text:
# Team Profile Generator

## License

[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

## Application

The walkthrough video can be seen here:
https://drive.google.com/file/d/1tZ0PG6lhk1sCBYZz8I27leQOYisQG9tF/view

## Technology Used

* Javascript
* Node.js
* Inquirer NPM Package
* Jest NPM Package

## Description

This Team Profile Generator will allow the user to create a simple web page that shows details for employees, including somedetails specific to the position held by the employee.

## Installation

1. Clone the Repo
  ```sh
  git@github.com:codyregis6891/team-profile-generator.git
  ```
2. All NPM packages required for this application are already listed as dependencies in the package.json file. Run the command 'npm i' command in your terminal at the root    directory level to install the packages.

3. Ensure you have Node.js installed on your machine. The application will be invoked by entering node index.js in the command line.

## Questions or Issues?

* Email<EMAIL_ADDRESS>* https://github.com/codyregis6891/team-profile-generator/issues


text:
---
title: Reading Week Progress (Part 2/2)
categories:
    -  General
author_staff_member: tsugumi
date: 2021-02-17 # needs to be a valid date (present or a past date)
---

## Intro.
After resolving hardware issues encountered, the robot is finally put into a single piece!

Robot powered up!

UV modulation test code implemented on the ESP32.

license: MIT

branch_name: refs/heads/main

extension: md

filename: 2021-02-17-Reading Week Progress_2.md

gha_language: SCSS

gha_license_id: MIT

license_type: permissive


text:
In this directory you will find 6 notebooks with varying levels of complexity. All follow a similar experiment, the details of which can be read at the beginning of ball_drop_1.ipynb, and ball_drop_2.ipynb.

  1. ball_drop_1.ipynb: details and implements the simplest of the ball drop experiments. We calibrate only 1 parameter.
  2. ball_drop_1_concise.ipynb: mimics ball_drop_1.ipynb but makes use of some sepia shortcuts
  3. ball_drop_1_ragged.ipynb: shows how to implement the ball drop problem with ragged observed data
  4. ball_drop_1_parallelchains.ipynb: how to implement parallel mcmc
  5. ball_drop_2.ipynb: implements the ball drop example but additionally estimates the coefficient of gravity
  6. ball_drop_2_ragged.ipynb: ball_drop_2.ipynb with ragged observed data

repository: lanl/SEPIA

branch_name: refs/heads/master

gha_language: Python

gha_license_id: NOASSERTION

repo_name: lanl/SEPIA


text:
# Leopard Binding for Rust

## Leopard Speech-to-Text Engine

Made in Vancouver, Canada by [Picovoice](https://picovoice.ai)

Leopard is an on-device speech-to-text engine. Leopard is:
- Private; All voice processing runs locally.
- [Accurate](https://picovoice.ai/docs/benchmark/stt/)
- [Compact and Computationally-Efficient](https://github.com/Picovoice/speech-to-text-benchmark#rtf)
- Cross-Platform:
    - Linux (x86_64), macOS (x86_64, arm64), Windows (x86_64)
    - Android and iOS
    - Chrome, Safari, Firefox, and Edge
    - Raspberry Pi (4, 3) and NVIDIA Jetson Nano

## Compatibility

- Rust 1.54+
- Runs on Linux (x86_64), macOS (x86_64, arm64), Windows (x86_64), Raspberry Pi (4, 3), and NVIDIA Jetson Nano.

## Installation

First you will need [Rust and Cargo](https://rustup.rs/) installed on your system.

To add the leopard library into your app, add `pv_leopard` to your apps `Cargo.toml` manifest:
```toml
[dependencies]
pv_leopard = "*"
```

If you prefer to clone the repo and use it locally, first run `copy.sh`.
(**NOTE:** on Windows, Git Bash or another bash shell is required, or you will have to manually copy the libs into the project).
Then you can reference the local binding location:
```toml
[dependencies]
pv_leopard = { path = "/path/to/rust/binding" }
```

## AccessKey

Leopard requires a valid Picovoice `AccessKey` at initialization. `AccessKey` acts as your credentials when using Leopard SDKs.
You can get your `AccessKey` for free. Make sure to keep your `AccessKey` secret.
Signup or Login to [Picovoice Console](https://console.picovoice.ai/) to get your `AccessKey`.

## Usage

Create an instance of the engine and transcribe an audio file:

```rust
use leopard::LeopardBuilder;

fn main() {
  let access_key = "${ACCESS_KEY}"; // AccessKey obtained from Picovoice Console (https://console.picovoice.ai/)

  let leopard: Leopard = LeopardBuilder::new().access_key(access_key).init().expect("Unable to create Leopard");
  if let Ok(leopard_transcript) = leopard.process_file("${AUDIO_PATH}") {
      println!("{}", leopard_transcript.transcript);
  }
}
```

Replace `${ACCESS_KEY}` with yours obtained from [Picovoice Console](https://console.picovoice.ai/) and
`${AUDIO_PATH}` to the path an audio file.

The model file contains the parameters for the Leopard engine. You may create bespoke language models using [Picovoice Console](https://console.picovoice.ai/) and then pass in the relevant file.

## Language Model

The Leopard Rust SDK comes preloaded with a default English language model (`.pv` file).
Default models for other supported languages can be found in [lib/common](../../lib/common).

Create custom language models using the [Picovoice Console](https://console.picovoice.ai/). Here you can train
language models with custom vocabulary and boost words in the existing vocabulary.

Pass in the `.pv` file via the `.model_path()` Builder argument:
```rust
let leopard: Leopard = LeopardBuilder::new()
    .access_key("${ACCESS_KEY}")
    .model_path("${MODEL_PATH}")
    .init()
    .expect("Unable to create Leopard");
```

## Demos

The [Leopard Rust demo project](https://github.com/Picovoice/leopard/tree/master/demo/rust) is a Rust console app that allows for processing real-time audio (i.e. microphone) and files using Leopard.

repository: Picovoice/leopard

repo_name: Picovoice/leopard


text:
# aframe-blink-controls

## [Live examples](https://jure.github.io/aframe-blink-controls)

## [Video demo](https://twitter.com/JureTriglav/status/1346502092282847234?s=20)

This component adds teleport with rotation to A-Frame applications! It's a modified version of the [`aframe-teleport-controls`](https://github.com/fernandojsg/aframe-teleport-controls) component by @fernandojsg, and the main changes are:
* added support for rotation,
* removed line teleport option,
* added support for thumbsticks,
* added snap turn support,
* calculation of parabolic roots for accurate longer teleport rays.

This is a work in progress to support an experimental project and currently only tested on: Oculus Quest, Oculus Quest 2.
Support for HTC Vive/Valve Index/HP Reverb G2 etc. controllers is only theoretical/untested, as I don't have a way of testing on these devices yet. PRs welcome!

## Properties

| Property    | Description                     | Default Value    |
| --------    | -----------                     | -------------    |
| cameraRig       | Selector of the camera Rig to teleport         |    |
| teleportOrigin | Selector of the child of cameraRig to use as the center point for teleporting, typically the camera. If set, teleporting will position the cameraRig such that this element ends up above the teleport location (rather than the center of the cameraRig) |    |
| collisionEntities | Selector of the meshes used to check the collisions. If no value provided a plane y = 0 is used |  |
| startEvents | Alternative to `button`, list of events to start teleporting.| [] |
| endEvents | Paired with `startEvents`, list of events to end teleporting.| []            |
| button       | Button used to launch the teleport: trackpad, trigger, grip, menu, thumbstick         |  |
| hitEntity | Entity used to show at the hitting position. If no value provided a cylinder will be used as default. |           |
| hitCylinderColor | Color used for the default `hitEntity` primitives | #4d93fd          |
| hitCylinderRadius | Radius used for the default `hitEntity` primitives | 0.25          |
| hitCylinderHeight | Height used for the default `hitEntity` primitives | 0.3 |
| curveHitColor | Color used for the curve when hit the mesh | #4d93fd          |
| curveMissColor | Color used for the curve when it doesn't hit anything | #ff0000          |
| curveNumberPoints | Number of points used in the curve | 50          |
| curveLineWidth | Line width of the curve | 0.025          |
| curveShootingSpeed | Curve shooting speed, as bigger value, farther distance. | 8          |
| interval            | Number of milliseconds to wait in between each intersection test. Lower number is better for faster updates. Higher number is better for performance.              | 0           |
| defaultPlaneSize | Default plane size | 100 |
| landingNormal | Normal vector to detect collisions with the `collisionEntity` | (0, 1, 0)          |
| landingMaxAngle | Angle threshold (in degrees) used together with `landingNormal` to detect if the mesh is too steep to jump to it. | 45          |
| drawIncrementally | If the ray should be drawn as an animation | true |
| incrementalDrawMs | How long the ray animation should be | 500 |
| snapTurn | If left/right thumbstick axis performs a 45 deg rotation | true |

### Usage

#### Directly in the browser

Use the script files directly, for example:

```html
<head>
  <title>My A-Frame Scene</title>
  <script src="https://aframe.io/releases/1.1.0/aframe.min.js"></script>
  <script src="https://cdn.jsdelivr.net/npm/aframe-blink-controls/dist/aframe-blink-controls.min.js"></script>
</head>

<body>
  <a-scene>
    <!-- camera rig -->
    <a-entity id="player">
      <!-- camera -->
      <a-entity id="camera" camera wasd-controls look-controls></a-entity>
      <!-- hand controls -->
      <a-entity id="left-hand" oculus-touch-controls="hand: left" blink-controls></a-entity>
      <a-entity id="right-hand" oculus-touch-controls="hand: right"></a-entity>
    </a-entity>
  </a-scene>
</body>
```

By default, this uses the **forward thumbstick axis to activate** the teleport, as that seems to be a familiar way across different applications and platforms, in addition to being pratical (as it does not require pressing buttons while also e.g. moving axes). When the teleport is active, you can also choose the direction you want to be facing (rotation) after teleporting, by using the thumbstick.

You can also use e.g. the trigger button instead of the thumbstick by adding `button: trigger` (or `trackpad`, `trigger`, `grip`, `menu`, `thumbstick`). Or specify `startEvents` and `endEvents` for specific use cases, though give the default bindings a try first!

For `collisionEntities`, you specify a selector for the objects that you want to calculate collisions with. By default this is a 100x100 plane at y = 0.

#### Installing via npm

Install via npm:

```bash
npm install aframe-blink-controls
```

Then require it: this will register the component globally.

```js
require('aframe-blink-controls');
```

### Development

Use `npm run dev` to run a development build with a number of provided examples on https://localhost:8080 (or alternatively your computer's IP on your network, e.g. for testing on standalone devices).

### Events

| Event      | Properties of `event.detail`             | Description                      |
|------------|------------------------------------------|----------------------------------|
| `teleported` | `oldPosition`, `newPosition`, `hitPoint`, `rotationQuaternion` | Fires when teleportation begins. |

repository: lamarrg/aframe-blink-controls

repo_name: lamarrg/aframe-blink-controls


text:
## Setting up the pipeline

There are multiple ways to set up the pipeline. There is a single
official prod mode, which can only be instantiated in Fedora under
the `fedora-coreos` namespace. However, one can set up everything
equally well in a separate namespace (such as `fedora-coreos-devel`), or
a separate cluster entirely.

The main tool to deploy and update these resource is `./deploy`, which
is located in this repo. It is a simple wrapper around
`oc process/create/replace` to make deploying and updating the various
resources located in the `manifests/pipeline.yaml` OpenShift template
easier. It will set up a Jenkins pipeline job which uses the
[Kubernetes Jenkins plugin](https://github.com/jenkinsci/kubernetes-plugin).

In the following sections, the section header may indicate whether the
section applies only to the local cluster case (`[LOCAL]`) or the
official prod case (`[PROD]`).

You'll want to be sure you have kubevirt available in your cluster.  See
[this section of the coreos-assembler docs](https://github.com/coreos/coreos-assembler/blob/main/README.md#getting-started---prerequisites).

### Using a production OpenShift cluster

This is recommended for production pipelines, and also gives you
a lot of flexibility.  The coreos-assembler document above has
multiple options for this.  To be clear, we would also likely
support running on "vanilla" Kubernetes if someone interested showed
up wanting that.

### [LOCAL] Set up an OpenShift cluster

The easiest way to set up your own local OCP4 cluster for developing on
the pipeline is using
[CodeReady Containers](https://code-ready.github.io/crc),
though the author has not yet tried setting up the pipeline on that
footprint yet. (You'll need to allocate the VM at least ~14G of RAM.)

Alternatively, you can use the OpenShift installer directly to create a
full cluster either in libvirt or GCP (for nested virt). For more
details, see:

https://github.com/openshift/installer/tree/master/docs/dev/libvirt
https://github.com/coreos/coreos-assembler/blob/main/doc/openshift-gcp-nested-virt.md

Once you have a cluster up, you will want to deploy the OpenShift CNV
operator for access to Kubevirt:

Install the operator using the web console:
https://docs.openshift.com/container-platform/4.9/virt/install/installing-virt-web.html#installing-virt-web

Altenatively, you can install the operator using the CLI:
https://docs.openshift.com/container-platform/4.9/virt/install/installing-virt-cli.html#installing-virt-cli

You can learn more about the OpenShift CNV operator here:
https://docs.openshift.com/container-platform/4.9/virt/virt-learn-more-about-openshift-virtualization.html

### [LOCAL] Create your project

It is preferable to match the project name used for prod in Fedora
(`fedora-coreos-pipeline`), but feel free to use a different project
name like `fedora-coreos-devel` if you'd like.

```
oc new-project fedora-coreos-pipeline
```

### [LOCAL] Fork the repo

If you're planning to test changes, it would be best to fork
this repo so that you do your work there. The workflow
requires a remote repo to which to push changes.

### [OPTIONAL] Creating AWS credentials configs

If you are in production where we upload builds to S3 OR you want to
test uploading to S3 as part of your pipeline development, you need to
create a credentials config as a secret within OpenShift.

First create files with your secret content:

```
cat <<'EOF' > /path/to/aws-build-upload-config
[default]
aws_access_key_id=keyid
aws_secret_access_key=key
EOF
```

Then create the secret in OpenShift:

```
oc create secret generic aws-build-upload-config \
    --from-literal=filename=aws_config_file \
    --from-file=data=/path/to/aws-build-upload-config
oc label secret/aws-build-upload-config \
    jenkins.io/credentials-type=secretFile
oc annotate secret/aws-build-upload-config \
    jenkins.io/credentials-description="AWS build upload credentials config"
```

We also have a second AWS config that can be used for running kola
tests. If you have a single account that has enough permissions for
both then you can use the same account for both uploading builds and
running kola tests (i.e. re-use secret from above). If not then
you can use a second set of credentials for the kola tests.

```
cat <<'EOF' > /path/to/aws-kola-tests-config
[default]
aws_access_key_id=keyid
aws_secret_access_key=key
EOF

oc create secret generic aws-kola-tests-config \
    --from-literal=filename=aws_config_file \
    --from-file=data=/path/to/aws-kola-tests-config
oc label secret/aws-kola-tests-config \
    jenkins.io/credentials-type=secretFile
oc annotate secret/aws-kola-tests-config \
    jenkins.io/credentials-description="AWS kola tests credentials config"
```

NOTE: For the prod pipeline these secrets can be found in BitWarden

### [OPTIONAL] Creating AWS GovCloud credentials configs

If you want to upload to AWS GovCloud you can create a separate
set of credentials for performing that action:

```
cat <<'EOF' > /path/to/aws-govcloud-image-upload-config
[default]
aws_access_key_id=keyid
aws_secret_access_key=key
EOF
```

Then create the secret in OpenShift:

```
oc create secret generic aws-govcloud-image-upload-config \
    --from-literal=filename=aws_config_file \
    --from-file=data=/path/to/aws-govcloud-image-upload-config
oc label secret/aws-govcloud-image-upload-config \
    jenkins.io/credentials-type=secretFile
oc annotate secret/aws-govcloud-image-upload-config \
    jenkins.io/credentials-description="AWS GovCloud image upload credentials config"
```

### [OPTIONAL] Creating GCP credentials configs

If you are in production where we upload images to GCP OR you want to
test uploading to GCP as part of your pipeline development, you need to
create a upload credentials for a service account as a secret within OpenShift.
For more information on creating a service account see
[the Google Cloud Docs](https://cloud.google.com/iam/docs/creating-managing-service-accounts#creating).

Once you have the json file that represents the credentials for your service account
from GCP, create the secret in OpenShift:

```
oc create secret generic gcp-image-upload-config \
    --from-literal=filename=gcp_config_file \
    --from-file=data=/path/to/upload-secret
oc label secret/gcp-image-upload-config \
    jenkins.io/credentials-type=secretFile
oc annotate secret/gcp-image-upload-config \
    jenkins.io/credentials-description="GCP Image upload credentials config"
```

We also have a second GCP config that can be used for running kola tests. If you have a
single account that you'd like to use for both image uploading and tests you can do that
assuming they have enough permissions.

```
oc create secret generic gcp-kola-tests-config \
    --from-literal=filename=gcp_config_file \
    --from-file=data=/path/to/kola-secret
oc label secret/gcp-kola-tests-config \
    jenkins.io/credentials-type=secretFile
oc annotate secret/gcp-kola-tests-config \
    jenkins.io/credentials-description="GCP kola tests credentials config"
```

NOTE: For the prod pipeline these secrets can be found in BitWarden

### [OPTIONAL] Creating Azure credentials configs

If you want to do image uploads or run kola tests against Azure
images you need to create a file called `azureCreds.json`. See the
[kola docs](https://github.com/coreos/coreos-assembler/blob/main/docs/mantle/credentials.md#azure)
for more information on those files.

Once you have the azureCreds.json for connecting to Azure, create the secrets in OpenShift:

```
oc create secret generic azure-image-upload-config \
    --from-literal=filename=azure_config_file \
    --from-file=data=/path/to/upload-secret
oc label secret/azure-image-upload-config \
    jenkins.io/credentials-type=secretFile
oc annotate secret/azure-image-upload-config \
    jenkins.io/credentials-description="Azure image upload credentials config"

oc create secret generic azure-kola-tests-config \
    --from-literal=filename=azure_config_file \
    --from-file=data=/path/to/kola-secret
oc label secret/azure-kola-tests-config \
    jenkins.io/credentials-type=secretFile
oc annotate secret/azure-kola-tests-config \
    jenkins.io/credentials-description="Azure kola tests credentials config"
```

NOTE: For the prod pipeline these secrets can be found in BitWarden

### [OPTIONAL] Creating OpenStack credentials configs

If you want to run kola tests against OpenStack images you need to
create a secret
([`clouds.yaml` format](https://docs.openstack.org/python-openstackclient/latest/configuration/index.html#clouds-yaml))
for talking with the OpenStack host.

Once you have the yaml file that represents the credentials for connecting
to your OpenStack instance, create the secret in OpenShift:

```
oc create secret generic openstack-kola-tests-config \
    --from-literal=filename=openstack_config_file \
    --from-file=data=/path/to/clouds.yaml
oc label secret/openstack-kola-tests-config \
    jenkins.io/credentials-type=secretFile
oc annotate secret/openstack-kola-tests-config \
    jenkins.io/credentials-description="OpenStack kola tests credentials config"
```

NOTE: For the prod pipeline these secrets can be found in BitWarden

### [OPTIONAL] Allocating S3 storage

If you want to store builds persistently, now is a good time to allocate
S3 storage.  See the [upstream coreos-assembler docs](https://github.com/coreos/coreos-assembler/blob/main/README-design.md)
around build architecture.

Today, the FCOS pipeline is oriented towards having its own
bucket; this will likely be fixed in the future.  But using your
credentials, you should now do e.g.:

```
$ aws s3 mb s3://my-fcos-bucket
```

And provide it to `--bucket` below when creating the pipeline with the `deploy` script.

To install the aws CLI needed for this steps see [installing or updating the latest version of the AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
To configure the aws CLI with your credentials see [quick configuration with aws configure](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-quickstart.html).

### [OPTIONAL] Slack integration

If you want to be able to have build status messages appear in Slack,
create a `slack-api-token` secret:

```
TOKEN=<token>
EMOJI=<:emojistring:>
oc create secret generic slack-api-token --from-literal=text="${TOKEN}"
oc label secret/slack-api-token \
    jenkins.io/credentials-type=secretText
oc annotate secret/slack-api-token \
    jenkins.io/credentials-description="Slack API token"
oc annotate secret/slack-api-token \
    jenkins.io/emoji-prefix="${EMOJI}"
```

You can obtain a token when creating a new instance of the Jenkins CI
app in your Slack workspace. The token used for the `coreos.slack.com`
workspace is available by going to the [Jenkins CI
app](https://slack.com/apps/A0F7VRFKN-jenkins-ci) then to
"Configuration" and "FCOS Pipeline".

### [OPTIONAL] Creating a secret for multi-arch builders

We can farm off builds to machines of other architectures. We use
SSH for this. To create a secret for one of these you can first
create files with your secret content:

```
dir=$(mktemp -d)
echo -n '<IP_ADDRESS>' > "${dir}/host"
echo -n 'builder'      > "${dir}/user"
echo -n '1001'         > "${dir}/uid"
cat /path/to/sshkey > "${dir}/sshkey"
```

Then create the secrets in OpenShift:

```
ARCH='aarch64'

oc create secret generic "coreos-${ARCH}-builder-host" \
    --from-file=text="${dir}/host"
oc label "secret/coreos-${ARCH}-builder-host" \
    jenkins.io/credentials-type=secretText
oc annotate "secret/coreos-${ARCH}-builder-host" \
    jenkins.io/credentials-description="Hostname or IP for the $ARCH builder"

oc create secret generic "coreos-${ARCH}-builder-uid" \
    --from-file=text="${dir}/uid"
oc label "secret/coreos-${ARCH}-builder-uid" \
    jenkins.io/credentials-type=secretText
oc annotate "secret/coreos-${ARCH}-builder-uid" \
    jenkins.io/credentials-description="UID for the user for $ARCH builder"

oc create secret generic "coreos-${ARCH}-builder-sshkey" \
    --from-file=username="${dir}/user" \
    --from-file=privateKey="${dir}/sshkey"
oc label "secret/coreos-${ARCH}-builder-sshkey" \
    jenkins.io/credentials-type=basicSSHUserPrivateKey
oc annotate "secret/coreos-${ARCH}-builder-sshkey" \
    jenkins.io/credentials-description="Username and Private SSH Key for $ARCH builder"
```

In the prod pipeline we create secrets for aarch64, ppc64le,
and x86_64 (for the build-cosa job).

NOTE: For x86_64 you need to use a hyphen/dash (`-`) instead of an
      underscore in the secret name: `coreos-x86-64-builder`.

NOTE: For the prod pipeline these secrets can be found in BitWarden

### [PROD] GitHub webhook shared secret

Create a shared webhook secret using e.g. `uuidgen -r`:

```
# use `echo -n` to make sure no newline is in the secret
echo -n "$(uuidgen -r)" > secret
oc create secret generic github-webhook-shared-secret --from-file=text=secret
oc label secret/github-webhook-shared-secret \
    jenkins.io/credentials-type=secretText
oc annotate secret/github-webhook-shared-secret \
    jenkins.io/credentials-description="GitHub Webhook Shared Secret"
```

NOTE: the secret will be used again when setting up the generic webhooks in the next section.

### [PROD] Setup webhooks for the Generic webhook plugin

Add a new webhook to the following repos:

- [`coreos/fedora-coreos-config`](https://github.com/coreos/fedora-coreos-config.git) for the `build-fcos-buildroot` job.
- [`coreos/coreos-assembler`](https://github.com/coreos/coreos-assembler.git) for the `build-cosa` job.

In this case we'll re-use the GitHub webhook shared secret text that
was created in the previous section. Add a webhook for each repo that
follows:

- Payload URL: `https://<JENKINS_URL>/generic-webhook-trigger/invoke?token=<JOB>`
    - replace `<JENKINS_URL>` with the URL of the jenkins instance
    - replace `<JOB>` with `build-fcos-buildroot` or `build-cosa` based on the repo you are adding the webhook to.
- Content Type: `application/json`
- Secret: Use the secret text from the GitHub webhook shared secret above

### [PROD] Create OSContainer image push secret

This secret is used to push the oscontainer and others to Quay.io.
The secret can be obtained from the `oscontainer-push-registry-secret` in BitWarden.

After obtaining the secret data you can create the Kubernetes secret via:

```
oc create secret generic oscontainer-push-registry-secret \
    --from-literal=filename=dockercfg \
    --from-file=data=oscontainer-push-registry-secret
oc label secret/oscontainer-push-registry-secret \
    jenkins.io/credentials-type=secretFile
oc annotate secret/oscontainer-push-registry-secret \
    jenkins.io/credentials-description="Push secret for registry for CoreOS OSContainer"
```

### [PROD] Create OSContainer image push secret for old location

This secret is used to push the oscontainer and others to the old registry. The
secret can be obtained from the `oscontainer-push-old-registry-secret` in
BitWarden.

After obtaining the secret data you can create the Kubernetes secret via:

```
oc create secret generic oscontainer-push-old-registry-secret \
    --from-literal=filename=dockercfg \
    --from-file=data=oscontainer-push-old-registry-secret
oc label secret/oscontainer-push-old-registry-secret \
    jenkins.io/credentials-type=secretFile
oc annotate secret/oscontainer-push-old-registry-secret \
    jenkins.io/credentials-description="Push secret for old registry for CoreOS OSContainer"
```

### [PROD] Create COSA image push secret

This secret is used to push COSA container image builds and FCOS buildroot
container image builds to Quay.io. The secret can be obtained from
the `cosa-push-registry-secret` in BitWarden.

After obtaining the secret data you can create the Kubernetes secret via:

```
oc create secret generic cosa-push-registry-secret \
    --from-literal=filename=dockercfg \
    --from-file=data=cosa-push-registry-secret
oc label secret/cosa-push-registry-secret \
    jenkins.io/credentials-type=secretFile
oc annotate secret/cosa-push-registry-secret \
    jenkins.io/credentials-description="Registry push secret for COSA and FCOS buildroot containers"
```

### [PROD] Create fedora-messaging configuration

First create the Fedora Messaging configuration secret:

```
oc create secret generic fedora-messaging-config \
    --from-literal=filename=fedmsg.toml \
    --from-file=data=configs/fedmsg.toml
oc label secret/fedora-messaging-config \
    jenkins.io/credentials-type=secretFile
oc annotate secret/fedora-messaging-config \
    jenkins.io/credentials-description="Fedora messaging fedmsg.toml"
```

Then add the client secrets:

```
oc create secret generic fedora-messaging-coreos-x509-cert \
    --from-literal=serverCaCertificate='unused' \
    --from-file=clientCertificate=coreos.crt \
    --from-file=clientKeySecret=coreos.key
oc label secret/fedora-messaging-coreos-x509-cert \
    jenkins.io/credentials-type=x509ClientCert
oc annotate secret/fedora-messaging-coreos-x509-cert \
    jenkins.io/credentials-description="Fedora messaging CoreOS x509 client cert"
```

You can obtain `coreos.crt` and `coreos.key` from BitWarden.

### [PROD] Create coreosbot GitHub token secrets

Create the CoreOS Bot (coreosbot) GitHub token secrets (this
corresponds to the "Fedora CoreOS pipeline" token of
coreosbot, with just `public_repo` and `admin:repo_hook`;
these creds are available in BitWarden).

We create two secrets here. One Username/Password (used by bump-lockfile and
sync-stream-metadata) and one SecretText (used by GitHub Plugin):

```
TOKEN=<TOKEN>
oc create secret generic github-coreosbot-token-text --from-literal=text=${TOKEN}
oc label secret/github-coreosbot-token-text \
    jenkins.io/credentials-type=secretText
oc annotate secret/github-coreosbot-token-text \
    jenkins.io/credentials-description="GitHub coreosbot token as text/string"

oc create secret generic github-coreosbot-token-username-password \
    --from-literal=username=coreosbot \
    --from-literal=password=${TOKEN}
oc label secret/github-coreosbot-token-username-password \
    jenkins.io/credentials-type=usernamePassword
oc annotate secret/github-coreosbot-token-username-password  \
    jenkins.io/credentials-description="GitHub coreosbot token as username/password"
```

### [PROD, OPTIONAL] Create additional root CA certificate secret

If an additional root CA certificate is needed, create it as
a secret. This assumes `ca.crt` is a file in the working directory:

```
oc create secret generic additional-root-ca-cert \
    --from-literal=filename=ca.crt --from-file=data=ca.crt
oc label secret/additional-root-ca-cert \
    jenkins.io/credentials-type=secretFile
oc annotate secret/additional-root-ca-cert \
    jenkins.io/credentials-description="Root certificate for XXX"
```

The description can be customized. All other fields must be
exactly as is.

### [OPTIONAL] Create splunk secret

The Splunk secret is actually a configuration stored in Bitwarden as
secret. It is optional and must be used for the internal RHCOS cluster.
Here you can see an example of the secret:

```
unclassified:
  splunkJenkinsInstallation:
    enabled: true
    globalPipelineFilter: true
    host: ***
    port: 8088
    splunkAppUrl: ***
    token: ***
    useSSL: true
```
To create it use:
```
oc create secret generic splunk-casc-cfg \
    --from-file=splunk.yaml
```
### [OPTIONAL] Create brew secrets (if uploading to Brew)

Brew requires a couple of secrets in order to work. All of them are
stored in Bitwarden.  We need the certificate (brew-ca), the keytab
(brew-keytab), the koji configuration (koji-conf) and the kerberos
configuration (krb5-conf). Make sure to meet the secret names, these
names are used in the brew job.

To create it use:
```
oc create secret generic brew-ca \
    --from-file=ca.crt
oc create secret generic brew-keytab \
    --from-file=brew.keytab
oc create secret generic koji-conf \
    --from-file=koji.conf
oc create secret generic krb5-conf \
    --from-file=krb5.conf
```

### Create a Jenkins instance with a persistent volume backing store

```
oc new-app --file=manifests/jenkins.yaml \
  --param=NAMESPACE=fedora-coreos-pipeline \
  --param=STORAGE_CLASS_NAME=ocs-storagecluster-ceph-rbd
```

Notice the `NAMESPACE` parameter. This makes the Jenkins controller use the
image from our namespace, which we'll create in the next step. (The
reason we create the app first is that otherwise OpenShift will
automatically instantiate Jenkins with default parameters when creating
the Jenkins pipeline).

The `STORAGE_CLASS_NAME` may be required depending on the cluster. If
using a development cluster, it normally isn't, and you can drop it. For
the Fedora prod cluster, use `ocs-storagecluster-ceph-rbd` as shown
above.

Now, create the Jenkins configmap:

```
oc create configmap jenkins-casc-cfg --from-file=jenkins/config
```

### Creating the pipeline

If working on the production pipeline, you may simply do:

```
./deploy
```

You may also want to provide additional switches depending on the
circumstances. Below are the available options:

- `--pipeline <URL>[@REF]`
    - Git source URL and optional git ref for pipeline Jenkinsfile.
- `--pipecfg <URL>[@REF]`
    - Git source URL and optional git ref for pipeline configuration, if
      not in-tree.

For example, to target a specific pipeline:

```
./deploy \
    --pipeline https://github.com/jlebon/fedora-coreos-pipeline
```

Or to build with the canonical pipeline but a different
pipecfg:

```
./deploy \
    --pipecfg https://github.com/jlebon/fedora-coreos-pipecfg
```

See `./deploy --help` for more information.

This will create:

1. the Jenkins controller imagestream,
2. the Jenkins agent imagestream,
3. the Jenkins agent BuildConfig (if a root CA cert was provided),
4. the jenkins-config configmap.

If a root CA cert was provided, we need to build the base images that
will bake in the cert in the controller and agent:

```
oc start-build --follow jenkins-with-cert
oc start-build --follow jenkins-agent-base-with-cert
```

We can now start an S2I build of the Jenkins controller:

```
oc start-build --follow jenkins-s2i
```

Once the Jenkins controller image is built, Jenkins should start up (verify
with `oc get pods`). Once the pod is marked READY, you should be able to
login to the Jenkins UI at https://jenkins-$NAMESPACE.$CLUSTER_URL/
(`oc get route jenkins` will show the URL). As previously noted, any
password works to log in as `developer`.

It may be a good idea to set the Kubernetes plugin to
[use DNS for service names](TROUBLESHOOTING.md#issue-for-jenkins-dns-names).

### Running the pipeline

Once Jenkins is ready, make sure that the seed job has been run successfully.

Once the seed job on Jenkins finishes successfully we can now start the
Fedora CoreOS pipeline! Go into the Jenkins UI and start the `build`
job.

### Updating the pipeline

The procedure is the same for updating the pipeline:

```
./deploy
```

Note any value you don't pass to `deploy` will be reset to its default
value from the `manifests/pipeline.yaml` OpenShift template. This is
currently as designed (see
[#65](https://github.com/coreos/fedora-coreos-pipeline/issues/65)).

### Triggering builds remotely

We use the OpenShift Login plugin for authentication. This plugin maps
OpenShift users to Jenkins users, including service accounts. So we can
use the `jenkins` service account (or really, any service account with
the `edit` role):

```
jenkins_uid=$(oc get sa jenkins -o jsonpath="{.metadata.uid}")
token_data=$(oc get secrets -o json | jq -r "[.items[] | select(
    .type == \"kubernetes.io/service-account-token\" and
    .metadata.annotations[\"kubernetes.io/service-account.name\"] == \"jenkins\" and
    .metadata.annotations[\"kubernetes.io/service-account.uid\"] == \"${jenkins_uid}\"
)] | .[0].data.token" | base64 -d)
curl -H "Authorization: Bearer ${token_data}" $JENKINS_URL/job/build/buildWithParameters --data STREAM=4.13
```

See the
[OpenShift Login plugin docs](https://github.com/jenkinsci/openshift-login-plugin#non-browser-access)
for more information.

### Nuking everything

One can leverage Kubernetes labels to delete all objects
related to the pipeline:

```
oc delete all -l app=coreos-pipeline
```

This won't delete a few resources. Notably the PVC and the
SA. Deleting the PVC is usually not recommended since it may
require cluster admin access to reallocate it in the future
(if it doesn't, feel free to delete it!). To delete the
other objects:

```
oc delete serviceaccounts -l app=coreos-pipeline
oc delete rolebindings -l app=coreos-pipeline
oc delete configmaps -l app=coreos-pipeline
```

repository: coreos/fedora-coreos-pipeline

gha_language: Groovy

repo_name: coreos/fedora-coreos-pipeline


text:
---
layout: default
---

# 1993-03-12 - Re: CYPHERPUNKS=EMAIL HARASSEMENT?

## Header Data

From: Mark C. Henderson<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: 65922f15c3526dd9bb9d96749044651a57c64251ad4e24decbadbcf5538154ab

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1993-03-12 07:18:36 UTC

Raw Date: Thu, 11 Mar 93 23:18:36 PST

## Raw message

```
{% raw  %}From: Mark C. Henderson<EMAIL_ADDRESS>Date: Thu, 11 Mar 93 23:18:36 PST
To<EMAIL_ADDRESS>Subject: Re: CYPHERPUNKS=EMAIL HARASSEMENT?
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

-----BEGIN PGP SIGNED MESSAGE-----

Subject: Re: CYPHERPUNKS=EMAIL HARASSEMENT?

On Mar 11, 21:16, Michael Brennan wrote:
} Subject: Re: CYPHERPUNKS=EMAIL HARASSEMENT?
}
} Brushing this matter aside as a non-issue and pretending there is no
} problem will not make the problem go away! UNSUBSCRIBE REQUESTS SENT TO
} CYPHERPUNKS-REQUEST ARE BEING IGNORED!!!

Well, sending a 3000 line file to hundreds of people, wasn't the
correct response to the situation.

But, to add something constructive, why don't we use majordomo to
handle list additions and delections automatically?

Mark

- --
Mark Henderson
<EMAIL_ADDRESS><EMAIL_ADDRESS>
-----BEGIN PGP SIGNATURE-----
Version: 2.2

iQCVAgUBK6A2sPfE/ap/JEqpAQEK6AQAqejFaX3122HwrkLibTYr/rEGEoL6qpSv
sSn2oVxoOJXc+R52P8RCZzfp/X0O5tp92tUf4sAL2YKIlb72W2y9rXZ9TXMxpmxi
AgRqqpts1uoKAfUMBaM9Lr0QJ2V7fnMRjOJiu2mU/bSbC4Tzr15reKjmhkQDDZXo
FoybTVchSEw=
=3DYZ
-----END PGP SIGNATURE-----

{% endraw %}
```

## Thread

+ Return to [March 1993](/archive/1993/03)

+ Return to "[Mark C. Henderson <markh@wimsey.bc.ca>](/authors/mark_c_henderson_markh_at_wimsey_bc_ca_)"

+ 1993-03-12 (Thu, 11 Mar 93 23:18:36 PST) - Re: CYPHERPUNKS=EMAIL HARASSEMENT? - _Mark C. Henderson<EMAIL_ADDRESS>


text:
---
layout: post
title: '/etc/init.d/zope2.8 restart on Ubuntu '
tags: [plone]
redirect_from: /blog/archive/2006/04/18/etcinitdzope28-restart-on-ubuntu-
---

*/etc/init.d/zope2.8 restart* didn't work on my Ubuntu Server 5.10. It
turns out that it's using Ubuntu's homebrewn *dzhandle* script to handle
plone instances. You are supposed to create instances using dzhandle. If
you do, there'll be a file named *debian\_policy* in the *etc* directory
of the instance, and if that file exists, dzhandle will recognize the
instance and happily restart it.


text:
# CX AST Manipulation API

AST Api is used to add, change, and/or remove packages, functions, expressions, function inputs, function outputs, expression inputs, expression outputs, structs, and globals of a CX Program.

# Usage

Examples of api usage can be found inside the tests of the api.
For packages manipulation example, you can refer to packages_test.go.
For functions manipulation example, you can refer to functions_test.go.
For expressions manipulation example, you can refer to expressions_test.go.
For arguments manipulation example, you can refer to arguments_test.go.

repository: skycoin/cx

branch_name: refs/heads/develop

gha_language: Go

repo_name: skycoin/cx


text:
---
layout: "post.11ty.js"
title: "Salesforce Mobile SDK and Ionic – Styling Actions - Part II"
date: "2017-08-18"
tags:
  - "Blog"
  - "Cordova"
  - "IonicFramework"
  - "Salesforce"
  - "SalesforceDeveloper"
slug: "salesforce-mobile-sdk-ionic-styling-actions-part-ii"
coverImage: "Screen-Shot-2017-08-18-at-9.53.51-PM.png"
---

Since we left off in the middle of updating the looks of the actions on our Contact Details page we should probably get back to it.

## More `contact-detail.ts` Updates

The last thing we are going to do is add a method called something like `showActions`, of course, you may choose a different name if that is fancy though.

This method will use the `ActionSheetController` we added as an `import` and injected into the `constructor` as `actionSheetCtrl` to create a new Action Sheet.  In the process of calling create we will pass in an options object that will have a `title` property that will have a value of a string and a `buttons` property.  The `buttons` property will have a value of an array of buttons.

For the title we can use a string template and put the name of the contact we are on.

For the buttons each will have a `title`, an `icon` (provided it's not ios) and a `handler`.  Some buttons will have a `role` property to help position, or color the button depending on the role.

#### `showAction` Method

showActions() {
  let actionSheet = this.actionSheetCtrl.create({
    title: \`Modify ${this.contact.Name}?\`,
    buttons: \[
      {
        text: 'Delete',
        role: 'destructive',
        icon: !this.platform.is('ios') ? 'trash' : null,
        handler: () => {
          actionSheet.onDidDismiss(() => {

            this.deleteContact();
          });
        }
      },
      {
        text: 'Edit',
        icon: !this.platform.is('ios') ? 'build' : null,
        handler: () => {

          actionSheet.onDidDismiss(() => {

            this.updateContact();
          });
        }
      },
      {
        text: 'Cancel',
        role: 'cancel',
        icon: !this.platform.is('ios') ? 'close' : null
      }
    \]
  });

  actionSheet.present();
}

For the button handlers you can see we are calling the `deleteContact` or `updateContact` depending on the button selected when the `onDidDismiss` event it called.

Using `onDidDismiss` allows you to wait till the Action Sheet has been dismissed before calling a followup action or even that may have conflicts if used at the same time.   With out using `onDidDismiss` the Alert Controller's buttons would trigger the methods called but would not dismiss the alert window.

With all that set we will need to update our markup before we can see it in action.

## Update `contact-details.html`

On the `contact-details.html` we will need to remove the buttons we already have in place.  So go on an delete the `Edit` and `Delete` buttons.

With those gone we will add an `ion-footer` that contains an `ion-toolbar`.  The ion-toolbar will contain an `ion-buttons` that has one `button`.  That `button` will have a click handler that calls the `showActions` method.   I'm also going to have the button have text that says `Modify` and an `ion-icon` with a `name` of `settings` so that we the international symbol for change things.... a gear.

The updated `contact-details.html` should look something like this.

#### Updated `contact-details.html`

<ion-header>
  <ion-navbar>
    <button ion-button menuToggle>
      <ion-icon name="menu"></ion-icon>
    </button>
    <ion-title>
      <ion-icon name="contact"></ion-icon> {{contact.Name}}</ion-title>
  </ion-navbar>
</ion-header>

<ion-content padding>

First Name

{{contact.FirstName}}

Last Name

{{contact.LastName}}

Email

{{contact.Email}}

Mobile Phone

{{contact.MobilePhone}}

</ion-content>

<ion-footer>
  <ion-toolbar>
    <ion-buttons end>
      <button ion-button icon-right (click)="showActions()">
        Modify
        <ion-icon name="settings"></ion-icon>
      </button>
    </ion-buttons>
  </ion-toolbar>
</ion-footer>

And now we should be able to run it.

## Run It

Now let's see how it looks when we run it on Android and iOS.

#### Run It

## ![Run It](images/mobile-22-00-1.gif)

Well that looks a little better.

## Conclusion

Don’t forget to sign up for [**The Weekly Stand-Up!**](https://wipdeveloper.wpcomstaging.com/newsletter/) to receive free the [WIP Developer.com](https://wipdeveloper.wpcomstaging.com/) weekly newsletter every Sunday!

Looking for the code and want to follow along?  Find it on [GitHub.com/BrettMN/salesforce-sdk-mobile-with-ionic-starter](https://github.com/BrettMN/salesforce-sdk-mobile-with-ionic-starter)

repository: BrettMN/wipdeveloper-wordpress-archive

repo_name: BrettMN/wipdeveloper-wordpress-archive


text:
Anonymize IPs from Apache logs
==============================

This reads a line from STDIN, searches for IPv4 addresses,
and replaces the last digit group with "0". It then appends
the resulting line to the filename passed as first argument to
this script.

Example
-------

This call:

    111.222.333.444 foolog

... will append this line to the file `foolog`:

    111.222.333.0

Usage in Apache config
----------------------

Make sure that `anonymize-ip` is in Apache's path or use an absolute path below:

    ErrorLog     "|anonymize-ip /opt/www/mysite/log/error.log"
    CustomLog    "|anonymize-ip /opt/www/mysite/log/access.log" combined

repository: triskweline/anonymize-ip

gha_language: Shell

repo_name: triskweline/anonymize-ip


text:
lequipe_stats
=============

Tool to build a time histogram for the lequipe 10km running race that took place in Paris, on June 23rd 2013.

Took race and want to see how you stack up?
Interested in knowing what the typical time distribution is for a big 10km race?

Then look at the graph which was generated with that tool:
https://docs.google.com/spreadsheet/ccc?key=0Agc25NQf3T7gdHlNcXczZF93R3laNGEyTzRpZjBHM1E#gid=1

Distributed under the [MIT License](http://creativecommons.org/licenses/MIT/)


text:
# _The Most Amazing E-Commerce Site_

#### _This is a Ruby on Rails E-Commerce Application that includes login functionality, a shopping cart, and Stripe.  July 14, 2017_

#### By _**Asia Kane**_

## Description

This is an E-Commerce application is for both customers (users) and store managers (admins).  It uses AJAX to improve user experience and includes `stripe`, `bcrypt` and `materialize`.

Users can:
- Create an account
- Login/Logout of their account
- View all products on one page
- Add items to their shopping cart
- Visit their shopping cart to view total price and/or remove items from their cart

User Stories using AJAX:
- Users can add products to their shopping cart from the index page with AJAX. The total item count in the nav bar updates.
- Users can click on a product and show/hide the product detail using AJAX.
- Users can remove items from the shopping cart without a page reload.  The total order price and item count in the nav bar updates.

Additional Features:
- Includes Stripe so users can pay when finalizing orders.
- Flash messages included for signing up, signing in and signing out.
- Only admins can add, update and delete a product.
- Flash messages for adding, updating and deleting products.
- Admin link in nav bar so admins can easily add, update and delete products.
- Allow other than whole dollar amounts for price (e.g. 12.99).

The application structure is outlined below.

Models:
  - Users
  - Products
  - Orders
  - Order Items

## Database Seeding

The application is seeded using `faker`.

* Note: There is one admin user seeded in the database.  An admin can only be added by seeding the database to prevent any user from accessing admin functionality.  To access the admin account, login using:

* Email<EMAIL_ADDRESS>* Password: "password123456"

## Prerequisites

You will need the following things properly installed on your computer.

* [Git](https://git-scm.com/)
* [Postgres](https://www.postgresql.org/)
* [Ruby](https://www.ruby-lang.org/en/downloads/)
* [Rails](http://rubyonrails.org/)

## Installation

In your terminal:
* `git clone https://github.com/akane0915/went-to-bali-mwahaha`
* `cd went-to-bali-mwahaha`
* `bundle install`
* Open another terminal window and type `postgres`.  Leave this window open.
* In your first terminal window type:
* `bundle exec rake db:setup`
* `bundle exec rake db:test:prepare`

This application uses Stripe.  To configure, you must create a stripe account and a .env file at the top level of your project directory.  In the file, include (replacing the text in quotes with your own keys):

* PUBLISHABLE_KEY="Your publishable key from stripe here"
* SECRET_KEY="Your secret key from stripe here"

## Development server

Run `bundle exec rails s` for a dev server. Navigate to `http://localhost:3000/`. The app will automatically reload if you change any of the source files.

* If you would like to make changes to this project, do so in a text editor.
* Make frequent commits with detailed comments.
* Submit changes as pull request to Asia at akane0915 on Github.

## Running tests

This app uses RSpec and Shouldamatchers for testing.
Run `bundle exec rspec` in terminal to test.

## Technologies Used

* Ruby
* Rails
* AJAX
* Stripe
* ActiveRecord
* Postgres
* Bundler
* Rake Gem
* Bcrypt Gem
* HTML
* CSS
* Bootstrap
* ES6

## Known Bugs
_N/A_

## Support and contact details
_I encourage you to update/make suggestions/refactor this code as you see fit. I am always open to improvement! Please contact Asia Kane at<EMAIL_ADDRESS>with questions._

### License
*This software is licensed under the MIT license*
Copyright © 2017 **Asia Kane**

gha_language: Ruby


text:
# Flappy Birds with genetic algorithm 🐣 🐥 🐦
## Simulation of Flappy Birds game using a simple neural network and genetic evolution strategy

![screenshot](screenshots/sc1.png)

## How does it work?
We create a large population of birds that try to fly over the pipes. When all of them have died (crashed against the pipes) we copy the **brain** of the bird that went further and create another generation with that brain and some mutation (changes). We repeat it over and over until we get one or several birds that do not crash against the pipes.

The brain of each bird is a simple neural network with 5 input nodes, one hidden layer with 8 nodes and the output layer with 2 nodes and softmax as activation function *(jump or not to jump)*

[Go to live demo](https://mrm8488.github.io/flappy_birds_genetic_evol/index.html)

### Network diagram:

![Network schema](screenshots/nn.png)


text:
# Build OpenVINO™ Runtime for Windows systems

OpenVINO can be compiled for different architectures on Windows: X64 or ARM64. In order to build for ARM64 architecture, the machine with Windows on ARM is required as only native compilation is supported (see [similar documents](https://www.linaro.org/blog/how-to-set-up-windows-on-arm-for-llvm-development/#:~:text=Install%20the%20Latest%20LLVM%20for,PATH%20yourself%2C%20as%20described%20above.) for details).

Supported configurations:
- Windows 10 x86 64-bit or higher with Visual Studio 2019 or higher build for X64 architecture.
- Windows on ARM (shortly WoA) to build for ARM64 architecture. OpenVINO was validated on [Windows DevKit 2023](https://developer.qualcomm.com/hardware/windows-on-snapdragon/windows-dev-kit-2023)

## Software requirements

- [CMake](https://cmake.org/download/) 3.13 or higher
- Microsoft Visual Studio 2019 or higher, version 16.3 or later
  > **NOTE**: Native Microsoft Visual Studio for WoA is available since 2022.
- Python 3.7 - 3.11 for OpenVINO Runtime Python API
  > **NOTE**: Python for ARM64 is available since [3.11](https://www.python.org/downloads/windows/) version.
- [Git for Windows*]
- (Windows on ARM only) [LLVM for Windows on ARM (WoA)](https://github.com/llvm/llvm-project/releases/download/llvmorg-15.0.6/LLVM-15.0.6-woa64.exe)
  > **NOTE**: After installation, make sure `clang-cl` compiler is available from `PATH`.

## How to build

> **NOTE**: By default, the build enables the OpenVINO Runtime GPU plugin to infer models on your Intel® Processor Graphics. This requires you to download and install the Intel® Graphics Driver for Windows (26.20) [driver package](https://www.intel.com/content/www/us/en/download/19344/intel-graphics-windows-dch-drivers.html) before running the build. If you don't want to use the GPU plugin, use the `-DENABLE_INTEL_GPU=OFF` CMake build option and skip the installation of the Intel® Graphics Driver.

1. Clone submodules:
    ```sh
    git clone https://github.com/openvinotoolkit/openvino.git
    cd openvino
    git submodule update --init --recursive
    ```
   (Extra for WoA) To build on Windows on ARM with ARM plugin:
    ```sh
    git clone https://github.com/openvinotoolkit/openvino_contrib.git
    cd openvino_contrib
    git submodule update --init --recursive
    ```

2. Create build directory:
    ```sh
    mkdir build && cd build
    ```
3. In the `build` directory, run `cmake` to fetch project dependencies and generate a Visual Studio solution.

   On Windows x86 64-bits:
    ```sh
    cmake -G "Visual Studio 16 2019" -DCMAKE_BUILD_TYPE=Release <openvino>
    ```

   On Windows on ARM for ARM64 architecture:
    ```sh
    cmake -G "Visual Studio 16 2019" -DOPENVINO_EXTRA_MODULES=<openvino_contrib>/modules/arm_plugin -DCMAKE_BUILD_TYPE=Release <openvino>
    ```

4. Build generated solution in Visual Studio or run `cmake --build . --config Release --verbose -j8` to build from the command line. Be aware that this process may take some time.

5. Before running the samples, add paths to the Threading Building Blocks (TBB) binaries used for the build to the `%PATH%` environment variable. By default, TBB binaries are downloaded by the CMake-based script to the `<openvino>/temp/tbb/bin` folder.

### Additional Build Options

- Internal JIT GEMM implementation is used by default.

- Threading Building Blocks (TBB) is used by default. To build Inference Engine with OpenMP threading, set the `-DTHREADING=OMP` option.

- Required versions of TBB and OpenCV packages are downloaded automatically by the CMake-based script. If you want to use the automatically-downloaded packages but you have already installed TBB or OpenCV packages configured in your environment, you may need to clean the `TBBROOT` and `OpenCV_DIR` environment variables before running the `cmake` command; otherwise they won'tnbe downloaded and the build may fail if incompatible versions were installed.

- If the CMake-based build script can not find and download the OpenCV package that is supported on your platform, or if you want to use a custom build of the OpenCV library, refer to the [Use Custom OpenCV Builds](./cmake_options_for_custom_compilation.md#Building-with-custom-OpenCV) section for details.

- To build the OpenVINO Runtime Python API:
  1. First, install all additional packages (e.g., cython and opencv) listed in the file:
      ```sh
      pip install -r <openvino>\src\bindings\python\src\compatibility\openvino\requirements-dev.txt
      ```
  2. Second, enable the `-DENABLE_PYTHON=ON` in the CMake (Step #4) option above. To specify an exact Python version, use the following options:
     ```sh
     -DPYTHON_EXECUTABLE="C:\Program Files\Python11\python.exe" ^
     -DPYTHON_LIBRARY="C:\Program Files\Python11\libs\python11.lib" ^
     -DPYTHON_INCLUDE_DIR="C:\Program Files\Python11\include"
     ```
  3. To build a wheel package (.whl), enable the `-DENABLE_WHEEL=ON` option in the CMake step above (Step 4), and install requirements:
     ```sh
     pip install -r <openvino source tree>\src\bindings\python\wheel\requirements-dev.txt
     ```
  4. After the build process finishes, export the newly built Python libraries to the user environment variables:
     ```
     set PYTHONPATH=<openvino_repo>/bin/<arch>/Release/python;%PYTHONPATH%
     set OPENVINO_LIB_PATHS=<openvino_repo>/bin/<arch>/Release;%OPENVINO_LIB_PATH%
     ```
     or install the wheel with pip:
     ```
     pip install build/wheel/openvino-2023.0.0-9612-cp11-cp11-win_arm64.whl
     ```

- OpenVINO runtime compilation options:
  `-DENABLE_OV_ONNX_FRONTEND=ON` enables the building of the ONNX importer.

### Building OpenVINO with Ninja* Build System

```sh
call "C:\Program Files (x86)\Microsoft Visual Studio\2019\Professional\VC\Auxiliary\Build\vcvars64.bat"
cmake -G Ninja -Wno-dev -DCMAKE_BUILD_TYPE=Release ..
cmake --build . --config Release
```

## See also

 * [OpenVINO README](../../README.md)
 * [OpenVINO Developer Documentation](index.md)
 * [OpenVINO Get Started](./get_started.md)
 * [How to build OpenVINO](build.md)

repository: openvinotoolkit/openvino

repo_name: openvinotoolkit/openvino


text:
# pb-to-typescript

## Intro

A converter to transform from Protobuf to Typescript definition files, which is inspired by [geotho/protobuf-to-typescript](https://github.com/geotho/protobuf-to-typescript). However, this converter is powered by [protobuf.js](https://github.com/protobufjs/protobuf.js), which is more tend to regularity and principle.

Protobuf is currently used in micro-service for back end. As a front end web developer, you can generate Typescript defination files based on Protobuf in case to develop your web page easily.

- [pbts](./packages/core)
- [pbts-web](./packages/web)
- [pbts-vscode](./packages/vscode)

## Demo

[Live Demo](https://brandonxiang.github.io/pb-to-typescript/)

## License

[MIT](LICENSE)

repository: brandonxiang/pb-to-typescript

gha_language: TypeScript

repo_name: brandonxiang/pb-to-typescript


text:
atmega
======

ATmega breadboard library for Arduino 1.5 IDE

I created this hardware definition for the Arduino 1.5 IDE becuase I could not find anything that worked.  I have many ATmega8 chips that I like to breadboard with and the Arduino IDE is convenient to use even without the fancy bootloaders.  To use, place the atmega directory inside the Arduino hardware directory.  On a Mac, this is located at ~/Documents/Arduino/hardware.

Restart the Arduino IDE and you should see under Tools/Board a menu ATmega.  After selecting, then a Processor and Clock menu option should show up.

Many thanks to damellis/attiny for showing me a pattern to use for the new Auduino IDE configuration files.  The Arduino documentation is still a work-in-progress IMHO.

This was tested with the 1.5.4 beta.

repository: chuckb/atmega

repo_name: chuckb/atmega


text:
# iso7064
ISO7064 implementation to compute and verify check digits (+ IBAN is implemented too)

## Installation
To install `iso7064` you need to, as usual, run this command:
```sh
go get github.com/pkosilo/iso7064
```

## How to use?
First of all you need to create a new `Calculator` to compute and verify ISO7064 check digits.
`BaseCalculator` and `IBANCalculator` are interfaces of `Calculator`, they implement methods
like `Verify(input string) (bool, error)`, `Compute(input string) (string, error)` and
`ComputeChars(input string) (string, error)`. So, you just need to create their instances using
one of the methods below

### IBAN
To create IBAN compatible `Calculator` you need to do something like this:
```golang
calc := iso7064.NewIBANCalculator()
```
It will create an instance of `IBANCalculator` which will have `BaseCalculator` to compute
check digits according to ISO7064 MOD97-10, but also will automatically rearrange input string,
replace letters with digits and etc. **Remember**, that you need to add a placeholder for check
digits when you compute with `IBANCalculator`, it can be any digit-only placeholder (preferred one
is `00`)

### MOD11-2
To create ISO7064 MOD11-2 compatible `Calculator` you need to do:
```golang
calc := iso7064.NewMod112Calculator()
```
It will return `BaseCalculator` instance with `Modulus` equal to `11`, `Radix` equal to `2`,
`Charset` equal to `0123456789X` and `IsDouble` equal to `false`.

### MOD37-2
To create ISO7064 MOD37-2 compatible `Calculator` you need to do:
```golang
calc := iso7064.NewMod372Calculator()
```
It will return `BaseCalculator` instance with `Modulus` equal to `37`, `Radix` equal to `2`,
`Charset` equal to `0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ*` and `IsDouble` equal to `false`.

### MOD97-10
To create ISO7064 MOD97-10 compatible `Calculator` you need to do:
```golang
calc := iso7064.NewMod9710Calculator()
```
It will return `BaseCalculator` instance with `Modulus` equal to `97`, `Radix` equal to `10`,
`Charset` equal to `0123456789` and `IsDouble` equal to `true`.

### MOD661-26
To create ISO7064 MOD661-26 compatible `Calculator` you need to do:
```golang
calc := iso7064.NewMod66126Calculator()
```
It will return `BaseCalculator` instance with `Modulus` equal to `661`, `Radix` equal to `26`,
`Charset` equal to `ABCDEFGHIJKLMNOPQRSTUVWXYZ` and `IsDouble` equal to `true`.

### MOD1271-36
To create ISO7064 MOD1271-36 compatible `Calculator` you need to do:
```golang
calc := iso7064.NewMod127136Calculator()
```
It will return `BaseCalculator` instance with `Modulus` equal to `1271`, `Radix` equal to `36`,
`Charset` equal to `0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ` and `IsDouble` equal to `true`.

### BaseCalculator
As you may spot in examples before, functions `NewMod****Calculator` always return `BaseCalculator`
with different `Modulus`, `Radix`, `Charset` and `IsDouble`. So, it means that `BaseController` can
take any `Modulus`, `Radix`, `Charset` and `IsDouble`, and you can create your own custom `BaseCalculator`:
```golang
calc := &iso7064.BaseCalculator {
  Modulus:  97,
  Radix:    10,
  Charset:  "0123456789",
  IsDouble: true,
}
```

### Compute and verify
#### Verify(input string) (bool, error)
To verify existing string that it has correct check digits, you need to do:
```golang
input := "1234123435"

calc := iso7064.NewMod9710Calculator()
correct, err := calc.Verify(input)
fmt.Println(correct, err) // Will return `true <nil>`
```
In case of an error it will return `false` and error itself. Error may happen if
the `input` is too short (shorter or equal to check digits length), the `input` has
`InvalidRune`, which is not present in the `Charset`.

#### Compute(input string) (string, error)
This function will return `input` string the check digits added to it. If it is `BaseCalculator`,
check digits will be located at the end of the string. It it is `IBANCalculator`, they will be
located at position 2-3 (couting from zero, remember) in the output string. **Remember**, you
need to add a placeholder for check digits if you use `IBANCalculator` (**again** preferred one
is `00`).
```golang
input := "12341234"

calc := iso7064.NewMod9710Calculator()
computed, err := calc.Compute(input)
fmt.Println(computed, err) // Will return `1234123435 <nil>`
```

#### ComputeChars(input string) (string, error)
This function will return `input` string the check digits added to it. If it is `BaseCalculator`,
check digits will be located at the end of the string. It it is `IBANCalculator`, they will be
located at position 2-3 (couting from zero, remember) in the output string. **Remember**, you
need to add a placeholder for check digits if you use `IBANCalculator` (**again** preferred one
is `00`).
```golang
input := "12341234"

calc := iso7064.NewMod9710Calculator()
computedChars, err := calc.ComputeChars(input)
fmt.Println(computedChars, err) // Will return `35 <nil>`
```


text:
# BigNerdRanch-Android

This repo contains my implementation of the book **Android Programming: The Big Nerd Ranch Guide** on its second edition.

![](cover.jpg)

The result of following every chapter of the book can be found on its own branch. Once a chapter is completed, it wil be merged to master which eventually will containt the final result of the book.

Content (Roadmap)
=================

| Chapter | Title                                             | Status|
|---------|:-------------------------------------------------:|:-----:|
| 1       | Your First Android Application                    | ✅
| 2       | Android and Model-View-Controller                 | ✅
| 3       | The Activity Lifecycle                            | ✅
| 4       | Debugging Android Apps                            | ✅
| 5       | Your Second Activity                              | ✅
| 6       | Android SDK Versions and Compatibility            | ✅
| 7       | UI Fragments and the Fragment Manager             | ✅
| 8       | Creating User Interfaces with Layouts and Widgets | ✅
| 9       | Displaying Lists with RecyclerView                | ✅
| 10      | Using Fragments Arguments                         | ✅
| 11      | Using ViewPager                                   | ✅
| 12      | Dialogs                                           | ✅
| 13      | The Toolbar                                       | ✅
| 14      | SQLite Databases                                  | ✅
| 15      | Implicit Intents                                  | ✅
| 16      | Taking Pictures with Intents                      | ✅
| 17      | Two-Pane Master-Detail Interfaces                 | ✅
| 18      | Assets                                            | ✅
| 19      | Audio Playback with SoundPool                     | ✅
| 20      | Styles and Themes                                 | ✅
| 21      | XML Drawables                                     | ✅
| 22      | More About Intents and Tasks                      | ✅
| 23      | HTTP & Background Tasks                           | ✅
| 24      | Loopers, Handlers, and HandlerThread              | ✅
| 25      | Search                                            | ♻  Branch Chapter-25-Search
| 26      | Background Services                               |
| 27      | Broadcast Intents                                 |
| 28      | Browsing the Web and WebView                      |
| 29      | Custom Views and Touch Events                     |
| 30      | Property Animation                                |
| 31      | Locations and Play Services                       |
| 32      | Maps                                              |
| 33      | Material Design                                   |
| 34      | Afterword                                         |

repository: vishistv/BigNerdRanch-Android

repo_name: vishistv/BigNerdRanch-Android


text:
# Scala.js typings for linq

Typings are for version 4.0.1

## Library description:
linq.js - LINQ for JavaScript

|                    |                 |
| ------------------ | :-------------: |
| Full name          | linq |
| Keywords           | linq |
| # releases         | 4 |
| # dependents       | 0.0 |
| # downloads        |<PHONE_NUMBER>3333334 |
| # stars            | 1495.0 |

## Links
- [Homepage](https://github.com/mihaifm/linq)
- [Bugs](https://github.com/mihaifm/linq/issues)
- [Repository](https://github.com/mihaifm/linq)
- [Npm](https://www.npmjs.com/package/linq)

## Note
This library has been generated from typescript code from first party type definitions.

Provided with :purple_heart: from [ScalablyTyped](https://github.com/oyvindberg/ScalablyTyped)

## Usage
See [the main readme](../../readme.md) for instructions.

repository: ScalablyTyped/Distribution

repo_name: ScalablyTyped/Distribution


text:
---
layout: post
title: Pride and Prejudice - Find which character is famous using Apache PIG
description: A simple PIG program to count the number of times each characters name has appeared in the book pride and prejudice.
categories: [hadoop-tutorials,apache-pig]
tags: [pig]
fullview: false
comments: true

---

In this tutorial, we are going to take the simple word count example and spice it up. We are going to use Apache PIG to determine the number of times each characters name has appeared in the book pride and prejudice.

If you have not installed PIG - please follow the steps in this tutorial.

  - [Installing Apache PIG on MAC OS](/hadoop-tutorials/apache-pig/2016/06/15/install-apache-pig.html)

Lets get started !!!

Just for reference, these are the main characters we are going to look for. I'm going by their first names.

- Catherine
- Elizabeth
- Collins
- George
- Jane
- Lydia
- Caroline
- Kitty
- Charles

**Step 1: Download the book**

```
wget https://s3.amazonaws.com/omairaasim.github.io/data/pride_and_prejudice.txt
```

**Step 2: Copy the book into HDFS**

```
hadoop fs -copyFromLocal /home/hadoop/pride_and_prejudice.txt /data/pig/pride_and_prejudice.txt
```

**Step 3: Load the data**

Start pig and load the data

```
pnp_book = LOAD '/data/pig/pride_and_prejudice.txt' AS (lines:chararray);
```

**Step 4: Tokenize the data**

Lets tokenize and flatten the data so we get one word in each line. Also in this step - I'm replacing all punctuation marks and ("'s'"). If we don't do that, then when we tokenize - these 3 would be considered as separate tokens

- Elizabeth
- Elizabeth.
- Elizabeth's

```
tokens = FOREACH pnp_book GENERATE FLATTEN (TOKENIZE(REPLACE(lines, '\'[s]|[\\.;,!:]',''))) AS word;
```

**Step 5: Filter the data**

```
character_names = FILTER tokens BY
                                (
                                    LOWER(word) matches LOWER('Elizabeth') OR
                                    LOWER(word) matches LOWER('Collins') OR
                                    LOWER(word) matches LOWER('George') OR
                                    LOWER(word) matches LOWER('Jane') OR
                                    LOWER(word) matches LOWER('Lydia') OR
                                    LOWER(word) matches LOWER('Caroline') OR
                                    LOWER(word) matches LOWER('Kitty') OR
                                    LOWER(word) matches LOWER('Charles')
                                );
```

**Step 6: Group the words together**

Next we will group the words

```
group_by_name = GROUP character_names BY LOWER(word);
```

**Step 7: Count the occurrences**

Next we will count the number of times each character name has occurred

```
count_names = FOREACH group_by_name GENERATE group, COUNT(character_names) as total_count;
```

**Step 8: Order by max count**

```
order_count = ORDER count_names BY total_count DESC;
```

**Step 9: Save the script**

Lets save it as a pride_and_prejudice.pig file

```
STORE order_count INTO '/output/pig/pride_and_prejudice';
```

**Step 10: Output**

The output is saved in the hdfs folder we specified in step 9. To view the results - you can use this command.

```
hadoop fs -cat /output/pig/pride_and_prejudice/part-r-00000
```

```
elizabeth 633
jane      293
collins	  180
lydia	  170
kitty	   70
caroline   17
george      8
charles	    7
```

**Here is the complete script**

```
pnp_book = LOAD '/data/pig/pride_and_prejudice.txt' AS (lines:chararray);
tokens = FOREACH pnp_book GENERATE FLATTEN (TOKENIZE(REPLACE(lines, '\'[s]|[\\.;,!:]',''))) AS word;
character_names = FILTER tokens BY
                                (
                                    LOWER(word) matches LOWER('Elizabeth') OR
                                    LOWER(word) matches LOWER('Collins') OR
                                    LOWER(word) matches LOWER('George') OR
                                    LOWER(word) matches LOWER('Jane') OR
                                    LOWER(word) matches LOWER('Lydia') OR
                                    LOWER(word) matches LOWER('Caroline') OR
                                    LOWER(word) matches LOWER('Kitty') OR
                                    LOWER(word) matches LOWER('Charles')
                                );
group_by_name = GROUP character_names BY LOWER(word);
count_names = FOREACH group_by_name GENERATE group, COUNT(character_names) as total_count;
order_count = ORDER count_names BY total_count DESC;
STORE order_count INTO '/output/pig/pride_and_prejudice';
```

As you can see - this is nothing but an extension of word count program but we've used it to do a simple analysis.


text:
# Class6
- [Class6](#class6)
  - [Exercises](#exercises)
  - [Challenge](#challenge)

In this class we are going to work with lists. In python Lists, arrays, and vectors means almost the same thing, and for that reason we are going to treat them as the same thing.

Lists are a collection of information. In some other languages, a list can contain only one type of data. In python, every item can have a different data type, including other lists.

Lists are not a primitive type of data, like strings, and int, and for that reason, we have a different way of working with lists.

In the code below, you will see the main features we use in a list: Declaration, adding item, removing item, getting an item in a specific position, checking if variable is in the list

```python
# Declaration
myList = []

# Adding Item
myList.append('item 1')
myList.append('item 2')

# Removing the first time the item appears
myList.remove('item 1')

# Removing every occurrence of the item in the list
while 'item 1' in myList:
    myList.remove('item 1')

# Getting the item in the specific index
x = myList[0]

# checking if the item is in the list
if 'item 2' in myList:
    print("it's in the list")
```

## Exercises

1. Create a program that reads the number of students in a class, and stores the name of every student
2. Implement a program that calculates the sum of 5 numbers,then prints the numbers and the total sum.

## Challenge

In this challenge, you have to create a program to create a groceries list. The has to be able to achieve the following tasks:

- Add an item, and the quantity
- Change the quantity of an existing item
- Remove an item (remove from the list if the quantity of item is 0 or less)
- print the list in a readable way


text:
# RVM, Ruby 2.0 and Bundler

We normally use [RVM](https://rvm.io/) to mange our development dependency on [Ruby 2.0.0](http://www.ruby-lang.org/en/)
and the specific Ruby Gems needed for building Lab and running the Lab server.

> Ubuntu Linux:
> - make sure that "run command as login shell" is checked in your terminal preferences
> - install curl `sudo apt-get install curl`

[Install RVM](https://rvm.io/rvm/install/)

    $ \curl -sSL https://get.rvm.io | bash -s stable --ruby

After RVM has finished installing it will ask you to run a command similar to

    $ source /home/user_name/.rvm/scripts/rvm

After installation you should see something like the following:

    $  ruby -v
    ruby 2.0.0p247 (2013-06-27 revision 41674) [x86_64-darwin10.8.0]

Often RVM has some additional dependencies, to view the list and directions for installing these, type:

    $ rvm requirements

> Ubuntu Linux: Often RVM doesn't recognise readline without being explictly pointed to it.
> To do this, reinstall ruby 2.0.0p247: `$ rvm reinstall 2.0.0-p247 --with-zlib1g-dev`

If you already have RVM installed update to the most up-to-date stable version.

    $ rvm get stable

Once you have a working version of Ruby 2.0.0 check to see if the RubyGem [Bundler](http://gembundler.com/)
is already installed:

    $ gem list bundler

    *** LOCAL GEMS ***

    bundler (1.3.5)

If Bundler is not installed, install it into the global gemset for ruby-2.0.0-p247

    $ rvm gemset use global
    $ gem install bundler

repository: concord-consortium/lab

gha_language: JavaScript

repo_name: concord-consortium/lab


text:
# Change Log
All notable changes to this project will be documented in this file.

The format is based on [Keep a Changelog](http://keepachangelog.com/)
and this project adheres to [Semantic Versioning](http://semver.org/).

## [1.4.0] - 2017-07-28
### Added
- docker_portainer_pull: "no"
- docker_portainer_state: "started"
- docker_portainer_restart_policy: "always"

## [1.3.0] - 2017-04-22
### Changed
- bugfix ansible when: docker_portainer_initial_database_file

## [1.2.0]
### Changed
- optional initial database copy
- remove versioning of data volume

## [1.1.0]
### Changed
- docker volume to docker.sock for local installations

## [1.0.0]
### Changed
- initial release


text:
---
name: SOLDIER
picture: Soldier.jpg

---

A psychotic patriot from the heart of America, the Soldier (allegedly Mister Jane Doe) is the bread and butter general assault unit of the team. While one of the easier to understand classes on the roster, he is far from the weakest. In fact, when played right, the Soldier can be one of the most dangerous classes on the battlefield. Equipped with his rocket launcher and stamina to spare, the Soldier is a highly versatile class for both offensive and defensive roles.


text:
## Last Week's Accomplishments

> We continued to get familiar with bootstap and flask

## This Week's Plan

> We plan to create json files with "data" that will eventually be replaced with the data of the student's progress and all the projects they can do

## Anything Blocking?

> got some errors when running a few flask test cases and cannot figure out why
> still have to get familar with Flask and figure out how to read the json files into the code

## Notes

> This is an optional section for any sort of information that does not fall under any of the other categories.

repository: mikbukow/rcos-status-updates

repo_name: mikbukow/rcos-status-updates


text:
# Changelog

All notable, unreleased changes to this project will be documented in this file. For the released changes, please visit the [Releases](https://github.com/mirumee/saleor-storefront/releases) page.

## [Unreleased]

- Handle quantity API errors in the cart #199 by @piotrgrundas
- Fix sticky footer, adjust cart overlay to the mocks, cart summary fixes, fix error if no shipping method found #205 by @piotrgrundas
- Disable ability to continue to billing without shipement chosen #211 by @piotrgrundas


text:
# Jailing Subprocesses

One of the techniques used in Nodejitsu's [haibu-carapace](https://github.com/nodejitsu/haibu-carapace) is using `chroot` to isolate a processes view of the file system.  Seems reasonably effective.

The [node-posix](https://github.com/melor/node-posix) module seems to offer one of the lightest weight implementations that provides access to the `chroot` functionality.  Obviously, if we do go down this path it will mean that this won't work on Windows systems.

## Additional Reading

Some useful reference links are available on the node-posix readme page:

repository: kondoot/sm-kondoot

repo_name: kondoot/sm-kondoot