text:
# react-experimentify [![Build Status](https://travis-ci.org/DomainGroupOSS/react-experimentify.svg?branch=master)](https://travis-ci.com/DomainGroupOSS/react-experimentify) ![npm-version]

## WARNING !! this component is no longer active and has been deprecated. Please feel free to fork or find alternatives 😬

### Features

A set of components to build experiments in React for A/B and Multivariate testing in Google Optimize or Optimizely.

Using an experiment object, an `Experiment` component can be used to render `Treatment` and `Control` components.

### Install

Via NPM

```bash
npm install react-experimentify
```

Via Yarn:

```bash
yarn add react-experimentify
```

### Mixpanel - `startMixpanelExperiment`

This function will signal to mixpanel that an experiment has started, and the group that the user has been bucketed into - either `Control` or `Variant`. It will only fire once per user/device, based upon [Mixpanel's `distinct_id`](https://help.mixpanel.com/hc/en-us/articles/115004509406-Distinct-IDs-).

#### Usage

Example of usage when treated component is in the user's viewport:

```javascript
import { startMixpanelExperiment } from 'react-experimentify';
import { useInView } from 'react-intersection-observer';

const InViewMixpanelExperiment = ({
  experimentName,
  showVariant,
  variant,
  control,
}) => {
  const { ref, inView } = useInView();

  useEffect(() => {
    if (inView) {
      startMixpanelExperiment({
        experimentName,
        isVariant: showVariant,
        onError: (err, errMsg) => console.error(err, errMsg),
        onSuccess: () => console.log('great success'),
      });
    }
  }, [inView, experimentName, showVariant]);

  return <div ref={ref}>{showVariant ? variant : control}</div>;
};

const Component = ({shouldShowVariant}) => (
  <div>
    <p>Always rendered</p>
    <InViewMixpanelExperiment
      experimentName="My great experiment"
      showVariant={shouldShowVariant}
      variant={<div>Variant markup</div>}
      control={<div>Control markup</div>}
    />
  </div>
);
```

#### Parameters

| Parameter | Type | Default | Description | Required |
| ---- | ---- | ------- | ----------- | -------- |
| experimentName | `string` | - | Experiment name logged to mixpanel | yes |
| isVariant | `bool` | - | Dictates value for experiment in mixpanel | yes |
| onError | `(error, errorMessage) => func` | `noop` | Called with error and error message if caught when starting experiment with mixpanel | no |
| onSuccess | `() => func` | `noop` | Called with no args on successful experiment start | no |

### Google Optimize

_Before jumping into Google Optimise you need to make sure your page will handle google optimise tags. For more info on
configuring the Google Tag Managers and the windows dataLayer please see
[Google's Docs](https://support.google.com/tagmanager/answer/7164339?hl=en)_

1. Decide on an experiment name

* Guide `<Component under experiment>_<Placement Identifier>`

  * eg: `h1_ListingPage`

2. Set up an experiment in Google Optimize

* Code to execute via Google Optimize

  ```javascript
  window.dispatchEvent(new CustomEvent('h1_ListingPage.render', {
    detail: {
      title: 'Treatment - ' + Date.now()
    }
  }));
  ```
* Add `h1_ListingPage.activate` as custom event

  ![targeting](./docs/optimize_targeting.png)

3. Import

```javascript
  import React from 'react';
  import ReactDOM from 'react-dom';

  import { Experiment, Treatment, Control, Optimize, ExperimentOpacifier } from 'react-experimentify';
```

4. Initialization

```javascript
import { Experiment, Treatment, Control, Optimize, ExperimentOpacifier } from 'react-experimentify';
import React from 'react';
import ReactDOM from 'react-dom';

const experiment = new Optimize('h1_ListingPage');
```

5. Activation

* Experiment can be activated at any point in time after component has been mounted. We can activate it on the
client side as well. If we want the experiment to be activated straight after the parent component is mounted,
add following

_experiment.activate() takes an optional callback, should you wish to fire any tracking events or specialised functionality once the experiment has been activated._

```javascript
componentDidMount() {
  this.experiment.activate();
  this.unsubscribe = this.experiment.subscribe(state => this.setState(state));
}

componentWillUnmount() {
  this.unsubscribe();
}
```

6. Add following to render method. _(Here we are experimenting _h1_ tag)_

```javascript
  <Experiment experiment={experiment}>
    <div>
      <Treatment>
        <h1>Treatment 1</h1>
      </Treatment>
      <Control>
        <p>Control</p>
      </Control>
    </div>
  </Experiment>
```

7. With `ExperimentOpacifier`

* Helps to reduce the flickering effect when the experiment is loading.
* How it works?

  * Let the component under experiment to render the control version in transparent mode.
  * Wait for the experiment to kick in within the `timeout` period.
  * If the experiment loads before timing out, user will see the variant of the experiment.
  * If timed out, user will see control version.

  ```javascript
    <Experiment experiment={experiment}>
      <ExperimentOpacifier
        wrapper={'div'}
        timeout={250}
        transition={250}
      >
        <div>
          <Treatment>
            <h1>Treatment 1</h1>
          </Treatment>
          <Control>
            <p>Control</p>
          </Control>
        </div>
      </ExperimentOpacifier>
    </Experiment>
  ```

8. Override opacity behaviour

Because the `ExperimentOpacifier` initially renders with an opacity of `0`,
this be override with the `.experiment__opacity` class.

Add a `<noscript>` element to the page to override the opacity

```html
<noscript>
  <style>
    .experiment__opacity {
      opacity: 1 !important;
    }
  </style>
</noscript>
```

### Optimizely

```javascript
import { Experiment, Treatment, Control, optimizely } from 'react-experimentify';
import React from 'react';
import ReactDOM from 'react-dom';

const experiment = optimizely(experimentId, {
  '2': {
    content: 'Treatment 2'
  },
  '3': {
    content: 'Treatment 3',
  },
});

ReactDOM.render((
  <Experiment experiment={experiment}>
    <div>
      <Treatment groups={['1']}>
        <h1>Treatment 1</h1>
      </Treatment>
      <Treatment groups={[2, 3]}>
        {
          ({ content }) => (<h2>{content}</h2>)
        }
      </Treatment>
      <Control group={4}>
        <p>Control</p>
      </Control>
    </div>
  </Experiment>
), document.querySelector('.react-experimentify-entry-point'));
```

### Props

#### `Experiment`

| Prop | Type | Default | Description | Required |
| ---- | ---- | ------- | ----------- | -------- |
| children | `node` |  | A single child element to render | No |
| experiment | `object` |  | An experiment object used to run the experiment | Yes |

#### `Treatment`

| Prop | Type | Default | Description | Required |
| ---- | ---- | ------- | ----------- | -------- |
| children | `oneOf(node, func)` |  | The child elements or function to render the treatment | No |
| render | `func` |  | The function to render the treatment | No |
| groups | `oneOf(string, arrayOf(string))` |  | The groups that will receive the treatment | Yes |

_Note: You should not use `<Control render>` and `<Control children>` in the same control;
`<Control children>` will be ignored_

#### `Control`

| Prop | Type | Default | Description | Required |
| ---- | ---- | ------- | ----------- | -------- |
| children | `oneOf(node, func)` |  | The child elements or function to render the control | No |
| render | `func` |  | The function to render the control | No |
| group | `string` |  | The control group | Yes |

_Note: You should not use `<Treatement render>` and `<Treatement children>` in the same treatment;
`<Treatement children>` will be ignored_

#### `withExperiment(component: ReactElement)`

A higher order component that injects the current experiment as a prop to the wrapped component

#### `new Optimizely(experimentId: String[, groupVariants: Object])`

An experiment object for the Optimizely A/B testing platform

`experimentId`: the id for the current optimizely experiment

`groupVariants`: an optional map of variantIds to props. Used when rendering a `Treatement` for a given group

To setup an experiment in optimizely, create an experiment and add the required number of variants.
You need to decide which variants will be the Treatments and which will be the Control.

The `experimentId` and `variantId` can be found visiting the edit page for the experiment
and opening the 'Diagnostic Report' under options.

![Diagnostic Report](./docs/diagnostic-report.png)

##### `Optimizely.pushEvent(eventName: String): void`

Pushes events to optimizely for tracking.

##### `optimizely.active(): void`

Manually activates an experiment.
Dispatches changes to all subscribers.

##### `optimizely.hasVariant([variantIds: Array[String]]): Boolean`

Determines if any of the variants are active for the current experiment.

##### `optimizely.isActive(): Boolean`

Determines if the current experiment is active.

##### `optimizely.isControl(): Boolean`

Determines if the current user is in the control group and no variants are active.

##### `optimizely.subscribe(listener: Function): Function`

Subscribe listener functions to changes to the experiment.
Returns the unsubscribe function.

##### `optimizely.update([{ group: String|Array[String]}]): void`

Updates the current experiment by moving the current user into a different treatment group.
Dispatches changes to all subscribers.
An empty `Array` will move the current user into the control group.

##### `optimizely.variantProps(): Object`

Gets the props for the current variant from the groupVariants.

## Changes and history

See [CHANGELOG.md](./CHANGELOG.md).

[npm-version]: https://badge.fury.io/js/react-experimentify.svg

repository: DomainGroupOSS/react-experimentify

repo_name: DomainGroupOSS/react-experimentify


text:
# Retrying failing jobs

As your queues processes jobs, it is inevitable that over time some of these jobs will fail. In BullMQ, a job is considered failed in the following scenarios:

- The processor function defined in your [Worker](https://docs.bullmq.io/guide/workers) has thrown an exception.
- The job has become [stalled](https://docs.bullmq.io/guide/jobs/stalled) and it has consumed the "max stalled count" setting.

{% hint style="danger" %}
The exceptions thrown in a processor must be an [Error](https://nodejs.org/api/errors.html#class-error) object for BullMQ to work correctly.

In general, as a best practice, it is better to always throw Error objects. There is even an eslint rule if you want to enforce it: https://eslint.org/docs/latest/rules/no-throw-literal
{% endhint %}

## Retrying failing jobs

When a processor throws an exception, the worker will catch it and move the job to the failed set. Depending on your [Queue settings](https://docs.bullmq.io/guide/queues/auto-removal-of-jobs), the job may stay in the failed set forever, or it could be automatically removed.

Often it is desirable to automatically retry failed jobs so that we do not give up until a certain amount of retries have failed. In order to activate automatic job retries you should use the [attempts](https://api.docs.bullmq.io/interfaces/v4.BaseJobOptions.html#attempts) setting with a value larger than 1 (see the examples below).

BullMQ supports retries of failed jobs using back-off functions. It is possible to use the **built-in** backoff functions or provide **custom** ones. If you do not specify a back-off function, the jobs will be retried without delay as soon as they fail.

#### Built-in backoff strategies

The current built-in backoff functions are "exponential" and "fixed".

With exponential backoff, it will retry after `2 ^ (attempts - 1) * delay` milliseconds. For example, with a delay of 3000 milliseconds, for the 7th attempt, it will retry 2^6 \* 3000 milliseconds = 3.2 minutes after the previous attempt.

With a fixed backoff, it will retry after `delay` milliseconds, so with a delay of 3000 milliseconds, it will retry _every_ attempt 3000 milliseconds after the previous attempt.

The code below shows how to specify the built-in "exponential" backoff function with a 1-second delay as a seed value, so it will retry at most 3 times spaced after 1 second, 2 seconds, and 4 seconds respectively:

```typescript
import { Queue } from 'bullmq';

const myQueue = new Queue('foo');

await queue.add(
  'test-retry',
  { foo: 'bar' },
  {
    attempts: 3,
    backoff: {
      type: 'exponential',
      delay: 1000,
    },
  },
);
```

You can also define the back-off strategy in the queue's `defaultJobOptions`, and it will apply to all jobs added to the queue unless overridden when adding the job. For example:

```typescript
import { Queue } from 'bullmq';

const myQueue = new Queue('foo', {
  defaultJobOptions: {
    attempts: 3,
    backoff: {
      type: 'exponential',
      delay: 1000,
    },
  },
});

await queue.add('test-retry', { foo: 'bar' });
```

#### Custom back-off strategies

If you want to define your custom backoff function, you need to define it in the worker settings:

```typescript
import { Worker } from 'bullmq';

const worker = new Worker('foo', async job => doSomeProcessing(), {
  settings: {
    backoffStrategy: (attemptsMade: number) => {
      return attemptsMade * 1000;
    },
  },
});
```

You can then use your custom strategy when adding jobs:

```typescript
import { Queue } from 'bullmq';

const myQueue = new Queue('foo');

await queue.add(
  'test-retry',
  { foo: 'bar' },
  {
    attempts: 3,
    backoff: {
      type: 'custom',
    },
  },
);
```

If you want to define multiple custom backoff types you need to define them like in the following example:

```typescript
import { Worker } from 'bullmq';

const worker = new Worker('foo', async job => doSomeProcessing(), {
  settings: {
    backoffStrategy: (
      attemptsMade: number,
      type: string,
      err: Error,
      job: Job,
    ) => {
      switch (type) {
        case 'custom1': {
          return attemptsMade * 1000;
        }
        case 'custom2': {
          return attemptsMade * 2000;
        }
        default: {
          throw new Error('invalid type');
        }
      }
    },
  },
});
```

license: MIT

repository: taskforcesh/bullmq

branch_name: refs/heads/master

extension: md

gha_language: TypeScript

gha_license_id: MIT

license_type: permissive

repo_name: taskforcesh/bullmq


text:
# markdown-viewer
A simple markdown viewer that watch markdown file and show the html result.

___This project has been deprecated, recommand you try this similar [markdown previewer](https://github.com/Mesamo/MarkdownPreview).___

repository: liyuan-rey/markdown-viewer

repo_name: liyuan-rey/markdown-viewer


text:
---
layout: relation
title: 'obj:agent'
shortdef: 'agent object of a non-actor-focused verb'
udver: '2'
---

A _ng_-marked nominal that denotes the agent in a clause with a voice other than actor-focus.
Unlike in Indo-European languages, the agent is still a core argument, hence it is labeled
`obj:agent` rather than [obl:agent]().

~~~ sdparse
Binigyan ng titser ng premyo ang istudyante . \n Given the teacher a prize the student .
obj:agent(Binigyan, titser)
obj:agent(Given, teacher)
~~~

“The teacher gave the student a prize.”

<!-- Interlanguage links updated Út 9. května 2023, 20:04:26 CEST -->

repository: UniversalDependencies/docs

branch_name: refs/heads/pages-source

gha_language: HTML

repo_name: UniversalDependencies/docs


text:
# Mini_Project
AIM : To Design and Develop Deep learning algorithms which can make diagnosis based on medical data and categorize vast variety of data records which will be used to assist doctors and managing large medical data records in hospitals in real time.

OBJECTIVES:
1.To reduce misdiagnosis and medical errors significantly saving time and unnecessary need for further diagnosis.
2.Cross Verification of Diagnosis by doctors in rural areas become easy and faster improving their experience.
3.For managing large amount of medical data in real time.

DATASETS USED FOR THIS PROJECT:
Lungs Dataset-https://www.kaggle.com/paultimothymooney/chest-xray-pneumonia
Brain-Tumor Dataset-https://www.kaggle.com/navoneel/brain-mri-images-for-brain-tumor-detection
Breast_cancer dataset--https://www.kaggle.com/aryashah2k/breast-ultrasound-images-dataset
Alziemers Dataset--https://www.kaggle.com/tourist55/alzheimers-dataset-4-class-of-images
Heart_CSV Dataset --https://www.kaggle.com/ronitf/heart-disease-uci
Fit-Bit Data Extraction Using Fitbit API

branch_name: refs/heads/main


text:
---
external help file: BluebirdPS-help.xml
Module Name: BluebirdPS
online version: https://docs.bluebirdps.dev/en/v0.7.0/Account%20Settings%2C%20User%20Profile%2C%20and%20Saved%20Searches/Remove-TwitterSavedSearch
schema: 2.0.0
---

# Remove-TwitterSavedSearch

## SYNOPSIS

Deletes the specified saved search belonging to the authenticating user.

## SYNTAX

### ById (Default)

```powershell
Remove-TwitterSavedSearch -Id <String> [-Confirm] [-WhatIf] [<CommonParameters>]
```

### BySavedSearch

```powershell
Remove-TwitterSavedSearch -SavedSearch <SavedSearch> [-Confirm] [-WhatIf] [<CommonParameters>]
```

## DESCRIPTION

Deletes the specified saved search belonging to the authenticating user.

## EXAMPLES

### Example 1

```powershell
PS > Remove-TwitterSavedSearch -Id<PHONE_NUMBER>092367362
```

```text
Confirm
Are you sure you want to perform this action?
Performing the operation "Removing Saved Search" on target "Search : (#PoShEvents) (from:thedavecarroll), Created: Fri Feb 07 18:29:15 +0000 2020".
[Y] Yes  [A] Yes to All  [N] No  [L] No to All  [S] Suspend  [?] Help (default is "Y"): y
```

Deletes the specified saved search belonging to the authenticating user.

### Example 2

```powershell
PS > Get-TwitterSavedSearch -Id<PHONE_NUMBER>094210566 | Remove-TwitterSavedSearch
```

```text
Confirm
Are you sure you want to perform this action?
Performing the operation "Removing Saved Search" on target "Search: (#pwsh_eats), Created: 11/9/2020 8:04:10 PM".
[Y] Yes  [A] Yes to All  [N] No  [L] No to All  [S] Suspend  [?] Help (default is "Y"): y
```

Gets the specified saved search then deletes it, if belonging to the authenticating user.

## PARAMETERS

### -Id

The id of the saved search.

```yaml
Type: String[]
Parameter Sets: (All)
Aliases:

Required: True
Position: Named
Default value: None
Accept pipeline input: False
Accept wildcard characters: False
```

### -Confirm

Prompts you for confirmation before running the cmdlet.

```yaml
Type: SwitchParameter
Parameter Sets: (All)
Aliases: cf

Required: False
Position: Named
Default value: False
Accept pipeline input: False
Accept wildcard characters: False
```

### -WhatIf

Shows what would happen if the cmdlet runs.
The cmdlet is not run.

```yaml
Type: SwitchParameter
Parameter Sets: (All)
Aliases: wi

Required: False
Position: Named
Default value: False
Accept pipeline input: False
Accept wildcard characters: False
```

### CommonParameters

This cmdlet supports the common parameters: -Debug, -ErrorAction, -ErrorVariable, -InformationAction, -InformationVariable, -OutVariable, -OutBuffer, -PipelineVariable, -Verbose, -WarningAction, and -WarningVariable. For more information, see [about_CommonParameters](http://go.microsoft.com/fwlink/?LinkID=113216).

## INPUTS

### None

## OUTPUTS

### None

## NOTES

## RELATED LINKS

[Online Version](https://docs.bluebirdps.dev/en/v0.7.0/Account%20Settings%2C%20User%20Profile%2C%20and%20Saved%20Searches/Remove-TwitterSavedSearch)

[Get-TwitterSavedSearch](https://docs.bluebirdps.dev/en/v0.7.0/Account%20Settings%2C%20User%20Profile%2C%20and%20Saved%20Searches/Get-TwitterSavedSearch)

[Add-TwitterSavedSearch](https://docs.bluebirdps.dev/en/v0.7.0/Account%20Settings%2C%20User%20Profile%2C%20and%20Saved%20Searches/Add-TwitterSavedSearch)

[Api Reference - POST saved_searches/destroy/:id](https://developer.twitter.com/en/docs/twitter-api/v1/accounts-and-users/manage-account-settings/api-reference/post-saved_searches-destroy-id)

url: https://raw.githubusercontent.com/ArneVangheel/BluebirdPS/78acc08b85da3410511fa67b2c4830667f5ad56b/docs/Account Settings, User Profile, and Saved Searches/Remove-TwitterSavedSearch.md

repository: ArneVangheel/BluebirdPS

repo_name: ArneVangheel/BluebirdPS


text:
# Choosing a DataBase

## Data Model

What native data structure suits the DataModel the most?

- Relational
- Graph
- Key Value

Data types

- Schemaless / Strict-Schema
- Geo-Spatial
- Text based
- Types with large volume
- Custom Types

## Data Behavior

- Is ACID important for you?
  - Atomic - Transactions
  - Isolation - Race condition of multiple transactions
  - Consistency - Always consistent / Eventually-consistent
    - Do your app design for eventually-consistent data?
    - Data constraints, FK, Cascades, Triggers
  - Durability - Will be committed even if the DataBase crashes in the middle of a transaction.
- Data Modification rate (Insert, Update, Delete)
- Size of the Data. Volume scale (Static/Linear/Exponential)
  - Scale Up / Scale out
- Queries profile
  - Join queries between tables/collections?
  - Hierarchy queries?
- High Availability? Disaster Recovery?
  - Supports Active Active? Cross-Regional Active Active?
- Caching? (SuperFast Queries - like Redis)
- Scheduler/Job/Task/Cron

## Infrastructures

- Does it have a Manage-Cloud service?
  - If you have to host and mange it by your self, it's a whole new
- Is it possible to run it locally with docker?

## Usual Considerations

- Stability of the DataBase
- Who's behind it
- Community
- OpenSource or not
- Support
- Price


text:
# Verovio score selection

This project is out of date and has been replaced with https://github.com/trompamusic/DigitalScoreEdition

This is a React application that loads an MEI score, renders it using
[Verovio](http://www.verovio.org/index.xhtml) and allows the user to select
musical elements on the score.

It was a prototype to determine if this stack could be used for the Trompa
Score Edition Component.

## License

```
Copyright 2019 Music Technology Group, Universitat Pompeu Fabra

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
```

# Implementation details

This project was bootstrapped with [Create React App](https://github.com/facebook/create-react-app).

## Available Scripts

In the project directory, you can run:

### `npm start`

Runs the app in the development mode.

Open [http://localhost:3000](http://localhost:3000) to view it in the browser.

The page will reload if you make edits.

You will also see any lint errors in the console.

You can learn more in the [Create React App documentation](https://facebook.github.io/create-react-app/docs/getting-started).

To learn React, check out the [React documentation](https://reactjs.org/).

repository: trompamusic/verovio-select

repo_name: trompamusic/verovio-select


text:
The size of a collection and the length of an array are always greater than or equal to zero. So testing that a size or length is greater than or equal to zero doesn't make sense, since the result is always `true`. Similarly testing that it is less than zero will always return `false`. Perhaps the intent was to check the non-emptiness of the collection or array instead.

## Noncompliant Code Example

    If Collection.Count >= 0 Then ...

    If Enumerable.Count < 0 Then ...

    If array.Length >= 0 Then ...

    Dim result As Boolean = Array.Length >= 0

## Compliant Solution

    If list.Count = 0 Then ...
    If array.Length >= 42 Then ...

repository: codacy/codacy-sonar-visual-basic

gha_language: C#

gha_license_id: NOASSERTION

repo_name: codacy/codacy-sonar-visual-basic


text:
# guide-build-python-environment

## `conda`
- This is a guide a setup a python environment using `conda` for Windows
- A description of `conda` can be found on https://docs.conda.io/projects/conda/en/latest/, a brief description copied from that page is pasted below

*Package, dependency and environment management for any language---Python, R, Ruby, Lua, Scala, Java, JavaScript, C/ C++, FORTRAN*

*Conda is an open-source package management system and environment management system that runs on Windows, macOS, and Linux. Conda quickly installs, runs, and updates packages and their dependencies. Conda easily creates, saves, loads, and switches between environments on your local computer. It was created for Python programs but it can package and distribute software for any language.*

- There are a few different terms; `conda`, Anaconda, Miniconda, `conda-forge`. More information on these can be found on https://docs.conda.io/projects/conda/en/latest/glossary.html
- For us, we want to choose between Anaconda and Miniconda. The main difference is that Anaconda ships with a large number of data science python packages whereas Miniconda is a very basic and bare bones
    - Due to this there is a difference in size of the installation file, i.e. Anaconda is much bigger than Miniconda
    - Both installations will provide an instance of `conda` which is the command line interface tool for package management
- Once we have `conda` installed, we can do the following things:
    - Create multiple python environments independent of each other
    - Remove python environments
    - Install python packages and other dependencies using `conda`

### Installation

- We can use the following powershell script to install Miniconda, some minor changes will also allow the user to install Anaconda if that is preffered
- Please find the script at https://gist.github.com/joy-rosie/dabf8a5511d5e6bd334a605fb5bd2c5c
- Once this is done, open a `conda` prompt and run:

```
conda update conda
```

- `conda` will have a base environment `(base)` which can be seen in the prompt and this is itself an environment
- We can create more environments than just the `base` environment
    - The idea is to create different environments for different projects to keep the dependencies clean
    - This is not necessary if we are doing simple projects for learning and playing around but as soon as we would like to share projects or code, it will be useful to have an environment dedicated to that project

### Useful commands
- Create a new environment

```
conda create -n <name> python=3.8
```

- Create an environment using an available `environment.yml` file

```
conda env create -f <path to environment.yml>
```

- Activate an environment

```
conda activate <name>
```

- Deactivate the environment we are in

```
conda deactivate
```

- Remove an environment

```
conda env remove -n <name>
```

## `git`

- Another important part of the python setup is `git`, this is an open source software used for version control for text base files
- More information on `git` can be found on https://git-scm.com/about
- Version control is important when collaborating and also for "saving" different parts of the development cycle so we can go back to the right place
- `git` is also the underlying software used within GitHub, GitLab, BitBucket
- With `git` we can download any `git` repository onto our computer with a single line of code
- We can install `git` from https://git-scm.com/downloads and recommend using default settings along the way


text:
## What is a unit test?
> A unit test is an automated piece of code that invokes a unit of work in the system and then checks a single assumption about the behavior of that unit of work.

### The AngularJS way
> Angular is written with testability in mind, but it still requires that you do the right thing. We tried to make the right thing easy, but if you ignore these guidelines you may end up with an untestable application.

> Angular comes with [dependency injection](https://docs.angularjs.org/guide/di) built-in, which makes testing components much easier, because you can pass in a component's dependencies and stub or mock them as you wish.

### Tools

![Unit testing tools](http://i62.tinypic.com/2cdtqfa.png)

Tool         | Description
------------ | -------------
[Karma](http://karma-runner.github.io/0.12/index.html) | Test runner
[Jasmine](http://jasmine.github.io/) / [Mocha](http://mochajs.org/) / [UnitJS](http://unitjs.com/)| Unit test frameworks

I tried every test framework listed above and I definitely agree with [the JS guy](http://thejsguy.com/2015/01/12/jasmine-vs-mocha-chai-and-sinon.html)

### Articles
* [Full-Spectrum Testing with AngularJS and Karma (yearofmoo)](http://www.yearofmoo.com/2013/01/full-spectrum-testing-with-angularjs-and-karma.html)
* [Unit Testing Best Practices in AngularJS (Andy Shora)](http://andyshora.com/unit-testing-best-practices-angularjs.html)
* [AngularJS Unit Testing Best Practices (Manuel Weiss)](https://blog.codeship.com/angularjs-tdd/)
* [:star:] [Testing Promises with Jasmine (Bluescreen)](http://ng-learn.org/2014/08/Testing_Promises_with_Jasmine/)
* [Advanced Testing and Debugging in AngularJS (yearofmoo)](http://www.yearofmoo.com/2013/09/advanced-testing-and-debugging-in-angularjs.html)
* [Testing Services, Controllers & Providers (Rabi Kiran )](http://www.sitepoint.com/unit-testing-angularjs-services-controllers-providers/)
* [:star:] [How to Unit Test an AngularJS Controller (Bradley Braithwaite)](http://www.bradoncode.com/blog/2015/05/17/angularjs-testing-controller/)
* [AngularJS Unit Testing – For Real, Though (Ben Lewis)](https://quickleft.com/blog/angularjs-unit-testing-for-real-though/)
* [Unit Testing AngularJS Modules (Edwin Guzman)](http://www.nypl.org/blog/2015/07/14/unit-testing-angular-js)
* [How to Unit Test with real $http calls using ngMockE2E (Bradley Braithwaite)](http://www.bradoncode.com/blog/2015/06/16/unit-test-http-ngmock-passthrough/)

### Presentations
* [:star:] [JavaScript TDD with Jasmine and Karma (Christopher Bartling)](http://www.slideshare.net/cebartling/javascript-tdd-with-jasmine-and-karma)
* [TDD Basics with Angular.js and Jasmine (Luis Sánchez Castellanos)](http://www.slideshare.net/iquark/tdd-basics-with-angular-and-jasmine)
* [Testing JavaScript with Jasmine (Tim Tyrrell)](http://www.slideshare.net/timtyrrell/testing-javascript-with-jasmine-8998985)

### Examples
* [AngularJS unit testing demo (nirkaufman)](https://github.com/nirkaufman/angularjs-unit-testing-demo)

### Fiddles
* [Testing a controller with Jasmine](http://jsfiddle.net/eitanp461/XrJMr/)
* [Testing a directive with Jasmine](http://jsfiddle.net/eitanp461/wFFet/)
* [Testing a filter with Jasmine](http://jsfiddle.net/eitanp461/E64Se/)
* [Testing promises with Jasmine](http://jsfiddle.net/eitanp461/vjJmY/)

### Books
* [AngularJS Test driven Development (Tim Chaplin)](http://www.amazon.com/AngularJS-Test-driven-Development-Tim-Chaplin/dp/1784398837)
* [:star:] [AngularJS Testing Cookbook (Simon Bailey)](http://www.amazon.com/Angu/larJS-Testing-Cookbook-Simon-Bailey/dp/1783983744)
* [JavaScript Testing with Jasmine (Evan Hahn)](http://www.amazon.com/JavaScript-Testing-Jasmine-Behavior-Driven-Development/dp/1449356370)

### Media
* [Introduction to AngularJS Unit Testing (Jim Lavin)](https://www.youtube.com/watch?v=UDB-jm8MWro)
* [:star:] [Testing Strategies for Angular JS (David Mosher)](https://www.youtube.com/watch?v=UYVcY9EJcRs)
* [AngularJs Unit Testing with Jasmine (playlist)](https://www.youtube.com/playlist?list=PLw5h0DiJ-9PDbh2i6knU4FybWA63PPbVi)
* [:star:] [Play by Play: Angular Testing with John Papa and Ward Bell](http://www.pluralsight.com/courses/play-by-play-angular-testing-papa-bell)
* [Unit Testing in Angular Applications (Hebrew) (Michael Haberman)](https://www.youtube.com/watch?v=k4uJRkZi-6c)

### Helpful links
* [How to unit test isolated scope directive in AngularJS](http://stackoverflow.com/questions/17371836/how-to-unit-test-isolated-scope-directive-in-angularjs)
* [:star:] [How to test John papa vm.model unit testing with jasmine](http://stackoverflow.com/questions/28456747/how-to-test-john-papa-vm-model-unit-testing-with-jasmine)
* [How to test that a $q promise chain was resolved](http://stackoverflow.com/questions/31229875/angular-jasmine-how-to-test-that-a-q-promise-chain-was-resolved)
* [Top 5 Testing and Mocking AngularJS Modules](http://angularjs4u.com/testing-and-mocking/top-5-testing-mocking-angularjs-modules/)

repository: Castafiore/angular-test-resources

repo_name: Castafiore/angular-test-resources


text:
### [CVE-2008-5081](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2008-5081)
![](https://img.shields.io/static/v1?label=Product&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Version&message=%3D%20n%2Fa%20&color=brighgreen)
![](https://img.shields.io/static/v1?label=Vulnerability&message=n%2Fa&color=brighgreen)

### Description

The originates_from_local_legacy_unicast_socket function (avahi-core/server.c) in avahi-daemon in Avahi before 0.6.24 allows remote attackers to cause a denial of service (crash) via a crafted mDNS packet with a source port of 0, which triggers an assertion failure.

### POC

#### Reference
- https://www.exploit-db.com/exploits/7520

#### Github
No PoCs found on GitHub currently.

repository: trickest/cve

repo_name: trickest/cve


text:
# Scalability validation of the release

_by Shyam JVS, Google Inc_

**July 2017**

## Introduction

Scalability is an integral part of k8s. Numerous issues were identified during release 1.7 while running tests on large clusters (2k-5k nodes). A majority of these manifested only in large clusters - more info under umbrella issue [#47344]. The issues ranged from large cluster setup (both cloud-provider specific and independent ones) to test-infra problems to previously uncaught regressions with performance and resource usage and so on.

We started [supporting] 5000-node clusters from k8s 1.6 and need to make sure this scale is supported in future releases too. We did it this time by running performance and correctness tests under different configurations manually. But this testing procedure needs to be automated, concrete & well-maintained.

## Goals

In this document, we address the following process-related problems wrt scale testing:

- Automate large cluster tests with a reasonable frequency
- Concretely define the testing configuration used for the release
- Make scalability validation a release prerequisite
- Clearly lay down responsibilities for scale tests

## Non-Goals

This document does not intend to:

- Define the set of tests that comprise scalability and correctness suite
- Define SLIs/SLOs (that’s discussed [here]) and thresholds for the tests
- Discuss particular performance issues we’re facing wrt different releases

While these are interesting from scalability perspective, they are not testing process issues but details of the tests themselves. And can change without requiring much changes in the process.

## Proposed design

For each of the problems above we propose solutions and discuss some caveats. This is an open discussion and better solutions may evolve in future.

### Automate large cluster tests

Currently, there are 2 kinds of tests needed to validate the claim “kubernetes supports X-node clusters”. These are:

- Correctness tests - e2e tests verifying expected system behaviours
- Performance tests - e2e tests for stress-testing the system perf ([Feature:Performance])

We need to run them on 5k-node clusters, but they’re:

- Time-consuming (12-24 hrs)
- Expensive (tens of thousands of core hours per run)
- Blocking other large tests (quota limitations + only one large test project available viz. 'kubernetes-scale')

So we don’t want to run them too frequently. On the other hand, running them too infrequently means
late identification and piling up of regressions. So we choose the following middleground. \
(**B** = release-blocking job, all times in UTC)

| Day | |
| ------------- |:-------------:|
| Mon | GCE 5k-node correctness (**B**)  @ 03:01 AM UTC
 GCE 5k-node performance (**B**) @ 08:01 AM UTC |
| Tue | GCE 5k-node correctness (**B**)  @ 03:01 AM UTC
 GCE 5k-node performance (**B**) @ 08:01 AM UTC |
| Wed | GCE 5k-node correctness (**B**)  @ 03:01 AM UTC
 GCE 5k-node performance (**B**) @ 08:01 AM UTC |
| Thu | GCE 5k-node correctness (**B**)  @ 03:01 AM UTC
 GCE 5k-node performance (**B**) @ 08:01 AM UTC |
| Fri | GCE 5k-node correctness (**B**)  @ 03:01 AM UTC
 GCE 5k-node performance (**B**) @ 08:01 AM UTC |
| Sat | GKE 5k-node correctness @ 03:01 AM UTC
 GKE 5k-node performance @ 08:01 AM UTC |
| Sun | GKE 2k-node performance @ 08:01 AM UTC
 GKE 2k-node performance (regional) @ 08:01 AM UTC |

Note: The above schedule is subject to change based on job health, release requirements, etc.

Why this schedule?

- 5k tests might need special attention in case of failures so they should mostly run on weekdays.
- Running a large-scale performance job and a large-scale correctness job each day would:
  - help catch regressions on a daily basis
  - help verify fixes with low latency
  - ensure a good release signal
- Running large scale tests on GKE once a week would help verify GKE setup also, at no real loss of signal ideally

Why run GKE tests at all?

Google is currently using a single project for scalability testing, on both GCE and GKE. As a result we need to schedule them together. There's a plan for CNCF becoming responsible for funding k8s testing, and GCE/GKE tests would be separated to different projects when that happens, with only GCE being funded by them. This ensures fairness across all cloud providers.

### Concretely define test configuration

This is a relatively minor issue but it is important that we clearly define the test configuration we use for the release. E.g. there was a confusion this time around testing k8s services, machine-type and no. of the nodes we used (we tested 4k instead of 5k due to a CIDR-setup problem). For ref - [#47344] [#47865]. To solve this, we need to document it using the below template in a file named scalability-validation-report.md placed under kubernetes/features/release->N<. And this file should be linked from under the scalability section in the release's CHANGELOG.md.

```
Validated large cluster performance under the following configuration:
- Cloud-provider - [GCE / GKE / ..]
- No. of nodes - [5k (desired) / 4k / ..]
- Node size, OS, disk size/type
- Master size, OS, disk size/type
- Any non-default config used - (monitoring with stackdriver, logging with elasticsearch, etc)
- Any important test details - (services disabled in load test, pods increased in density test, etc)
- <job-name, run#> of the validating run (to know other specific details from the logs)

Validated large cluster correctness under the following configuration:
- <similar to above>

Misc:
<Any important scalability insights/issues/improvements in the release>
```

### Make scalability validation a release prerequisite

The model we followed this time was to create an umbrella issue ([#47344]) for scalability testing and labeling it as a release-blocker. While it helped block the release, it didn’t receive enough traction from individual SIGs as scale tests were not part of the release-blocking suite. As a result, the onus for fixing issues fell almost entirely on sig-scalability due to time constraints. Thus the obvious requirement here is to make the 5k-node tests release blockers. This along with test automation ensures failures are identified quickly and get traction from relevant SIGs.

### Clearly lay down responsibilities for scale tests

Responsibilities that lie with sig-scalability:

- Setting and tuning the schedule of the tests on CI
- Ensuring the project is healthy and quotas are sufficient
- Documenting the testing configuration for the release
- Identifying and fixing performance test failures (triaging/delegating as needed)

Responsibilities lying with other SIGs/teams as applicable (could be sig-scalability too):

- Fixing failing correctness test - Owner/SIG for the e2e test (as specified by [test_owners.csv])
- Fixing performance regression - Owner/SIG of relevant component (as delegated by sig-scalability)
- Testing infrastructure issues - @sig-testing
- K8s-specific large-cluster setup issues - @sig-cluster-lifecycle
- GKE-specific large-cluster setup issues - @goog-gke

[#47344]: https://github.com/kubernetes/kubernetes/issues/47344
[supporting]: http://blog.kubernetes.io/2017/03/scalability-updates-in-kubernetes-1-6
[here]: https://docs.google.com/document/d/15rD6XBtKyvXXifkRAsAVFBqEGApQxDRWM3H1bZSBsKQ
[#47865]: https://github.com/kubernetes/kubernetes/issues/47865
[test_owners.csv]: https://github.com/kubernetes/kubernetes/blob/master/test/test_owners.csv
[calendar]: https://calendar.google.com/calendar?cid=Z29vZ2xlLmNvbV9tNHA3bG1jODVubGlmazFxYzRnNTRqZjg4a0Bncm91cC5jYWxlbmRhci5nb29nbGUuY29t

repository: kubernetes/community

gha_language: Jupyter Notebook

repo_name: kubernetes/community


text:
ChemEQL
=======

ChemEQL calculates and draws **thermodynamic equilibrium** concentrations of species in complex chemical systems.
It handles **homogeneous solutions, dissolution, precipitation, titrations** with acids, bases, or other components.
**Adsorption** on up to five different particulate surfaces can be modeled with the choice of the Constant Capacitance,Diffuse Layer (Generalized Two Layer), Basic Stern Layer, or Triple Layer model to consider surface charges.
Corrections for ionic strength can be made and **activities** calculated.
**Kinetic reactions** can be simulated with one rate determining process in a system of otherwise fast thermodynamic chemical equilibrium.
**Two-dimensional logarithmic diagrams**, such as pe-pH, or generally pX vs. pY, can be calculated.
A drawing option is implemented.

A **library** with over 1750 thermodynamic stability constants allows quick access, comfortable creation of input matrices and hence easy use of the program.
A second library contains more than 300 solubility products can be introduced if **solid phases** are modeled.
Both libraries can be altered and extended with new reactions and stability constants.
Output data are formatted for .xls or for import in a graphic program.

ChemEQL 3.1 is a Java port (by freelancer Kai-Holger Brassel) of a native Mac OS 9 application that in turn was an extended and user-friendly version (by Dr. Beat Müller from EAWAG) of the original program MICROQL by John Westall.
ChemEQL 3.1 and its manual with many representative examples are available at: http://www.eawag.ch/en/department/surf/projects/chemeql/.

In 2013 this repository was created with the aim to modernize the application by using a recent Java version (Java 8 at that time), move from Swing to JavaFX for the UI toolkit and replace the outdated proprietary diagram library de.vseit.showit, again by JavaFX.
After donating the code and some first refactorings, this effort came to a halt, leaving the code base in a state that will not compile.

Meanwhile Beat Müller retired and Kai is busy with other projects.
Kai cannot afford to work on ChemEQL 4 without sponsering.
Also note, that given the developments in scientific computing over the last decade, rewriting the application in Python may be a worthwhile alternative to updating the Java version.
In any case, this repo will preserverve the legacy of ChemEQL in the meantime.

repository: eawag-surface-waters-research/ChemEQL

repo_name: eawag-surface-waters-research/ChemEQL


text:
# Apprasail talk 2018
---
## Content
---
1. [Introduction](#introduction)
2. [Overview]
3. [Sankey]
4. [Conclusion]

## This is the introduction
Some introduction text, formatted in heading 2 style


text:
# Security Policy

## Supported Versions

| Version | Supported          |
| ------- | ------------------ |
| <IP_ADDRESS>a  | :white_check_mark: |
| 5.0.x   | :x:                |
| 4.0.x   | :white_check_mark: |
| < 4.0   | :x:                |

## Reporting a Vulnerability

Report a Issue by contacting us Via, Our discord server or email me!

Email<EMAIL_ADDRESS>

repository: Coltenblox/VegaX

repo_name: Coltenblox/VegaX


text:
# Using Hidden Markov Models to Score Place Cell Sequences

This project includes Python utilities Jupyter notebooks for simulating the activity of
hippocampal place cells as well as learning HMMs which represent these data.

# Notes

In addition to the usual dependencies, i.e., numpy and scipy, you will need to install a
modified version of the hmmlearn library (https://github.com/ckemere/hmmlearn.git).

# Running

The [vonMisesRuns notebook](vonMisesRuns.ipynb) creates simulated place field data for 1000
short runs through different (WorldParameters['NEnv'] = 5) circular mazes containing
a large number of potential place fields (NumNeurons = 100, WorldParameters['alpha'] =
Pr(active in environment) = 0.5). The data are saved in a List of Lists of np arrays
(NEnvs x NSequences x NumNeurons), and then exported in a Pickle file.

The [HMMForSpikingData notebook](HMMForSpikingData.ipynb) loads the Pickle file and trains
HMMs using a subset of the data sequences. The remainder are used for evaluating the model
log-likelihood and to generate plots.

repository: ckemere/SimulatedReplayStatistics

repo_name: ckemere/SimulatedReplayStatistics


text:
# BikiniProxy

BikiniProxy is a novel technique to provide self-healing for the web.
BikiniProxy is designed as an HTTP proxy that uses five self-healing strategies to rewrite buggy HTML and Javascript code.

[Fully Automated HTML and Javascript Rewriting for Constructing a Self-healing Web Proxy](https://arxiv.org/pdf/1803.08725) (Thomas Durieux, Youssef Hamadi and Martin Monperrus), arXiv 1803.08725, 2018.

## Self-healing Strategies

1. *HTTP/HTTPS Redirector* that changes HTTP URLs to HTTPS URLs.
2. *HTML Element Creator* that creates missing HTML elements.
3. *Library Injector* injects missing libraries in the page.
4. *Line Skipper* wraps a statement with an if to prevent invalid object access.
5. *Object Creator* initializes a variable with an empty object to prevent further null dereferences.

## DeadClick

DeadClick is a novel benchmark of JavaScript errors that are triggered in large production web applications.
This benchmark has been constructed with a unique methodology based crawling the web for finding errors and advanced proxying to ensure that those errors can be reliably reproduced.
The final benchmark contains 555 JavaScript reproducible production errors.

See DeadClick/README.me to have more details

## Example

![bikiniproxy](https://user-images.githubusercontent.com/5577568/37277161-3516e9a4-25e4-11e8-9f15-9eb08047b6fb.gif)

## License

MIT License

repository: hankers/bikiniproxy

repo_name: hankers/bikiniproxy


text:
# echo-initializr

Echo Initializr is a tool created to help developers start projects created in the Echo Framework more quickly, without having to waste time with basic configurations.

## Usage

#### Available Commands:

  - help - Help about any command
  - init  - Create a basic project using echo framework from the scratch
    -   -d, --dependencies stringArray

    Set the dependencies of your project. (default: empty)

    - -h, --help

    help for init

    - -n, --namespace [string]

    Set your project's name (default: github.com/example/sample)

    - -o, --outputDir [string]

    Set the output directory to your project. (default "$HOME/echo_initializr")

    - -p, --port [int]

    Set the port of your project webserver. (default 8080)

    - -v, --version [string]

    Set your project's version (default: installed)

### To try, just run this command on the root of the echo-initializr's project
```
go run main.go init --namespace "github.com/example/sample" -d "github.com/gorilla/mux,github.com/google/uuid" -p 8080
```

## Tips:
### RUN
Inside the root of this project:
```
go build
```
A executable named "echo-initializr" will be generated.

Place this executable where you prefer, for example:
```
mv echo-initializr $HOME/go/bin
```
Now you can just set this in you PATH as variable to use directly in you terminal.

Open the .bash_profile
```
vim $HOME/.bash_profile
```
Write this lines: (Assuming that you have placed the executable file in the same folder as me)
```
export ECHOINITIALZR=$HOME/go/bin
export PATH=$PATH:$ECHOINITIALZR
```

Now you can run the command anywhere in you terminal:
```
echo-initializr help
```

repository: brunocalmon/echo-initializr

gha_language: Go

repo_name: brunocalmon/echo-initializr


text:
#

## Rapid Distance-Based Outlier Detection via Sampling

 [1] is a simple and rapid distance-based method that utilizes the nearest neighbor distance on a small sample from the dataset. It takes a small random sample of the entire dataset and then assigns an outlierness score to each point, as the distance from the point to its nearest neighbor in the sample set. Therefore, this method enjoys a linear time complexity concerning each one of the essential variables, viz the number of objects, the number of dimensions, and the number of samples; furthermore,  has a constant space complexity, which makes it ideal for analyzing massive datasets.

 is really simple to understand and also to implement, and only requires one single parameter, which even with its default value proposed by the authors, promising outcomes could be achieved over multiple datasets. For this reason, we follow the same procedure as suggested in the original paper and set the sample size, _s_, equal to 20 in our experiments.

[1] Sugiyama, Mahito, and Karsten Borgwardt. "Rapid distance-based outlier detection via sampling." Advances in Neural Information Processing Systems 26 (2013): 467-475.

## Implementation details

You can follow the subsequent script with the suggested parameters as a template to use the `Sp.m` function and obtain the required results out of an arbitrary dataset:

```matlab
% Setting initial parameters
s = 20; % sample size
totIter = 40; % total number of independent runs

% Mammography dataset
load('Mammography_(11183by6_260o).mat');

tEarr_Mammography = [];
ROCarr_Mammography = [];
PRarr_Mammography = [];
for e1 = 1:totIter
    tic
    [~,ROC,PR] = Sp(X,y,s);
    tEarr_Mammography = [tEarr_Mammography toc];
    ROCarr_Mammography = [ROCarr_Mammography ROC];
    PRarr_Mammography = [PRarr_Mammography PR];
end
ROCavg_Mammography = mean(ROCarr_Mammography); ROCstd_Mammography = std(ROCarr_Mammography);
PRavg_Mammography = mean(PRarr_Mammography); PRstd_Mammography = std(PRarr_Mammography);
timElpAvg_Mammography = mean(tEarr_Mammography);

fprintf('Sp (s=%d) result with totIter = %d for Mammography:\t\tROC = %0.3f+-%0.3f\t\tPR = %0.3f+-%0.3f\t\telpsTime = %0.3f sec\n\n',...
    s,totIter,ROCavg_Mammography,ROCstd_Mammography,PRavg_Mammography,PRstd_Mammography,timElpAvg_Mammography);
save(['res_Sp(s=' num2str(s) ')_Mammography.mat'],'ROCarr_Mammography','PRarr_Mammography','ROCavg_Mammography','ROCstd_Mammography','PRavg_Mammography','PRstd_Mammography','timElpAvg_Mammography');
```

path: /codes/_competing methods/Sp/Readme.md


text:
---
external help file: Microsoft.Tools.WindowsInstaller.PowerShell.dll-Help.xml
Module Name: MSI
online version:
schema: 2.0.0
---

# Get-MSIComponentState

## SYNOPSIS
Gets the install state for all authored components for one or more products installed on the machine.

## SYNTAX

### Product (Default)
```
Get-MSIComponentState [-Product] <ProductInstallation[]> [<CommonParameters>]
```

### ProductCode
```
Get-MSIComponentState [-ProductCode] <String[]> [-UserContext <UserContexts>] [-UserSid <String>]
 [<CommonParameters>]
```

## DESCRIPTION
Gets the install state for all components authored into one or more products.
This includes all patches applied to the product.
In addition to the information returned from Get-MSIComponentInfo, the authored component identifier from the Component table is attached along with a simple boolean property that determines if the component is installed locally or not.

## EXAMPLES

### EXAMPLE 1
```
get-msicomponentstate "{877EF582-78AF-4D84-888B-167FDC3BCC11}"
```

Gets state information for all components authored into the product "{877EF582-78AF-4D84-888B-167FDC3BCC11}" and all applied patches.

### EXAMPLE 2
```
get-msiproductinfo -name *TEST* | get-msicomponentstate
```

Gets state information for all components authored into any product where the ProductName matches *TEST*.

## PARAMETERS

### -Product
The products for which authored component state is retrieved.

```yaml
Type: ProductInstallation[]
Parameter Sets: Product
Aliases:

Required: True
Position: 0
Default value: None
Accept pipeline input: True (ByValue)
Accept wildcard characters: False
```

### -ProductCode
The installed ProductCodes that define the components for which state information is retrieved.

```yaml
Type: String[]
Parameter Sets: ProductCode
Aliases:

Required: True
Position: 0
Default value: None
Accept pipeline input: True (ByPropertyName, ByValue)
Accept wildcard characters: False
```

### -UserContext
The context for registered products.
This can be a combination of "Machine", "UserManaged", or "UserUnmanaged".

```yaml
Type: UserContexts
Parameter Sets: ProductCode
Aliases: Context, InstallContext

Required: False
Position: Named
Default value: All
Accept pipeline input: True (ByPropertyName)
Accept wildcard characters: False
```

### -UserSid
The security identifier for a user for user-managed and user-unmanaged products.

```yaml
Type: String
Parameter Sets: ProductCode
Aliases:

Required: False
Position: Named
Default value: None
Accept pipeline input: True (ByPropertyName)
Accept wildcard characters: False
```

### CommonParameters
This cmdlet supports the common parameters: -Debug, -ErrorAction, -ErrorVariable, -InformationAction, -InformationVariable, -OutVariable, -OutBuffer, -PipelineVariable, -Verbose, -WarningAction, and -WarningVariable.
For more information, see about_CommonParameters (http://go.microsoft.com/fwlink/?LinkID=113216).

## INPUTS

### Microsoft.Deployment.WindowsInstaller.ProductInstallation

## OUTPUTS

### Microsoft.Deployment.WindowsInstaller.ComponentInstallation#State

## NOTES

## RELATED LINKS

[Get-MSIComponentInfo](get-msicomponentinfo)

[Get-MSIProductInfo](get-msiproductinfo)

repository: laudarch/psmsi

repo_name: laudarch/psmsi


text:
# terminfo

The `terminfo` library provides parser for compiled [terminfo(5)](http://linux.die.net/man/5/terminfo)
entries.

## LICENSE

[![BSD-3-Clause licensed](https://img.shields.io/badge/license-BSD-blue.svg)](https://raw.githubusercontent.com/0xAX/mysql-tools/master/LICENSE.md)

## Contribute

Feel free to create issues or pull-requests if you have any problems.

Please read [CONTRIBUTING.md](https://github.com/0xAX/mysql-tools/blob/master/CONTRIBUTING.md) before pushing any changes.

## Author

[@0xAX](https://twitter.com/0xAX)

repository: hemel-cse/mysql-tools

repo_name: hemel-cse/mysql-tools


text:
To set up SSH for github access, use the following commands (change the email address):

```
ssh-keygen -t ed25519 -C<EMAIL_ADDRESS>cat ~/.ssh/ssh_ed25519.pub
```

Copy the contents of the file to Github under your user account. Now `git clone` will work.

repository: ajbogh/OpenCodeProject

repo_name: ajbogh/OpenCodeProject


text:
# Random Batch LP Solver

This is a batch linear program solver for Nvidia GPUs, suitable for solving many 2D problems efficiently.

To test results from paper "Two-Dimensional Batch Linear Programming on the GPU" please see the "Improvements" branch.

## How to build

If using Visual studio, there is a ready-to-use solution file avaialable called `LP.sln`. Otherwise ensure there is a working version of CMAKE available.

### CMake

Use CMake to generate the relevant makefile, VS solution, e.t.c. Useful CMake flags to set would be adding `-arch=sm_xx` to "CMAKE_CUDA_FLAGS". This ensures that the project is built using a suitable architecture. Requires `xx` to be set to at least 30. Therefor ensure the GPU this is ran on is an NVidia graphics card with compute capability of at least 30.

### Windows

Directory contains a visual studio solution not requiring CMake. Open this .sln file in visual studio.

## What this project contains

CMake capabilities to generate a build tool such as make or .sln. The GLM library in `include/glm`

## How to Run

Build and compile the project to generate an executable. The default location will be `x64/"build_mode"/LP` where "build_mode" is either "Debug" or "Release".

Executable takes 2 arguments: 1) The name of constraint data to read in. 2) The number of batches of these to solve.

An example would be `./x64/Release/LP benchmarks/64 1024` to use the pregenerated file containing 64 random constraints with feasible solution, for 1024 batches.

## Program Output

The program will output timing to the "timings" folder in a timings.txt file. This file contains lines of the form `%1 %2 %3\n` where %1 is the number of constraints (e.g. 64), %2 is the number of batches (e.g. 1024), %3 is the time in milliseconds that the program took.

The solutions to the linear program are printed to console. Access to these values is accessible within the code by both GPU and CPU code in `output[i]` where i ranges over all batches.

## Runing a test example

Once an executable has been generated one can check the program is working correctly. This example uses a release mode build and can be done from the command line by running the following command from the base folder directory for this code:

`"./x64/Release/LP.exe" benchmarks/64 1024`

Or for Linux:

`./x64/Release/LP benchmarks/64 1024`

which should provide the output:

`Batch 0          Optimal location is x: 1.265306 y: 0.448980     value of 2.163265`

## Custom Data

To use custom data, create 3 files of the form *_A.txt, *_B.txt, *_C.txt. Where * is a consistent name for all 3 files. File *_A.txt starts with a line of 2 numbers, the first is the number of constraints within the file (n) and the dimension of the problem (d) (should always be 2). The remainder of the file is (n) lines of (d) numbers. These represent the left hand side of the constraints A1x + A2y <= B. All should be space-separated when on the same line

File *_B.txt contains (n) lines of 1 number. These represent the right hand side of the constraints A1x + A2y <= B.

File *_C.txt contains (d) lines of 1 number (d=2). These represent the objective function to maximise. Ensure data is written with respects to maximising objective function, and inequalities are of form Ax <= B.

For solving a minimization (e.g. min ax + by ) there is a corresponding maximization function (max -ax - by) that can always be used.

repository: twinkarma/LP

repo_name: twinkarma/LP


text:
# Screen/Caputer module for Nexss PROGRAMMER 2.0

Allows to capture desktop on selected area by the user.

## Examples

```sh
nexss Screen/Capture --file=myfile.png
```

## Credits

Languages/Technologies used for this Nexss PROGRAMMER package:

- NodeJS
- AutoIt3
- <https://github.com/J2TEAM/AutoIt-Imgur-UDF/blob/master/include/JSON.au3>
- <https://www.autoitscript.com/forum/topic/95920-solved-selecting-a-rectangle-to-screencapture/>

gha_language: AutoIt


text:
---
title: Micro-Segmentation with Istio Authorization
description: Describe Istio's authorization feature and how to use it in various use cases.
publishdate: 2018-07-20
subtitle:
attribution: Limin Wang
keywords: [authorization,rbac,security]
target_release: 0.8
---

Micro-segmentation is a security technique that creates secure zones in cloud deployments and allows organizations to
isolate workloads from one another and secure them individually.
[Istio's authorization feature](/docs/concepts/security/#authorization), also known as Istio Role Based Access Control,
provides micro-segmentation for services in an Istio mesh. It features:

* Authorization at different levels of granularity, including namespace level, service level, and method level.
* Service-to-service and end-user-to-service authorization.
* High performance, as it is enforced natively on Envoy.
* Role-based semantics, which makes it easy to use.
* High flexibility as it allows users to define conditions using
[combinations of attributes](/docs/reference/config/security/conditions/).

In this blog post, you'll learn about the main authorization features and how to use them in different situations.

## Characteristics

### RPC level authorization

Authorization is performed at the level of individual RPCs. Specifically, it controls "who can access my `bookstore` service”,
or "who can access method `getBook` in my `bookstore` service”. It is not designed to control access to application-specific
resource instances, like access to "storage bucket X” or access to "3rd book on 2nd shelf”. Today this kind of application
specific access control logic needs to be handled by the application itself.

### Role-based access control with conditions

Authorization is a [role-based access control (RBAC)](https://en.wikipedia.org/wiki/Role-based_access_control) system,
contrast this to an [attribute-based access control (ABAC)](https://en.wikipedia.org/wiki/Attribute-based_access_control)
system. Compared to ABAC, RBAC has the following advantages:

* **Roles allow grouping of attributes.** Roles are groups of permissions, which specifies the actions you are allowed
to perform on a system. Users are grouped based on the roles within an organization. You can define the roles and reuse
them for different cases.

* **It is easier to understand and reason about who has access.** The RBAC concepts map naturally to business concepts.
For example, a DB admin may have all access to DB backend services, while a web client may only be able to view the
frontend service.

* **It reduces unintentional errors.** RBAC policies make otherwise complex security changes easier. You won't have
duplicate configurations in multiple places and later forget to update some of them when you need to make changes.

On the other hand, Istio's authorization system is not a traditional RBAC system. It also allows users to define **conditions** using
[combinations of attributes](/docs/reference/config/security/conditions/). This gives Istio
flexibility to express complex access control policies. In fact, **the "RBAC + conditions” model
that Istio authorization adopts, has all the benefits an RBAC system has, and supports the level of flexibility that
normally an ABAC system provides.** You'll see some [examples](#examples) below.

### High performance

Because of its simple semantics, Istio authorization is enforced on Envoy as a native authorization support. At runtime, the
authorization decision is completely done locally inside an Envoy filter, without dependency to any external module.
This allows Istio authorization to achieve high performance and availability.

### Work with/without primary identities

Like any other RBAC system, Istio authorization is identity aware. In Istio authorization policy, there is a primary
identity called `user`, which represents the principal of the client.

In addition to the primary identity, you can also specify any conditions that define the identities. For example,
you can specify the client identity as "user Alice calling from Bookstore frontend service”, in which case,
you have a combined identity of the calling service (`Bookstore frontend`) and the end user (`Alice`).

To improve security, you should enable [authentication features](/docs/concepts/security/#authentication),
and use authenticated identities in authorization policies. However, strongly authenticated identity is not required
for using authorization. Istio authorization works with or without identities. If you are working with a legacy system,
you may not have mutual TLS or JWT authentication setup for your mesh. In this case, the only way to identify the client is, for example,
through IP. You can still use Istio authorization to control which IP addresses or IP ranges are allowed to access your service.

## Examples

The [authorization task](/docs/tasks/security/authorization/authz-http/) shows you how to
use Istio's authorization feature to control namespace level and service level access using the
[Bookinfo application](/docs/examples/bookinfo/). In this section, you'll see more examples on how to achieve
micro-segmentation with Istio authorization.

### Namespace level segmentation via RBAC + conditions

Suppose you have services in the `frontend` and `backend` namespaces. You would like to allow all your services
in the `frontend` namespace to access all services that are marked `external` in the `backend` namespace.

{{< text yaml >}}
apiVersion: "rbac.istio.io/v1alpha1"
kind: ServiceRole
metadata:
  name: external-api-caller
  namespace: backend
spec:
  rules:
  - services: ["*"]
    methods: ["*”]
    constraints:
    - key: "destination.labels[visibility]”
      values: ["external"]
---
apiVersion: "rbac.istio.io/v1alpha1"
kind: ServiceRoleBinding
metadata:
  name: external-api-caller
  namespace: backend
spec:
  subjects:
  - properties:
      source.namespace: "frontend”
  roleRef:
    kind: ServiceRole
    name: "external-api-caller"
{{< /text >}}

The `ServiceRole` and `ServiceRoleBinding` above expressed "*who* is allowed to do *what* under *which conditions*”
(RBAC + conditions). Specifically:

* **"who”** are the services in the `frontend` namespace.
* **"what”** is to call services in `backend` namespace.
* **"conditions”** is the `visibility` label of the destination service having the value `external`.

### Service/method level isolation with/without primary identities

Here is another example that demonstrates finer grained access control at service/method level. The first step
 is to define a `book-reader` service role that allows READ access to `/books/*` resource in `bookstore` service.

{{< text yaml >}}
apiVersion: "rbac.istio.io/v1alpha1"
kind: ServiceRole
metadata:
  name: book-reader
  namespace: default
spec:
  rules:
  - services: ["bookstore.default.svc.cluster.local"]
    paths: ["/books/*”]
    methods: ["GET”]
{{< /text >}}

#### Using authenticated client identities

Suppose you want to grant this `book-reader` role to your `bookstore-frontend` service. If you have enabled
[mutual TLS authentication](/docs/concepts/security/#mutual-tls-authentication) for your mesh, you can use a
service account to identify your `bookstore-frontend` service. Granting the `book-reader` role to the `bookstore-frontend`
service can be done by creating a `ServiceRoleBinding` as shown below:

{{< text yaml >}}
apiVersion: "rbac.istio.io/v1alpha1"
kind: ServiceRoleBinding
metadata:
  name: book-reader
  namespace: default
spec:
  subjects:
  - user: "cluster.local/ns/default/sa/bookstore-frontend”
  roleRef:
    kind: ServiceRole
    name: "book-reader"
{{< /text >}}

You may want to restrict this further by adding a condition that "only users who belong to the `qualified-reviewer` group are
allowed to read books”. The `qualified-reviewer` group is the end user identity that is authenticated by
[JWT authentication](/docs/concepts/security/#authentication). In this case, the combination of the client service identity
(`bookstore-frontend`) and the end user identity (`qualified-reviewer`) is used in the authorization policy.

{{< text yaml >}}
apiVersion: "rbac.istio.io/v1alpha1"
kind: ServiceRoleBinding
metadata:
  name: book-reader
  namespace: default
spec:
  subjects:
  - user: "cluster.local/ns/default/sa/bookstore-frontend"
    properties:
      request.auth.claims[group]: "qualified-reviewer"
  roleRef:
    kind: ServiceRole
    name: "book-reader"
{{< /text >}}

#### Client does not have identity

Using authenticated identities in authorization policies is strongly recommended for security. However, if you have a
legacy system that does not support authentication, you may not have authenticated identities for your services.
You can still use Istio authorization to protect your services even without authenticated identities. The example below
shows that you can specify allowed source IP range in your authorization policy.

{{< text yaml >}}
apiVersion: "rbac.istio.io/v1alpha1"
kind: ServiceRoleBinding
metadata:
  name: book-reader
  namespace: default
spec:
  subjects:
  - properties:
      source.ip: <IP_ADDRESS>/9
  roleRef:
    kind: ServiceRole
    name: "book-reader"
{{< /text >}}

## Summary

Istio’s authorization feature provides authorization at namespace-level, service-level, and method-level granularity.
It adopts "RBAC + conditions” model, which makes it easy to use and understand as an RBAC system, while providing the level of
flexibility that an ABAC system normally provides. Istio authorization achieves high performance as it is enforced
natively on Envoy. While it provides the best security by working together with
[Istio authentication features](/docs/concepts/security/#authentication), Istio authorization can also be used to
provide access control for legacy systems that do not have authentication.


text:
This README includes instruction for unit-testing a coordinate-based meta-analysis with the author-topic model.

## Reference
Gia H. Ngo, Simon B. Eickhoff, Minh Nguyen, Peter T. Fox,  R. Nathan Spreng, B. T. Thomas Yeo. [Beyond Consensus: Embracing Heterogeneity in Neuroimaging Meta-Analysis](https://www.biorxiv.org/content/early/2017/06/19/149567). BioRxiv preprint

----

## Data
For this unit test, we used activation coordinates from 30 experiments of self-generated thought dataset (`./unit_test_sample_coordinates.txt`).
The original self-generated thought dataset can be found at`../SelfGeneratedThought/MNI152_ActivationCoordinates`.

----

## Run

In Matlab, run `CBIG_AuthorTopic_UnitTest.m`

If the local environment has been set up properly (see the project's main [README](https://github.com/ThomasYeoLab/CBIG/stable_projects/meta-analysis/Ngo2019_AuthorTopic)), the unit test would perform the following steps:

1. Prepare input data as a Matlab `.mat` file in the format required by the inference functions and save it under `./data` directory.
2. Perform inference to estimate the model parameters. For testing, inference will only be performed up to 3 cognitive components with 3 re-initializations each. All output files are saved under `./outputs` directory.
3. Visualize components of the 2-component solution. The output figures will be saved under `./figures` directory.
4. Compute Bayesian Information Criterion (BIC) across different number of components. The output files and figures will be saved under `./BIC` directory.

repository: ThomasYeoLab/CBIG

gha_language: MATLAB

repo_name: ThomasYeoLab/CBIG


text:
# Udacity
# Self Driving Car Nanodegree

## Term 3 Capstone Project
### System Integration: Programming a real self driving car

![alt text](imgs/RetroSDC2.png "Retro SDC - Home James!")

### Team "Home James!"

* Kevin Randall	 -<EMAIL_ADDRESS>(Team Lead)

* Driss Squalli -<EMAIL_ADDRESS>
* Grigory Kostromin -<EMAIL_ADDRESS>
* Sharon Liu -<EMAIL_ADDRESS>
* Harish Vadlamani -<EMAIL_ADDRESS>

This is the final project of Udacity's Self Driving Car (SDC) Nanodegree program. In this project we use the open source Robotic Operating System (ROS) together with dataspeed Drive By Wire (DBW) to control a vehicle's steering, brake and accelerator. Code is tested on Udacity's simulator and (having passed review) is loaded on to Carla - Udacity's Lincoln MKZ SDC, to navigate a test lot. This project leverages skills and techniques acquired from earlier projects in the program.

ROS uses the concept of nodes as discrete processing units that "publish" (send) "topics" (data) that are received by "subscribers". The architecture for this project is illustreted in block diagram below.

![alt text](imgs/Architecture.png "SDC Architecture.png")

This project essentially uses the same track as Path Planning (term 3, project 1) except here the waypoints are closely spaced (about 0.5 meters apart), so waypoint interpolation is not necessary for this project.
![alt text](imgs/T3P3_track.png "Sim Track")

In addition the capstone project sim track features 8 Traffic lights, locations around the track are shown below:

![alt text](imgs/T3P3_TL_positions.png "Traffic Lights")

In the figure below, the Udacity Sim vehicle is being held (brake = 400, throttle = 0) behind the stop line for a red light using code in this repo.

![alt text](imgs/AtStopLight.png "At Stop Light")

### Code

The three main components that we completed for this project are briefly described below.

##### Waypoint updater

Track waypoints are loaded at initialization. Based on the current pose of the vehicle the waypoint updater assigns target linear and angular velocities, depending on traffic lights and obstacles, for 200 waypoints ahead of the vehicle.

##### Traffic Light Detector

Traffic light stop line positions are read in at initialization from the configuration file - src/tl_detector/sim_traffic_light_config.yaml.

Camera images (from the /image_color topic) are classified as containing a red light, or not. The index of an upcoming red light is passed to the waypoint updater decreasing upcoming target velocities, so that the vehicle stops short of a red light. For a green light the waypoint updater will increase target velocities to a preset maximum velocity (or maintain maximum velocity).

##### Drive by wire

The DBW node utilizes PID and lowpass filter control to smoothly adjust throttle, brake and steering according to the waypoint target velocities.

#### Implementation
In this version we have used an existing CNN image classification model (from Team America) to detect upcoming red lights. We are currently working on a version using our own classifier.

Testing included verifying that the vehicle maximum speed was limited according to the configuration file and that toggling between auto and manual conrol did not introduce instabilty from accumulated integral errors in the PID controller for example.

##### Docker Image for Tensorflow with GPU acceleration

Ubuntu is necessary for this project. Slack and forum discussions indicate that the vehicle becomes uncontrolllable if trying to run project code in a Virtual Machine (VM) - for example running a Ubuntu VM on a windows machine.

Initial testing showed slight performance issues even with a native Ubuntu 16.04 desktop (Intel i5-4430 with 16GB RAM), when using the image classifier. Utilizing an Nvidia Titan X Pascal GPU (12GB) on this system solved performance issues. Using Tensorflow GPU acceleration requires a modified Docker image. Files to create the image are included in the Docker-gpu directory, and are based on Attila Babo (https://gist.github.com/babo/94309eac327209ca68867fb579bb12be)

Build the docker image with gpu support:

bash docker build . -t capstone_gpu

Run the docker file:

sudo nvidia-docker run -e DISPLAY=$DISPLAY -p 4567:4567 -v $PWD:/capstone -v
/tmp/log:/root/.ros/ -v /tmp/.X11-unix:/tmp/.X11-unix:rw --rm -it capstone_gpu

____
Udacity SDC readme continues below
____

This is the project repo for the final project of the Udacity Self-Driving Car Nanodegree: Programming a Real Self-Driving Car. For more information about the project, see the project introduction [here](https://classroom.udacity.com/nanodegrees/nd013/parts/6047fe34-d93c-4f50-8336-b70ef10cb4b2/modules/e1a23b06-329a-4684-a717-ad476f0d8dff/lessons/462c933d-9f24-42d3-8bdc-a08a5fc866e4/concepts/5ab4b122-83e6-436d-850f-9f4d26627fd9).

Please use **one** of the two installation options, either native **or** docker installation.

### Native Installation

* Be sure that your workstation is running Ubuntu 16.04 Xenial Xerus or Ubuntu 14.04 Trusty Tahir. [Ubuntu downloads can be found here](https://www.ubuntu.com/download/desktop).
* If using a Virtual Machine to install Ubuntu, use the following configuration as minimum:
  * 2 CPU
  * 2 GB system memory
  * 25 GB of free hard drive space

  The Udacity provided virtual machine has ROS and Dataspeed DBW already installed, so you can skip the next two steps if you are using this.

* Follow these instructions to install ROS
  * [ROS Kinetic](http://wiki.ros.org/kinetic/Installation/Ubuntu) if you have Ubuntu 16.04.
  * [ROS Indigo](http://wiki.ros.org/indigo/Installation/Ubuntu) if you have Ubuntu 14.04.
* [Dataspeed DBW](https://bitbucket.org/DataspeedInc/dbw_mkz_ros)
  * Use this option to install the SDK on a workstation that already has ROS installed: [One Line SDK Install (binary)](https://bitbucket.org/DataspeedInc/dbw_mkz_ros/src/81e63fcc335d7b64139d7482017d6a97b405e250/ROS_SETUP.md?fileviewer=file-view-default)
* Download the [Udacity Simulator](https://github.com/udacity/CarND-Capstone/releases).

### Docker Installation
[Install Docker](https://docs.docker.com/engine/installation/)

Build the docker container
```bash
docker build . -t capstone
```

Run the docker file
```bash
docker run -p 4567:4567 -v $PWD:/capstone -v /tmp/log:/root/.ros/ --rm -it capstone
```

### Port Forwarding
To set up port forwarding, please refer to the [instructions from term 2](https://classroom.udacity.com/nanodegrees/nd013/parts/40f38239-66b6-46ec-ae68-03afd8a601c8/modules/0949fca6-b379-42af-a919-ee50aa304e6a/lessons/f758c44c-5e40-4e01-93b5-1a82aa4e044f/concepts/16cf4a78-4fc7-49e1-8621-3450ca938b77)

### Usage

1. Clone the project repository
```bash
git clone https://github.com/udacity/CarND-Capstone.git
```

2. Install python dependencies
```bash
cd CarND-Capstone
pip install -r requirements.txt
```
3. Make and run styx
```bash
cd ros
catkin_make
source devel/setup.sh
roslaunch launch/styx.launch
```
4. Run the simulator

### Real world testing
1. Download [training bag](https://s3-us-west-1.amazonaws.com/udacity-selfdrivingcar/traffic_light_bag_file.zip) that was recorded on the Udacity self-driving car.
2. Unzip the file
```bash
unzip traffic_light_bag_file.zip
```
3. Play the bag file
```bash
rosbag play -l traffic_light_bag_file/traffic_light_training.bag
```
4. Launch your project in site mode
```bash
cd CarND-Capstone/ros
roslaunch launch/site.launch
```
5. Confirm that traffic light detection works on real life images

repository: sdriss/CarND-Capstone

repo_name: sdriss/CarND-Capstone


text:
---
layout: default
---

# 1996-10-17 - [NOISE] White house docs

## Header Data

From: Marshall Clow<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: 1c60e304d6a661dd1341c51b90e2bf3e5f7cbd044c2654be99603d97ce247d02

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1996-10-17 04:40:22 UTC

Raw Date: Wed, 16 Oct 1996 21:40:22 -0700 (PDT)

## Raw message

```
{% raw  %}From: Marshall Clow<EMAIL_ADDRESS>Date: Wed, 16 Oct 1996 21:40:22 -0700 (PDT)
To<EMAIL_ADDRESS>Subject: [NOISE] White house docs
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

Just for fun:

 go to <http://www.whitehouse.gov>, go into the library, and ask to search everything.
Search for "key recovery". Here's a partial list of what you get:

------------------------------------------------------------------------
Public Press Releases

October 6, 1996
HARTFORD DEBATE '96: THE FIRST PRESIDENTIAL DEBATE BETWEEN PRESIDENT
CLINTON AND SENATOR DOLE

------------------------------------------------------------------------
White House Website

Franklin D. Roosevelt
...recovery ...
http://www.whitehouse.gov/WH/glimpse/presidents/html/fr32.html

Franklin D. Roosevelt [Text Version]
...recovery ...
http://www.whitehouse.gov/WH/glimpse/presidents/html/fr32-plain.html

Making West Virginia a Better Place to Live and Work
...Key Industries. After a decade of enormous job losses ...
http://www.whitehouse.gov/WH/Accomplishments/states/html/wv.html

Making Hawaii a Better Place to Live and Work
...Key Industries. After a decade of enormous job losses ...
http://www.whitehouse.gov/WH/Accomplishments/states/html/hw.html

Making Oregon a Better Place to Live and Work
...Key Industries. After a decade of enormous job losses ...
http://www.whitehouse.gov/WH/Accomplishments/states/html/or.html

Making Montana a Better Place to Live and Work
...Key Industries. After a decade of enormous job losses ...
http://www.whitehouse.gov/WH/Accomplishments/states/html/mt.html

and on for the rest of the 50 states.
These web pages are all (ok, I looked at a few, not all) titled: "Making XXX a Better Place to Live and Work" and subtitled: "America Is Moving In the Right Direction Under President Clinton"

So I compared the "accomplishments" for Oregon and Montana. Discounting all the places where the name of the state was the only thing changed, I was left with:

Oregon:
*Unemployment Rate in Oregon Has Declined from 8.0% to 4.7%.
*Consumer Confidence Is Up 43%, After Dropping During the Prior Four
*155,000 New Jobs in 33 Months -- More than the Entire Previous
*145,323 Working Families Receive a Tax Cut. The President's expanded
*332 New Police Officers in Oregon. The President's Crime Bill puts 332
*431,000 Workers Protected by Family and Medical Leave. The Family and

Montana:
*Unemployment Rate in Montana Has Declined from 6.6% to 5.9%.
*Consumer Confidence Is Up 71%, After Dropping During the Prior Four
*39,200 New Jobs in 33 Months -- More than the Entire Previous
*47,638 Working Families Receive a Tax Cut. The President's expanded
*120 New Police Officers in Montana. The President's Crime Bill puts 120
*76,000 Workers Protected by Family and Medical Leave. The Family and

-- Marshall

Marshall Clow     Aladdin Systems<EMAIL_ADDRESS>
"We're not gonna take it/Never did and never will
We're not gonna take it/Gonna break it, gonna shake it,
let's forget it better still" -- The Who, "Tommy"

{% endraw %}
```

## Thread

+ Return to [October 1996](/archive/1996/10)

+ Return to "[Marshall Clow <mclow@owl.csusm.edu>](/authors/marshall_clow_mclow_at_owl_csusm_edu_)"

+ 1996-10-17 (Wed, 16 Oct 1996 21:40:22 -0700 (PDT)) - [NOISE] White house docs - _Marshall Clow<EMAIL_ADDRESS>


text:
# Yet Another Colored Outlines Mod

An extremely simple mod to make block outlines visible against any color block.

Ever had trouble mining the correct block of obsidian or black concrete? This mod makes the outline color change depending on the block type.


text:
# Project Euler

Project Euler for Python.

## Running

Run the following:

```
git clone https://github.com/ahmedcharles/euler-py
cd euler-py
python problem_<number>.py
```

```
Copyright (C) 2015 Ahmed Charles -<EMAIL_ADDRESS>Copyright (C) 2015 Nadeen Hodge
Distributed under the Boost Software License, Version 1.0.
   (See accompanying file LICENSE_1_0.txt or copy at
         http://www.boost.org/LICENSE_1_0.txt)
```

repository: nhodge/euler-py

repo_name: nhodge/euler-py


text:
Webtrekk Tracking Library for Swift
===================================

The Webtrekk SDK allows you to track user activities, screen flow and media usage for an App. All data is send to the Webtrekk tracking system for further analysis.

Requirements
============

| Plattform | Version            |
|-----------|-------------------:|
| `iOS`     |             `8.0+` |
| `tvOS`    |             `9.0+` |
| `watchOs` |             `2.0+` |

Xcode 7.3+ and Swift 2.2 for versions below and equal to 4.0.1

Xcode 8.0+ and Swift 3.0 starting with version 4.1.0

tvOS support starting with verison 4.2.0 with the follow limitation:
No screen resolution and network status automatic tracing support.

watchOS support starting with verison 4.3.0 with the follow limiation
1. No screen resolution and network status automatic tracking support.
2. No deep link and campaign support.

Installation
============

Using [CocoaPods](htttp://cocoapods.org) the installation of the Webtrekk SDK is done by simply adding it to your project's `Podfile`:

pod 'Webtrekk'

Migrating from Webtrekk SDK V3
==============================

The Webtrekk SDK V4 offers the possibility to migrate some stored information to the new SDK. This option is enabled as per default but in case the old data should be neglected and deleted the value of the `migratesFromLibraryV3` variable needs to be set to `false` before creating the first tracker. The code snippet below shows this case.

```swift
WebtrekkTracking.migratesFromLibraryV3 = false
```

Following properties are part of the migration.

| Option           | Description                                                       |
|------------------|-------------------------------------------------------------------|
| `everId`         | previously generated everId for the user                          |
| `appVersion`     | previously stored appVersion used to detect app updates           |
| `optedOut`       | previously stored status which is only migrated if not set before |
| `samplingState`  | previously stored samplingState                                   |
| `unsentRequests` | previously saved unsent requests                                  |

SSL
===

As of iOS 9 Apple is more strictly enforcing the usage of the SSL for network connections. Webtrekk highly recommend and offers the usage of a valid serverUrl with SSL support. In case there is a need to circumvent this the App needs an exception entry within the `Info.plist` this and the regulation Apple bestows upon that are well documented within the [iOS Developer Library](https://developer.apple.com/library/ios/documentation/General/Reference/InfoPlistKeyReference/Articles/CocoaKeys.html#//apple_ref/doc/uid/TP40009251-SW33)

Examples & Unit Tests
=====================

The `Xcode` directory contains all files necessary to

-	manually build the library
-	run unit test
-	run examples

```shell
# install CocoaPods 1.0.1 or newer (unless you already did)
sudo gem install cocoapods

# clone this repository
git clone https://bitbucket.org/widgetlabs/webtrekk-library.git && cd webtrekk-library

# examples & tests are located in the directory 'Xcode' …
cd Xcode

# … and are set up with CocoaPods
pod update

# 'Examples.xcworkspace' is the file you'll use from now on
open Examples.xcworkspace
```

repository: RamiroRamirez/webtrekk-ios-sdk

gha_language: Swift

repo_name: RamiroRamirez/webtrekk-ios-sdk


text:
# Fizz Buzz Kata #

Return "fizz", "buzz" or "fizzbuzz".

For a given natural number greater than zero return:

1. "fizz" if the number is dividable by 3

2. "buzz" if the number is dividable by 5

3. "fizzbuzz" if the number is dividable by 3 and 5

4. The same number if no other requirement is fulfilled

repository: luis-moral/kata-fizz-buzz

repo_name: luis-moral/kata-fizz-buzz


text:
# rules_foreign_cc

Rules for building projects using foreign build systems inside Bazel projects.

* Experimental - API will most definitely change.
* This is not an officially supported Google product
(meaning, support and/or new releases may be limited.)

## ./configure && make

**NOTE**: this requires building Bazel from head after https://github.com/bazelbuild/bazel/commit/060b1624e4d64dbdbeb375f9a55a3da9bd055a54

Example:

* In `WORKSPACE`, we use a `new_http_archive` to download tarballs with the libraries we use.
* In `BUILD`, we instantiate a `cc_configure_make_library` macro which behaves similarly to a `cc_library`, which can then be used in a C++ rule (`cc_binary` in this case).

In `WORKSPACE`, put

```python
new_http_archive(
    name = "libevent",
    build_file_content = """filegroup(name = "all", srcs = glob(["**"]), visibility = ["//visibility:public"])""",
    strip_prefix = "libevent-2.1.8-stable",
    urls = ["https://github.com/libevent/libevent/releases/download/release-2.1.8-stable/libevent-2.1.8-stable.tar.gz"],
)
```

and in `BUILD`, put

```python
cc_configure_make(
    name = "libevent",
    src = "@libevent//:all",
    configure_flags = [
        "--enable-shared=no",
        "--disable-libevent-regress",
        "--disable-openssl",
    ],
    out_lib_path = "lib/libevent.a",
)

cc_binary(
    name = "libevent_echosrv1",
    srcs = ["libevent_echosrv1.c"],
    deps = [":libevent"],
)
```

then build as usual:

```bash
$ devbazel build //:libevent_echosrv1
```


text:
pyGett
======

About
-----
This library provides a binding to the REST API for the file sharing service [Ge.tt](http://ge.tt). Please see
the [Ge.tt Developer's Documentation](http://ge.tt/developers) for information on how to get an API key.

Installation
------------
To install, use the standard `python setup.py install` or `sudo pip install pygett`

Documentation
-------------
Read the full documentation on [ReadTheDocs](http://pygett.readthedocs.org/).

Quick Usage
-----------
The API initializaton requires the following parameters to be present:

- **apikey**: The API key assigned by Ge.tt for your application
- **email**: The email address linked to an API key
- **password**: The password linked to an API key

Example initialization:

    from pygett import Gett

    client = Gett(
            apikey = "apitest",
            email =<EMAIL_ADDRESS>            password = "secret"
    )

Getting a dict of all shares:

    shares = client.get_shares()
    for file in shares['4ddfds'].files
        print file.filename

Getting a list of all shares:

    shares = client.get_shares_list()
    for share in shares:
        for file in share.files:
            print share.sharename + "\t" + file.filename + "\t" + file.size

Getting a specific share:

    share = client.get_share("4ddfds")

Getting a specific file:

    file = client.get_file("4ddfds", 0)

Uploading a file:

    file = client.upload_file(
            filename = "test.rst",
            data = open("test.rst", "rb").read()
    )

        print "File '%s' is now available at %s" % (file.filename, file.getturl)

Downloading file content:

    file = client.get_file("4ddfds", 0)
    open("myCopy.txt", "wb").write(file.contents())

License
-------
Copyright (C) 2011 by Mark Allen.  You may use this library under the terms and conditions
of the [MIT license](http://www.opensource.org/licenses/mit-license.php).  See the LICENSE
file for full information.


text:
# Spinner

A spinner, also known as a _throbber_, is used to show that some content is loading.

It is a non-interactive, non-focusable, purely visual component that is ignored by screen readers. An accessible UI should set `aria-busy` on the component or section that is loading.

By default, the spinner is rendered as a block-level `<span>`. If you need an inline spinner, you must style the component. The colour of the spinner is determined by the CSS `color`, which can be set to style the spinner.

## Examples

```jsx
import styled from 'styled-components';
import {Spinner} from '@condict/ui';

// A default spinner.
<Spinner/>

// A styled spinner with a custom size.
const PurpleSpinner = styled(Spinner)`
  display: inline-block;
  margin: 32px;
  color: rebeccapurple;
`;
<PurpleSpinner size={48}/>
```

## Props

| Name | Type | Default | Description |
| --- | --- | --- | --- |
| `className` | string | `''` | One or more class names that are forwarded to the outer wrapper (a `<span>`). |
| `size` | number | `24` | The size of the spinner, in pixels. The thickness of the rotating line adjusts automatically. |

Other props are _not_ forwarded to any underlying element.

repository: arimah/condict

repo_name: arimah/condict


text:
# toromon

This a collection of various software examples originally published in blog
posts on [toromon.com](http://toromon.com/).

Main Repo on [BitBucket](https://bitbucket.org/jeffreyksmithjr/toromon)

Mirror Repo on [GitHub](https://github.com/jeffreyksmithjr/toromon)

repository: jeffreyksmithjr/toromon

repo_name: jeffreyksmithjr/toromon


text:
---
title: AyncAPI
---

EventSource's DSL applies the [AsyncAPi 2.0.0](https://www.asyncapi.com/docs/specifications/v2.0.0) specification for configuring the infrastucture environment and exchanging event messages. AsyncAPI settings include details that an application or service needs to:

1. Connect to a shared message broker/server
2. Produce messages for other services
3. Consume messages produced by other services

## AsyncApi Definition

Using AsyncAPI definitions, EventSource enables your application to join message broker- and Web server- hosted networks, registering as a message producer and/or consumer, performing message publish and subscribe operations. Components include:

- Servers
- Channels
- Operations
- Protocol-specific bindings at various levels

Following is an abbrevatiated example AsyncAPI YAML configuration file for accessing a service over HTTP protocol:

```yaml
servers:
  production:
    url: http://mitc:3001
    protocol: http
    protocolVersion: 0.1.0
    description: MitC Development Server

channels:
  /determinations/eval:
    publish:
      operationId: /determinations/eval
      description: HTTP endpoint for MitC eligibility determination requests
      bindings:
        http:
          type: request
          method: POST
          headers:
            Content-Type: application/json
            Accept: application/json
    subscribe:
      operationId: /on/determinations/eval
      description: EventSource Subscriber that publishes MitC eligibility determination responses
      bindings:
        http:
          type: response
          method: GET
          headers:
            Content-Type: application/json
            Accept: application/json
```

The `servers` section specifies Connection-level information, including the URL to the subject server and the protocol to use. Multiple server definitions may be defined, with the server key correlating with the associated Enivronment.

This example defines a server for the `production` environment. Typically the file will also include server references for `test` and `development` environments.

```yaml
servers:
  production:
    url: http://mitc:3001
    protocol: http
    protocolVersion: 0.1.0
    description: MitC Development Server
```

The `channels` section

## Organizing AsyncApi Definitions

An AsyncAPI definition can specify settings for a single messsage service using a single protocol. EventSource does support multiple AsyncAPI definitions for a single message resource. However, it's best to avoid splitting a single resource across multiple AsyncAPI definitions as it increases DevOps overhead and maintenance complexity.

For HTTP protocol, services with a host URL consistent across environment level (dev, test, production) and resource endpoints defined relative to that host may be represented in one AsyncAPI definition. In this case the server host specifies the EventSource Connection settings and each resource endpoint is represented by a Channel.

Similarly, a single AMQP message broker may define an EventSource Connection and each AMQP Channel is represented by an EventSource Channel.

That said, it's not uncommon for a service to load mulitple AsynCAPI definitions to support business functions. For example, a service may use AMQP to exchange messages within the enterprise boudaries and HTTP to access an external API service. A separate AsynAPI definition is necessary in this case because a single AyncAPI definition may describe only one protocol.

Another single service/multiple AsyncAPI definition scenario is when a service that accesses multple resources -- even though those services may use the same protocol. An AsyncAPI definition may specify settings for a single service only.

branch_name: refs/heads/trunk

gha_language: Ruby


text:
# MongoDB-C--Sample
This project is to get an abstract idea for coding in C++ for data insertion/deletion/read into MongoDB

## Build Command
g++ --std=c++11 <filename>.cpp -o build/<filename> $(pkg-config --cflags --libs libmongocxx) && ./build/<filename>

Note:
```
> echo $(pkg-config --cflags --libs libmongocxx)
> -I/usr/local/include/mongocxx/v_noabi -I/usr/local/include/libmongoc-1.0 -I/usr/local/include/bsoncxx/v_noabi -I/usr/local/include/libbson-1.0 -L/usr/local/lib -lmongocxx -lbsoncxx
```

## Dockerfile
The provided dockerfile is adapted from https://stackoverflow.com/questions/46283218/installing-mongo-c-and-c-drivers-in-docker thanks to Pav K.

## Reference Websites
http://mongocxx.org/mongocxx-v3/tutorial/


text:
---
description: REST API Roles Methods
---

# Roles

Please find the document here:

[https://developer.rocket.chat/api/rest-api/methods/roles](https://developer.rocket.chat/api/rest-api/methods/roles)

repository: Jeanstaquet/docs

gha_language: JavaScript

repo_name: Jeanstaquet/docs


text:
---
layout: post
title:  "Creating an APT repository on Github pages"
date:   2020-05-09 15:04:00 -0300
categories: tutorial linux debian github
---
You can host debian packages on Github and provide these files for the APT package manager to download from the terminal.

Initially do:
```bash
sudo apt-get install reprepro

mkdir -p myrepo/{conf,incoming}
cd myrepo

cat <<EOF >> conf/distributions
Origin: NameOfProvider
Label: LabelOfProvider
Suite: stable
Codename: focal
Architectures: i386 amd64
Components: main
Description: Debian x86-64 packages hosted on githubpages
SignWith: MY-KEY-TO-SIGN-THE-PACKAGES
EOF

cp ../../public.key .
```

To include new deb packages use:
```bash
reprepro includedeb focal ../my_deb_package.deb
```

To list all packages in your repository:
```bash
reprepro list focal
```

To Remove package:
```bash
reprepro remove focal PACKAGE
```

After upload the folder to github pages, you can add the repository:
```bash
wget -qO - 'https://winunix.github.io/debian/public.key' | sudo apt-key add -
sudo add-apt-repository 'deb https://winunix.github.io/debian focal main'

# Host locally with PHP
# deb http://<IP_ADDRESS>:8080/debian focal main
# http://<IP_ADDRESS>:8080/public.key
```

gha_language: CSS


text:
# Arduino_pushbutton_music_player

Performs basic fuctions like play/pause/stop/rewind etc to control music using arduino and push buttons

>Libraries used: Pyserial and Pygame(mixer)

>How its working:
  It takes input from push button and print data accordingly on serial monitor. After this, that data on serial monitor is read using serial library and actions are performed according to Python code.

>How to perform:
  Firstly, open the schematic image given and make the circuit according to it.
  Upload the .ino code on your arduino board.
  Run the python code on your system and control using push buttons.

CURRENT FUNCTIONS IT CAN PERFORM:
1) Start and Stop the music.
2) Pause and unpause the music.
3) Rewind the current song.

FEATURES TO BE ADDED IN FUTURE:
1) Adding playlist/queue support.
2) Controlling volume using potentiometer.
3) Adding LCD to display informations.