text:
# Ciinabox

## Intro

Ciinabox is set of tools that was created in order to leverage creation and
management of large numbers of CI/CD environments, allowing user to treat
set of CI tools and automation tasks as code. These tools are responsible for
following

- Provisioning of underlying infrastructure for CI Tools
- Provisioning of CI/CD tools themselves
- Provisioning of automation tasks in repeatable manner. Storing these tasks
  in a human readbale format, and treating them as a code

## Repositories

- [ciinabox-ecs](https://github.com/base2Services/ciinabox-ecs) is responsible for provisioning infrastructure and CI tools on AWS.
Any automation servers are provisioned as [Docker](https://www.docker.com) containers. In it's default setup
ciinabox-ecs provisions [Jenkins](https://jenkins.io) automation server containers automation server,
however it is possible to rpvoision any automation server/tool that can be run as
a Docker container

- [ciinabox-containers](https://github.com/base2Services/ciinabox-containers) is set of docker container definition for automation tools. Most of
tooling is focused around Jenkins ecosystem. Pull requests are welcome :)

- [ciinabox-jenkins](https://github.com/base2Services/ciinabox-jenkins) is command line utility for provisioning Jenkins tasks from human readbale
YAML files. These YAML files can than be stored as code in repository and versioned,
treating your automation tasks as a code.

- [ciinabox-pipelines](https://github.com/base2Services/ciinabox-pipelines) is [Jenkins pipelines library](https://jenkins.io/doc/book/pipeline/shared-libraries/) aiding in orchestration of existing Jenkins.
This library also contains methods that should enable it's users to build new pipeline jobs
utilising methods such as `dockerBuild` for building docker images, or `withECR`
for executing Groovy closure while logged into Amazon's Elastic Container Service in case your pipeline is running

## Getting started

### Create Ciinabox environment on AWS

Before commencing to steps below, be aware that you will incur charges on
your AWS account (1 NAT Gateway, 1 t2.large instance and 1 ELB). Also note
that instance type can be tweaked using configuration files. Once environment
has been torn down, it will leave EBS snapshots behind, as deletion policies
are set to `Snapshot` for data drives.

#### Requirements

- AWS Account
- Route53 hosted zone for your tools (`tools.aws.example.net` in example below)
- S3 Bucket for Cloud Formation templates (optional, can be automatically created)

#### Creating ciinabox

Ciinabox creation consists of following steps

1. Generation of configuration files
2. (Optional) creation and upload of server certificates
3. (Optional) creation of ciinabox key
4. (Optional) creation of s3 bucket with Cloud Formation templates

If you have previously deployed ciinabox to your AWS account, you won't need
steps 2 and 3, as step 4 can be done either manually or trough setup script.
Each of this steps can be executed in isolation, as separate rake task.
Fully guided install is available trough `ciinabox:full_install` rake task.
Type `rake -t` for more info.

- Clone the repo and install required gems

```
$ git clone https://github.com/base2Services/ciinabox-ecs.git

ciinabox-ecs $ bundle install
Using rake 12.0.0
Using cfndsl 0.12.4
Using bundler 1.13.3
Bundle complete! 2 Gemfile dependencies, 3 gems now installed.
Use  \`bundle show [gemname]\` to see where a bundled gem is installed.
```

- `ciinabox:full_install` rake task will guide you trough whole process of generating
  configuration files new toolset, and provisioning all resources in your
  AWSS account. Only 2 mandatory parameters are name of your ciinabox installation,
  determining local path for configuration files, and Route53 hosted zone for newly
  setup tools. Full install will wait for completion of stack creation before
  exiting

```
ciinabox-ecs $ bundle exec rake ciinabox:full_install
Enter the name of your ciinabox:
demo
Enter the AWS region to create your ciinabox [us-east-1]:

Using us-east-1 as AWS region
Enter the name of the S3 bucket to deploy ciinabox to [ciinabox-deployment-0bce48b2-8eda-405e-a26f-8653882d3956]:

Enter top level domain (e.g tools.example.com), must exist in Route53 in the same AWS account:
tools.aws.example.net
Enter AWS profile you wish to use for provisioning (empty for default):

Using AWS Account<PHONE_NUMBER>11
Enter the name of created Cloud Formation stack [ciinabox]:
ciinabox-demo
Using user-provided services.yml File
# Enable active ciinabox by executing or override ciinaboxes base directory:
export CIINABOXES_DIR="ciinaboxes"
export CIINABOX="demo"
# or run
# eval "$(rake ciinabox:active[demo])"
Create source bucket (y/n)? [y]
y
make_bucket: s3://ciinabox-deployment-0bce48b2-8eda-405e-a26f-8653882d3956/
Successfully created S3 source deployment bucket ciinabox-deployment-0bce48b2-8eda-405e-a26f-8653882d3956
Create and upload server certificate (y/n)? [y]
n
Create and upload ciinabox key (y/n)? [y]
n
......
..... # Output of template generation
......
Successfully uploaded rendered templates to S3 bucket ciinabox-deployment-0bce48b2-8eda-405e-a26f-8653882d3956
{
    "StackId": "arn:aws:cloudformation:us-east-1:111111111111:stack/ciinabox-demo/xxxxxxx"
}
Starting creation of ciinabox environment
Waiting for Cloud Formation stack creation completion ...
```

### Making changes to ciinabox environment

### Publishing jobs to Jenkins

Jenkins jobs can be provisioned by using [ciinabox-jenkins](https://github.com/base2Services/ciinabox-jenkins)
CLI utility.
Please see repo's [README](https://github.com/base2Services/ciinabox-jenkins/blob/master/README.md) for reference on job dsl, and yaml file format.
Once you check out the repo, there will be some example jobs within `ciinaboxes.example/example/jenkins/dsl-reference-jobs.yml` file.
To provision these sample jobs to your newly created ciinabox environment, use command below.
Example assumes that default username/password hasn't been changed.

```
ciinabox-jenkins $ ./gradlew jenkins -Dusername=ciinabox -Dpassword=ciinabox -Durl=http://jenkins.aws.example.net -Dciinaboxes=ciinaboxes.example -Dciinabox=example

```

Info output on all jobs created should be written to console

```
....
processing job: MyJobWithParameters
Processing provided DSL script
dsl-doc - updated
dsl-doc/MyJobWithParameters - created

processing job: MyJobWithDescription
Processing provided DSL script
dsl-doc - updated
dsl-doc/MyJobWithDescription - created

BUILD SUCCESSFUL

Total time: 20.255 secs

```


text:
# vericredClient.ACAPlanPre2018

## Properties
Name | Type | Description | Notes
------------ | ------------- | ------------- | -------------
**carrierName** | **String** | Name of the insurance carrier | [optional]
**displayName** | **String** | Alternate name for the Plan | [optional]
**effectiveDate** | **String** | Effective date of coverage. | [optional]
**expirationDate** | **String** | Expiration date of coverage. | [optional]
**identifiers** | [**[PlanIdentifier]**](PlanIdentifier.md) | List of identifiers of this Plan | [optional]
**name** | **String** | Marketing name of the plan | [optional]
**networkIds** | **[Number]** | List of Vericred-generated network_ids | [optional]
**networkSize** | **Number** | Total number of Providers in network | [optional]
**planType** | **String** | Category of the plan (e.g. EPO, HMO, PPO, POS, Indemnity, PACE, Medicare-Medicaid, HMO w/POS, Cost, FFS, MSA) | [optional]
**serviceAreaId** | **String** | Foreign key for service area | [optional]
**source** | **String** | Source of the plan benefit data | [optional]
**type** | **String** | The type of the Plan | [optional]
**adultDental** | **Boolean** | Does the plan provide dental coverage for adults? | [optional]
**age29Rider** | **Boolean** | True if the plan allows dependents up to age 29 | [optional]
**ambulance** | **String** | Benefits string for ambulance coverage | [optional]
**benefitsSummaryUrl** | **String** | Link to the summary of benefits and coverage (SBC) document. | [optional]
**buyLink** | **String** | Link to a location to purchase the plan. | [optional]
**childDental** | **Boolean** | Does the plan provide dental coverage for children? | [optional]
**childEyewear** | **String** | Child eyewear benefits summary | [optional]
**childEyeExam** | **String** | Child eye exam benefits summary | [optional]
**customerServicePhoneNumber** | **String** | Phone number to contact the insurance carrier | [optional]
**durableMedicalEquipment** | **String** | Benefits summary for durable medical equipment | [optional]
**diagnosticTest** | **String** | Diagnostic tests benefit summary | [optional]
**dpRider** | **Boolean** | True if plan does not cover domestic partners | [optional]
**drugFormularyUrl** | **String** | Link to the summary of drug benefits for the plan | [optional]
**emergencyRoom** | **String** | Description of costs when visiting the ER | [optional]
**familyDrugDeductible** | **String** | Deductible for drugs when a family is on the plan. | [optional]
**familyDrugMoop** | **String** | Maximum out-of-pocket for drugs when a family is on the plan | [optional]
**familyMedicalDeductible** | **String** | Deductible when a family is on the plan | [optional]
**familyMedicalMoop** | **String** | Maximum out-of-pocket when a family is on the plan | [optional]
**fpRider** | **Boolean** | True if plan does not cover family planning | [optional]
**genericDrugs** | **String** | Cost for generic drugs | [optional]
**habilitationServices** | **String** | Habilitation services benefits summary | [optional]
**hiosIssuerId** | **String** |  | [optional]
**homeHealthCare** | **String** | Home health care benefits summary | [optional]
**hospiceService** | **String** | Hospice service benefits summary | [optional]
**hsaEligible** | **Boolean** | Is the plan HSA eligible? | [optional]
**id** | **String** | Government-issued HIOS plan ID | [optional]
**imaging** | **String** | Benefits summary for imaging coverage | [optional]
**individualDrugDeductible** | **String** | Deductible for drugs when an individual is on the plan | [optional]
**individualDrugMoop** | **String** | Maximum out-of-pocket for drugs when an individual is on the plan | [optional]
**individualMedicalDeductible** | **String** | Deductible when an individual is on the plan | [optional]
**individualMedicalMoop** | **String** | Maximum out-of-pocket when an individual is on the plan | [optional]
**inpatientBirth** | **String** | Inpatient birth benefits summary | [optional]
**inpatientFacility** | **String** | Cost under the plan for an inpatient facility | [optional]
**inpatientMentalHealth** | **String** | Inpatient mental helath benefits summary | [optional]
**inpatientPhysician** | **String** | Cost under the plan for an inpatient physician | [optional]
**inpatientSubstance** | **String** | Inpatient substance abuse benefits summary | [optional]
**inNetworkIds** | **[Number]** | List of NPI numbers for Providers passed in who accept this Plan | [optional]
**level** | **String** | Plan metal grouping (e.g. platinum, gold, silver, etc) | [optional]
**logoUrl** | **String** | Link to a copy of the insurance carrier's logo | [optional]
**nonPreferredBrandDrugs** | **String** | Cost under the plan for non-preferred brand drugs | [optional]
**onMarket** | **Boolean** | Is the plan on-market? | [optional]
**offMarket** | **Boolean** | Is the plan off-market? | [optional]
**outOfNetworkCoverage** | **Boolean** | Does this plan provide any out of network coverage? | [optional]
**outOfNetworkIds** | **[Number]** | List of NPI numbers for Providers passed in who do not accept this Plan | [optional]
**outpatientFacility** | **String** | Benefits summary for outpatient facility coverage | [optional]
**outpatientMentalHealth** | **String** | Benefits summary for outpatient mental health coverage | [optional]
**outpatientPhysician** | **String** | Benefits summary for outpatient physician coverage | [optional]
**outpatientSubstance** | **String** | Outpatient substance abuse benefits summary | [optional]
**planMarket** | **String** | Market in which the plan is offered (on_marketplace, shop, etc) | [optional]
**preferredBrandDrugs** | **String** | Cost under the plan for perferred brand drugs | [optional]
**prenatalPostnatalCare** | **String** | Inpatient substance abuse benefits summary | [optional]
**preventativeCare** | **String** | Benefits summary for preventative care | [optional]
**premiumSubsidized** | **Number** | Cumulative premium amount after subsidy | [optional]
**premium** | **Number** | Cumulative premium amount | [optional]
**premiumSource** | **String** | Source of the base pricing data | [optional]
**primaryCarePhysician** | **String** | Cost under the plan to visit a Primary Care Physician | [optional]
**rehabilitationServices** | **String** | Benefits summary for rehabilitation services | [optional]
**skilledNursing** | **String** | Benefits summary for skilled nursing services | [optional]
**specialist** | **String** | Cost under the plan to visit a specialist | [optional]
**specialtyDrugs** | **String** | Cost under the plan for specialty drugs | [optional]
**urgentCare** | **String** | Benefits summary for urgent care | [optional]
**actuarialValue** | **Number** | Percentage of total average costs for covered benefits that a plan will cover. | [optional]
**chiropracticServices** | **String** | Chiropractic services benefits summary | [optional]
**coinsurance** | **Number** | Standard cost share for most benefits | [optional]
**embeddedDeductible** | **String** | Is the individual deductible for each covered person, embedded in the family deductible | [optional]
**gated** | **Boolean** | Does the plan's network require a physician referral? | [optional]
**imagingCenter** | **String** | Imaging center benefits summary | [optional]
**imagingPhysician** | **String** | Imaging physician benefits summary | [optional]
**labTest** | **String** | Lab test benefits summary | [optional]
**mailOrderRx** | **Number** | Multiple of the standard Rx cost share for orders filled via mail order | [optional]
**nonpreferredGenericDrugShare** | **String** | Non-preferred generic drugs benefits summary | [optional]
**nonpreferredSpecialtyDrugShare** | **String** | Non-preferred specialty drugs benefits summary | [optional]
**outpatientAmbulatoryCareCenter** | **String** | Outpatient ambulatory care center benefits summary | [optional]
**planCalendar** | **String** | Are deductibles and MOOPs reset on Dec-31 (\"calendar year\"), 365 days after enrollment date (\"plan year\"), or are both options available (\"both\")? | [optional]
**prenatalCare** | **String** | Prenatal care benefits summary | [optional]
**postnatalCare** | **String** | Post-natal care benefits summary | [optional]
**skilledNursingFacility365** | **String** | Does the plan cover full-time, year-round, nursing facilities? | [optional]

repository: vericred/vericred-javascript

branch_name: refs/heads/master

extension: md

gha_language: JavaScript

license_type: permissive

repo_name: vericred/vericred-javascript


text:
# Changes

## Version 6 (in progress)

* 2013-07-16 - move file encoding in surefire onto the argline.
* 2013-07-15 - re-enable junit:junit with versions >= 4.11 (they fixed the deps)
* 2013-07-02 - remove mavanagaiata plugin, not really usable in its current state.
* 2013-07-12 - Require maven 3.0.5 to build
* 2013-07-12 - Upgrade compiler plugin to 3.1 (from 3.0)
* 2013-07-12 - Upgrade dependency plugin to 2.8 (from 2.7)
* 2013-07-12 - Upgrade enforcer plugin to 1.3 (from 1.2)
* 2013-07-12 - Upgrade javadoc plugin to 2.9.1 (from 2.9)
* 2013-07-12 - Upgrade project-info-reports plugin to 2.7 (from 2.6)
* 2013-07-12 - Upgrade release plugin to 2.4.1 (from 2.3.2)
* 2013-07-12 - Upgrade site plugin to 3.3 (from 3.2)
* 2013-07-12 - Upgrade surefire plugin to 2.15 (from 2.14)
* 2013-07-12 - Upgrade build-helper plugin to 1.8 (from 1.7)
* 2013-07-12 - Upgrade jacoco plugin to 0.6.3 (from 0.6.2)

## Version 5

* 2013-03-13 - Upgrade surefire plugin to 2.14 (from 2.13)
* 2013-03-13 - Upgrade pmd plugin to 3.0.1 (from 2.7.1)
* 2013-03-13 - Upgrade jacoco plugin to 0.6.2 (from 0.6.1)
* 2013-03-13 - Upgrade dependency plugin to 2.7 (from 2.6)
* 2013-03-13 - Downgrade release plugin to 2.3.2 from 2.4 to fix git local checkout regression
* 2013-03-13 - Upgrade mavanagaiata plugin to 0.5.0 (from 0.4.1)
* 2013-03-13 - Upgrade maven-duplicate-finder-plugin to 1.0.4 (from 1.0.3)
* 2013-03-13 - Update guava dependency version to 14.0.1 (from 13.0.1)
* 2013-03-13 - Update objenesis version to 1.3 (from 1.2)
* 2013-03-13 - add build helper plugin 1.7
* 2013-03-13 - reactivate mavanagaiata plugin
* 2013-03-13 - ban guava versions before 10.0.1 (old r0<x> versions)
* 2013-03-13 - ban org.eclipse.jetty.orbit:javax.servlet (use javax.servlet:javax.servlet-api)
* 2013-03-13 - ignore duplicate classes in org.jruby:jruby-complete
* 2013-03-13 - make fork mode for surefire configurable using fb.test.fork-mode. Default is 'once' (was 'always').
* 2013-03-13 - skip mavanagaiata plugin when no git repository is present
* 2013-03-13 - skip existing license headers when running license:format
* 2013-03-13 - [BUG] fb.check.skip-jacoco did not do anything
* 2013-01-11 - make automatic push of release related files and tags configurable. Default is 'false' (was 'true').
* 2013-01-11 - Updated documentation.

----

## Version 4

* 2013-01-11 - Released
* 2013-01-11 - release plugin should only execute artifact deploy even if a site is present.

## Version 3

* 2013-01-11 - Released


text:
# graphqurl
## DISARTICULATE -- forked, reverted to v0.3.3 & Frozen
## Thanks for the fish!

### Check out https://github.com/hasura/graphqurl if you want whatever's newer than this

Made by the team at [hasura.io](https://hasura.io), `graphqurl` is a curl like CLI for GraphQL:
- CLI for making GraphQL queries with autocomplete
- Run GraphiQL locally against any endpoint
- Use as a library with Node.js or from the browser
- Supports subscriptions
- Export GraphQL schema

[![oclif](https://img.shields.io/badge/cli-oclif-brightgreen.svg)](https://oclif.io)
[![CircleCI](https://circleci.com/gh/hasura/graphqurl/tree/master.svg?style=shield)](https://circleci.com/gh/hasura/graphqurl/tree/master)
[![Appveyor CI](https://ci.appveyor.com/api/projects/status/github/hasura/graphqurl?branch=master&svg=true)](https://ci.appveyor.com/project/hasura-bot/graphqurl/branch/master)
[![Downloads/week](https://img.shields.io/npm/dw/graphqurl.svg)](https://npmjs.org/package/graphqurl)
[![License](https://img.shields.io/npm/l/graphqurl.svg)](https://github.com/hasura/graphqurl/blob/master/LICENSE)

----------------
![Graphqurl Demo](assets/subscription.gif)
---
![GraphiQL Demo](assets/graphiql.gif)
---
![Subscriptions triggering bash](assets/bash_trigger.gif)
----------------

## Installation

### CLI

```bash
npm install -g graphqurl
```

### Node Library

```bash
npm install --save graphqurl
```

## Usage

### CLI

#### Query

```bash
gq https://my-graphql-endpoint/graphql \
     -H 'Authorization: token <token>' \
     -q 'query { table { column } }'
```

#### Auto-complete

GraphQURL can auto-complete queries using schema introspection. Execute the
command without providing a query string:

```bash
$ gq <endpoint> [-H <header:value>]
Enter the query, use TAB to auto-complete, Ctrl+Q to execute, Ctrl+C to cancel
gql>
```

You can use `TAB` to trigger auto-complete. `Ctrl+C` to cancel the input and
`Ctrl+Q`/`Enter` to execute the query.

#### GraphiQL

Open GraphiQL with a given endpoint:

```bash
gq <endpoint> -i
```

> This is a custom GraphiQL where you can specify request's headers.

#### Mutation

Mutations with variables can be executed by providing the variables with `-v`
flag.

```bash
gq <endpoint> \
   -v 'name=hasura' \
   -q 'mutation ($name: String) { table (objects: [{ name: $name }]) }'
```

#### Subscription

Subscriptions can be executed and the response is streamed on to stdout.

```bash
gq <endpoint> \
   -q 'subscription { table { column } }'
```

#### Export schema

Export GraphQL schema to GraphQL or JSON format:

```bash
gq <endpoint> --introspect > schema.graphql

# json
gq <endpoint> --introspect --format json > schema.json
```

### Command

```bash
$ gq ENDPOINT [-q QUERY]
```

#### Args

* `ENDPOINT`: graphql endpoint (can be also set as `GRAPHQURL_ENDPOINT` env var)

#### Options

- `-q, --query=query`: graphql query to execute
- `-H, --header="key:value"`: request header
- `-v, --variable="key=value"`: variables used in the query
- `-n, --name=name`: name of the graphql definition to execute, use only if there are multiple definitions
- `--queryFile=/path/to/queryfile`: file to read the query from
- `--variablesFile=/path/to/variablefile`: file to read the query variables from
- `-i, --graphiql`: open graphiql with the given endpoint, headers, query and variables
- `-p, --graphiqlPort=graphiqlPort`: [default: 4500] port to use for graphiql
- `-a, --graphiqlAddress=graphiqlAddress`: [default: localhost] address to use for graphiql
- `-l, --singleLine`: show output in a single line, do not prettify
- `--version`: show CLI version
- `-h, --help`: show CLI help

### Node Library

#### Using callbacks:

```js
const { query } = require('graphqurl');

function successCallback(response, queryType, parsedQuery) {
  if (queryType === 'subscription') {
    // handle subscription response
  } else {
    // handle query/mutation response
  }
}

function errorCallback(error, queryType, parsedQuery) {
  console.error(error);
}

query(
  {
    query: 'query { table { column } }',
    endpoint: 'https://my-graphql-endpoint/graphql',
    headers: {
      'x-access-key': 'mysecretxxx',
    }
  },
  successCallback,
  errorCallback
);

```

#### Using Promises:

For queries and mutations,

```js
const { query } = require('graphqurl');

query(
  {
    query: 'query { table { column } }',
    endpoint: 'https://my-graphql-endpoint/graphql',
    headers: {
      'x-access-key': 'mysecretxxx',
    }
  }
).then((response) => console.log(response))
 .catch((error) => console.error(error));
```

For subscriptions,

```js
const { query } = require('graphqurl');

query(
  {
    query: 'subscription { table { column } }',
    endpoint: 'https://my-graphql-endpoint/graphql',
    headers: {
      'x-access-key': 'mysecretxxx',
    }
  }
).then((observable) => {
  observable.subscribe(
    (event) => {
      console.log('Event received: ', event);
      // handle event
    },
    (error) => {
      console.log('Error: ', error);
      // handle error
    }
  )
})
 .catch((error) => console.error(error));
```

> Subscriptions are not supported in browsers yet.

### API

#### query(options, successCallback, errorCallback)

- **options**: [Object, *required*] GraphQL query options with the following properties:
  - endpoint: [String, *required*] GraphQL endpoint
  - query: [String, *required*] GraphQL query string
  - headers: [Object] Request headers, defaults to `{}`
  - variables: [Object] GraphQL query variables, defaults to '{}'
  - name: [String] Operation name. Used only if the `query` string contains multiple operations.
- **successCallback**: [Function] Success callback which is called after a successful response. It is called with the following parameters:
  - response: The response of your query
  - queryType: The type of query you made i.e. one [`query`, `mutation`, `subscription`]
  - parsedQuery: The query parsed into a GraphQL document
- **errorCallback**: [Function] Error callback which is called after the occurrence of an error. It is called with the following parameters:
  - error: The occurred error
  - queryType: [String] The type of query you made i.e. one [`query`, `mutation`, `subscription`]
  - parsedQuery: [Object] The query parsed into a GraphQL document
- **Returns**: [Promise (response) ]If `successCallback` and `errorCallback` are not provided, this function returns the response wrapped in a promise.
  - response: response is a GraphQL compliant JSON object in case of `queries` and `mutations`. However, if you make a subscription, it returns an observable that you can later subscribe to. Check [this example](#subscriptions) to see how to subscribe to observables.

## More Examples

### Node Library

#### Queries

Query example with variables

```js
const { query } = require('graphqurl');

query(
  {
    query: `
      query ($name: String) {
        table(where: { column: $name }) {
          id
          column
        }
      }
    `,
    endpoint: 'https://my-graphql-endpoint/graphql',
    headers: {
      'x-access-key': 'mysecretxxx',
    },
    variables: {
      name: 'Alice'
    }
  }
).then((response) => console.log(response))
 .catch((error) => console.error(error));
```

#### Mutations

```js
const { query } = require('graphqurl');

query(
  {
    query: `
      mutation ($id_insert_input: String!, $column_insert_input: String!) {
        insert_to_table (
          id: $id_insert_input,
          column: $column_insert_input
        ) {
          affected_rows
        }
      }
    `,
    endpoint: 'https://my-graphql-endpoint/graphql',
    headers: {
      'x-access-key': 'mysecretxxx',
    },
    variables: {
      id_insert_input: 'id_ak23sdfkjk2',
      column_insert_input: 'Bob'
    }
  }
).then((response) => console.log(response))
 .catch((error) => console.error(error));
```

#### Subscriptions

Using promises,

```js
const { query } = require('graphqurl');

const eventCallback = (event) => {
  console.log('Event received:', event);
  // handle event
};

const errorCallback = (error) => {
  console.log('Error:', error)
};

query(
  {
    query: 'subscription { table { column } }',
    endpoint: 'https://my-graphql-endpoint/graphql',
    headers: {
      'Authorization': 'Bearer Andkw23kj=Kjsdk2902ksdjfkd'
    }
  },
).then((observable) => {
  observable.subscribe(
    (event) => {
      console.log('Event received', event);
      // handle event
    },
    (error) => {
      console.log('Error', error);
      // handle error
    }
  )
}).catch(errorCallback);
```

Lets do the above subscription using callbacks,

```js
const { query } = require('graphqurl');

function eventCallback(event) {
  console.log('Event received:', event);
  // handle event
}

function errorCallback(error) {
  console.log('Error:', error)
}

query(
  {
    query: 'subscription { table { column } }',
    endpoint: 'https://my-graphql-endpoint/graphql',
    headers: {
      'Authorization': 'Bearer Andkw23kj=Kjsdk2902ksdjfkd'
    }
  },
  eventCallback,
  errorCallback
);
```

### CLI

Generic example:

```bash
gq \
     https://my-graphql-endpoint/graphql \
     -H 'Authorization: token <token>' \
     -H 'X-Another-Header: another-header-value' \
     -v 'variable1=value1' \
     -v 'variable2=value2' \
     -q 'query { table { column } }'
```

Reading the query and variables from a file:

```bash
gq \
     https://my-graphql-endpoint/graphql \
     -H 'Authorization: token <token>' \
     -H 'X-Another-Header: another-header-value' \
     --variableFile='./queryVariables.json' \
     --queryFile='./query.gql
```

Executing only a particular named query from a file that contains many queries:

```bash
gq <endpoint> --queryFile ./queries.gql --name getItems
```

---
Maintained with :heart: by Hasura

repository: disarticulate/graphqurl

branch_name: refs/heads/main

repo_name: disarticulate/graphqurl


text:
# Tests for API

## Integration tests

Integration tests use Python3 along with `unittest` library. To run tests do the following:

1. Run the server

```bash
$ bundle exec rackup
```

2. Run all the tests from console

```bash
python3 -m unittest discover -s tests/integration/
```

license: MIT

repository: jambinoid/parser-manager

gha_language: Python

gha_license_id: MIT

repo_name: jambinoid/parser-manager


text:
# atom-publish-command-snippets
Quick command snippets for publishing Atom Package.

#### Steps to create and publish atom package/ theme

  * command-shift-P > Package > Package Generator: Generate Syntax Theme > mypackage

  * cd ~/.atom/packages/mypackage

  * apm login

  * apm develop mypackage

  * cd ~/github/mypackage

  * sudo chown -R username:wheel .

  *  git commit -a -m 'checking everything in'

  *  apm publish --tag v2.5.0 minor

  * apm publish minor

  * apm publish major


text:
# timeseries-notebooks

There are many time series packages list [here](https://www.microprediction.com/blog/popular-timeseries-packages)

Surprisingly few contain the most basic "hello world" univariate example: predicting the (k+1)'th number in a sequence.


text:
# Build-a-Library

Congratulations, you’ve become head librarian at your local Books-‘N-Stuff, which is in dire need of your help. They’re still using index cards to organize their content! Yikes.

Let’s get to work modernizing.

## Installation

Install the project locally
```bash
```

## Usage
Go to

## Contributing
Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.

Please make sure to update tests as appropriate.

## License
[MIT](https://choosealicense.com/licenses/mit/)

repository: SenayYakut/Build-a-Library

repo_name: SenayYakut/Build-a-Library


text:
---
layout: frontpage
teaser: PyCon Namibia 2016 will take place from the 25th-29th January, at the University of Namibia,
    		Windhoek for five days of talks, workshops and collaboration. The event is supported by the Phoenix Project, an initiative of Cardiff University and the University of Namibia, and is the fruit of a collaboration
    		between the two Universities and the international Python community.
widget1:
  title: "About Pycon Namibia"
  url: '/about'
  image: /namibian-pythonistas.jpg
  text: 'PyCon Namibia will bring together 180 professional software developers, scientists, academics and students, from Namibia and around the world.'
widget2:
  title: "Travel"
  url: '/travel'
  text: 'Namibia is fairly easy to reach from most places. It’s visitor-friendly, and international attendees should consider allocating some extra time to explore.'
  image: /arrival.jpg
widget3:
  title: "Get involved"
  url: /take-part
  image: get-involved.jpg
  text: "PyCon Namibia invites you to take part - as a volunteer, a speaker, a sponsor or just as an attendee. Join us in Windhoek for the world's newest PyCon."

permalink: /index.html
---

Now is the time to...

     Buy your ticket for PyCon Namibia 2016.

     Submit a proposal to speak at the event.

     Support PyCon Namibia as a commercial sponsor.

     Apply for a grant to travel to Namibia.


text:
DotNetVault
===========

Synchronization Library and Static Analysis Tool for C\# 8

DotNetVault takes its inspiration from the synchronization mechanisms provided
by Rust language and the Facebook Folly C++ synchronization library. These
synchronization mechanisms observe that the mutex should own the data they
protect. You literally cannot access the protected data without first obtaining
the lock. RAII destroys the lock when it goes out of scope – even if an
exception is thrown or early return taken.

**Advantages:**

 **Deadlock avoidance**: by default, all locks are timed. If the resource has
already been obtained or you have accidentally changed the acquisition order of
various locks somewhere in the code, you get a *TimeoutException*, allowing you
to identify your mistake. In addition to being able to base termination of an
acquisition attempt on timeout, you can also use a cancellation token to
propagate the cancellation request.

 **RAII (Scope-based) Lock Acquisition and Release:** Locks are stack-only
objects (ref structs) and the integrated Roslyn analyzer forces you to declare
the lock inline in a using statement or declaration, or it will cause a
compilation error. There is no danger of accidentally holding the lock open
longer than its scope even in the presence of an exception or early return.

**Incredible Flexibility to Change Underlying Synchronization Mechanism:**
Vaults are provided that use varied underyling mechanisms (Monitor Locks,
Atomic Exchanges, and ReaderWriterLockSlim).These vaults provide a common
compile time API for their common functionality.  Thus, you can easily change
from a synchronization mechanism using Monitor.Enter (which is used by C#'s
lock statement) to a mechanism based on lock free atomics or even
ReaderWriterLock.  This flexibility will allow you to profile code and
make changes without needing to extensively refactor your code.

**Isolation of Protected Resources**: The need for programmer discipline is
reduced:
		1. programmers do not need to remember which mutexes protect which resources,
		2. programmers cannot access the protected resource before they obtain the
		lock and cannot access any mutable state from the protected resource after
		releasing the lock, and
		3. static analysis rules enforced by compilation errors emitted from the
		integrated Roslyn analyzer prevent references to mutable state from outside the
		protected resource from becoming part of the protected resource and prevent the
		leaking of references to mutable state inside the protected resource to the
		outside.

The ubiquity of shared mutable state in Garbage Collected languages like C\# can
work at cross purposes to thread-safety. One approach to thread-safety in such
languages is to elimate the use of mutable state. Because this is not always
possible or even desireable, the synchronization mechanisms employed in C\#
typically rely on programmer knowledge and discipline. DotNetVault uses
Disposable Ref Structs together with custom language rules enforced by an
integrated Roslyn analyzer to prevent unsynchronized sharing of protected
resources. Locks cannot be held longer than their scope and, by default, will
timeout. This enables deadlock-avoidance.

Try DotNetVault. There is a learning curve because it is restrictive about
sharing protected resources. There are plenty of documents and example projects
provided with the source code of this project that can ease you into that
learning curve and demonstrate DotNetVault's suitability for use in highly
complex concurrent code. Armed with the resources that DotNetVault provides, you
will be able to approach concurrent programming, including use of shared mutable
state, with a high degree of confidence.

See **DotNetVault Description.pdf** for full description of this project.

RELEASE NOTES VERSION <IP_ADDRESS>-beta
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 This is a beta release.  Current stable release is <IP_ADDRESS>.

 This release adds a ReadWriteStringBuffer vault that provides thread-safe readonly, upgradable readonly and writable access to a StringBuilder object.  It also (when binaries or source retrieved from GitHub) includes the "Clorton Game" which demonstrates usage of the readwrite vault and provides a stress test to validate its functionality.

 "DotNetVault.Description.pdf" updated to reflect changes.
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

RELEASE NOTES VERSION <IP_ADDRESS>-alpha

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
This release contains MAJOR feature updates but is still considered unstable alpha.

Major new feature: vaults with varying underlying synchronization mechanisms.  You may now chose lock=free atomics (only mechanism before), the .NET standard Monitor.Enter (used by C# lock statement) or ReaderWriterLockSlim.  Because these vaults have a compatible (at compile-time) API, you can easily switch between synchronization mechanisms without any extensive refactoring required.  Also, the new vault based on ReaderWriterLock slim allows for shared readonly locks, upgradable readonly locks and exclusive read-write locks.  If you are coming from an old version of this project, you may need to refactor in some places as their are a significant number of small breaking changes.  It should, however, be a quick and painless process.

Fixed Bug 76.  Illegal references to non-vault-safe types inside mutable vault's locked resource objects delegates where not being detected in the case of local functions or using anonymous function syntax.

More unit tests.  There are now two unit test projects included.  The older one (DotNetVault.Test) tests the functionality of the built-in static analyzer.  The newer unit test project (VaultUnitTests) tests the functionality and synchronization mechanisms provided for the vaults.  It may also serve, in addition to the pre-existing sample code projects, as an introduction to this library.

Documentation (including "DotNetVault Description.pdf") updated to reflect changes.
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

RELEASE NOTES VERSION <IP_ADDRESS>-alpha

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
This is an unstable alpha release.  The current stable release is <IP_ADDRESS>.

The "Value" property of the BasicVault's locked resource object is now returned by reference.  This enables more efficient use of large mutable structs as protected resource objects.  An additional analysis rule was added to prevent ref local aliasing of the property, to prevent possible unsynchronized access.  Documentation updated to reflect.
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

gha_license_id: NOASSERTION


text:
# Versioning approach for component releases

## Decision
When we release Backpack packages, we use [semver](https://semver.org/) to ensure that changes made don't cause unexpected issues. The following reasoning should be followed.

### Major
A change is `major` if:
- Changes are not backwards compatible.
- Breaking changes to components such as updating the API or visual changes.
- Changes to tokens such as changes to colours or changes to values such as padding/margins.
- Removal of tokens, components or API.
- Adding new functionality to a component.

### Minor
A change is `minor` if:
- Changes where the updates are only in the Backpack component itself and not used publicly.
- Added new functionality to a component that didn't exist before and are not mandatory meaning there would be no impact on release.
- Adding a new icon that is not in used yet.
- Adding a new component to the Backpack library.
- Deprecation to tokens, components or API.

### Patch
A change is `patch` if:
- Only a dependency that a component uses needs an upgrade to improve functionality in the component.
- Bug fixes.
- Quality fixes such as `eslint` or `prettier`.

## Thinking
[You can find out more about the benefits of `semver` on `semver.org`](https://semver.org/#why-use-semantic-versioning)

repository: Skyscanner/backpack

repo_name: Skyscanner/backpack


text:
# How to use markdown syntaxe
[reference](https://daringfireball.net/projects/markdown/syntax)

### Online rendering markdown to html
* http://dillinger.io/
* https://stackedit.io/

#### <i class="icon-file"></i> Create a document

### text bold, italic and links

It's very easy to make some words **bold** and other words *italic* with
Markdown. You can even [link to Google!](http://google.com)

# This is an <h1> tag
### This is an <h2> tag
###### This is an <h6> tag

*This text will be italic*
_This will also be italic_

**This text will be bold**
__This will also be bold__

_You **can** combine them_

# Lists

* Item 1
* Item 2
* Item 2a
* Item 2b

# Images

![GitHub Logo](/images/logo.png)
Format: ![Alt Text](url)

Links

http://github.com - automatic!
[GitHub](http://github.com)

Blockquotes

As Kanye West said:

> We're living the future so
> the present is our past.

Inline code

I think you should use an
`<addr>` element here instead.

# Syntax highlighting

Here’s an example of how you can use syntax highlighting with GitHub Flavored Markdown:

```javascript
function fancyAlert(arg) {
    if(arg) {
        $.facebox({div:'#foo'})
    }
}
```

You can also simply indent your code by four spaces:

    function fancyAlert(arg) {
        if(arg) {
            $.facebox({div:'#foo'})
        }
    }

repository: londoed/dotfiles

repo_name: londoed/dotfiles


text:
# Discriminant Analysis

**Linear Discriminant Analysis** (LDA) and **Quadratic Discriminant Analysis** (QDA) arise as simple probabilistic classifiers. Discriminant Analysis works under the assumption that each class follows a Gaussian distribution. That is, for each class $k$, the probability distribution can be modelled by the function $f$:

$$
f_k(x) = \frac{\exp\left(\frac{-1}{2}(\mathbf{x}-\mathbf{\mu_k})^{\intercal}\Sigma_k^{-1}(\mathbf{x}-\mathbf{\mu_k})\right)}{(2\pi)^{p/2}\left|\Sigma_k\right|^{1/2}}
$$

where $\mu_k \in \mathbb{R}^p$ is the centroid for class $k$, $\Sigma_k \in \mathbb{R}^{p \times p}$ is the covariance matrix for class $k$ and $\mathbf{x} \in \mathbb{R}^p$ is a data vector. Let $\pi_k$ represent the prior class membership probabilities. Application of Baye's Theorem allows us to assign a probability to each class membership given an observation
$\mathbf{x}$:

$$
P(K = k | X = \mathbf{x}) = \frac{f_k(\mathbf{x})\pi_k}{\sum_i f_i(\mathbf{x})\pi_i}
$$

We can take the $\argmax$ over $k$ over the above function as our classification rule to develop a simple classification rule. Noting that the probabilities are non-zero and the natural logarithm is monotonically increasing, the rule can be simplified to:

$$
\argmax_k \left[\ln\left(f_k(\mathbf{x})\right) + \ln(\pi_k) \right]
= \argmax_k \delta_k(\mathbf{x})
$$

The set of functions $\delta_k$ are known as **discriminant functions**. For QDA, the discriminant functions are quadratic in $\mathbf{x}$:

$$
\delta_k(\mathbf{x}) = -\frac{1}{2}\left[
    (\mathbf{x}-\mathbf{\mu_k})^{\intercal}\Sigma_k^{-1}(\mathbf{x}-\mathbf{\mu_k})
    + \ln\left|\Sigma_k\right|
\right] + \ln(\pi_k)
$$

LDA has the additional simplifying assumption that $\Sigma_k = \Sigma \; \forall \; k$. That is, the classes share a common within-class covariance matrix. Since the $\mathbf{x}^\intercal \Sigma \mathbf{x}$ and $\ln|\Sigma|$ terms are constant across classes, they can be eliminated since they have no impact on the classification rule. The discriminant functions then simplify to a linear rule:

$$
\delta_k(x) =
    - \mathbf{\mu_k}^{\intercal}\Sigma^{-1}\mathbf{x}
    + \frac{1}{2}\mathbf{\mu_k}\Sigma^{-1}\mathbf{\mu_k}
    + \ln(\pi_k)
$$

## Estimation

To construct a discriminant model, only the class centroids and class covariance matrices (or overall covariance matrix) are required. In practice, these statistics are unknown and must be computed from the data. Given a data sample $\mathcal{D} = \{\mathbf{x}_i \}_{i=1}^n$, a data matrix $\mathbf{X}$ is a matrix of observations that are stored as either as columns or as rows:

$$
\mathbf{X}^{\text{col}} = \begin{bmatrix}
    \uparrow & \uparrow & & \uparrow \\
    \mathbf{x}_1 & \mathbf{x}_2 & \cdots & \mathbf{x}_n \\
    \downarrow & \downarrow & & \downarrow
\end{bmatrix}
\quad \text{and} \quad
\mathbf{X}^{\text{row}} = \begin{bmatrix}
    \leftarrow & \mathbf{x}_1^\intercal & \rightarrow \\
    \leftarrow & \mathbf{x}_2^\intercal & \rightarrow \\
    & \vdots & \\
    \leftarrow & \mathbf{x}_n^\intercal & \rightarrow
\end{bmatrix}
$$

While the orientation of the data matrix is largely an implementation detail, most statistics textbooks use the row format in their formulas and derivations. However, this has the disadvantage of data vectors being transposed relative to the random vector distribution they were sampled from.

For a class $k$ with corresponding sample $\mathcal{D}_k = \{\mathbf{x}_{i} \}_{i=1}^{n_k}$, we  can compute an estimate of the class centroid using the standard formula for an average and a corresponding centered sample:

$$
\hat{\mu}_k = \bar{\mathbf{x}}_k = \frac{1}{n}\sum_{i=1}^{n_k} \mathbf{x}_i
\quad \implies \quad
\tilde{\mathcal{D}}_k = \{\mathbf{x}_{i} - \hat{\mu}_k \}_{i=1}^{n_k}
= \{\tilde{\mathbf{x}}_{i}\}_{i=1}^{n_k}
$$

Given a centered data matrix $\tilde{\mathbf{X}}_k$ that consists of observations from sample $\tilde{\mathcal{D}}_k$, the class covariance matrix estimate can be computed as follows:

$$
\hat{\Sigma}
= \frac{1}{n_k-1} \sum_{i=1}^{n_k} \tilde{\mathbf{x}}_i\tilde{\mathbf{x}}_i^\intercal
= \begin{cases}
\frac{1}{n-1} \tilde{\mathbf{X}} \tilde{\mathbf{X}}^\intercal
&\text{if column oriented}\\
\frac{1}{n-1} \tilde{\mathbf{X}}^\intercal \tilde{\mathbf{X}}
&\text{if row oriented}

\end{cases}
$$

## Regularization

Section to be completed.

## Data Whitening

One main issue with the discriminant rules outlined above is that each discriminant function requires computing the inverse of the covariance matrix. Computing a matrix inverse is a computationally intensive procedure. Further, full inversion of a matrix may introduce numerical error as a result of floating point arithmetic. Therefore, data is typically "sphered" or "whitened" to decorrelate predictors and simplify the discriminant functions while maintaining numerical stability. A whitening transform for a random vector $\mathbf{x}$ with covariance matrix $\Sigma$ is a matrix $\mathbf{W}$ such that:

$$
\operatorname{Var}(\mathbf{Wx})
= \mathbf{W} \Sigma \mathbf{W}^\intercal = \mathbf{I}
\quad \implies \quad
\Sigma^{-1} = \mathbf{W}^\intercal \mathbf{W}
$$

In general, the whitening transform is not unique based on the characterization above. Two common methods to compute a whitening transform are through the eigendecomposition or the Cholesky decomposition, respectively:

$$
\Sigma = \mathbf{V} \Lambda \mathbf{V}^\intercal
\quad\text{or}\quad
\Sigma = \mathbf{L}\mathbf{L}^\intercal
$$

For the eigendecomposition, $\mathbf{V}$ is an orthogonal matrix consisting of the eigenvectors of $\Sigma$ and $\Lambda$ is a positive diagonal matrix of eigenvalues. For the Cholesky decomposition, $\mathbf{L}$ is a lower triangle matrix. This yields two approaches to the whitening transform:

$$
\mathbf{W}^{\text{SVD}} = \Lambda^{-\frac{1}{2}}\mathbf{V}^\intercal
\quad \text{and} \quad
\mathbf{W}^{\text{Chol}} = \mathbf{L}^{-1}
$$

In general, computing and inverting the Cholesky decomposition has a lower runtime complexity than computing the eigendecomposition so the Cholesky method is the preferred approach.

For QDA, a whitening matrix is defined for each class covariance matrix $\Sigma_k$. For a specific class $k$, we can define the transformed random vector of $\mathbf{x}$ and transformed class mean of $\mu$ as:

$$
\tilde{\mathbf{x}}_k = \mathbf{W}_k \mathbf{x}
\quad\text{and}\quad
\tilde{\mathbf{\mu}}_k = \mathbf{W}_k \mu_k
$$

Since $\Sigma_k^{-1} = \mathbf{W}_k^\intercal \mathbf{W}_k$, this simplifies the quadratic term of the discriminant function:

$$
(\mathbf{x}-\tilde{\mathbf{\mu}}_k)^{\intercal}\Sigma_k^{-1}(\mathbf{x}-\tilde{\mathbf{\mu}}_k)
= (\tilde{\mathbf{x}}_k-\tilde{\mathbf{\mu}}_k)^{\intercal}(\tilde{\mathbf{x}}_k-\tilde{\mathbf{\mu}}_k)
= ||\tilde{\mathbf{x}}_k-\tilde{\mathbf{\mu}}_k||_2^2
$$

Therefore, under the whitening transform, the QDA discriminant functions simplify to:

$$
\delta_k(\mathbf{x}) = -\frac{1}{2} \left[
    ||\mathbf{z}-\tilde{\mathbf{\mu}}_k||_2^2
    + \ln\left|\Sigma_k\right|
\right] + \ln(\pi_k)
$$

Similarly, the LDA discriminant functions simplify to:

$$
\delta_k(\mathbf{x}) =
-\frac{1}{2} ||\mathbf{z}-\tilde{\mathbf{\mu}}_k||_2^2 + \ln(\pi_k)
$$

## Canonical Discriminant Analysis (CDA)

Canonical discriminant analysis expands upon linear discriminant analysis by noting that
the class centroids lie in a $m-1$ dimensional subspace of the $p$ dimensions of the data
where $m$ is the number of classes. Defining the overall centroid and the between-class
covariance matrix:

$$
\mu = \sum_{k=1}^m \pi_k \mu_k
\qquad \text{and} \qquad
\Sigma_b = \sum_{k=1}^{m} \pi_k (\mu_k - \mu)(\mu_k - \mu)^{\intercal}
$$

Note that although $\mathbf{\Sigma}$ is a full rank matrix by design, the rank of $\mathbf{\Sigma}_b$ is $m-1$.

The goal of canonical discriminant analysis is to find the vector that maximizes the class
separation. This corresponds to maximizing the generalized Rayleigh quotient:

$$
\mathbf{c}^{\intercal} \mathbf{x}
\quad \text{where} \quad
\mathbf{c} =
\argmax_{\mathbf{u} \in \mathbb{R}^{p}}
\frac{\mathbf{u}^{\intercal}\Sigma_b\mathbf{u}}{\mathbf{u}^{\intercal}\Sigma\mathbf{u}}
$$

The vector $\mathbf{c}$ is known as a **canonical coordinate**. The problem can also be extended to a multiclass case:

$$
\mathbf{C} \mathbf{x}
\quad \text{where} \quad
\mathbf{C} =
\argmax_{\mathbf{U} \in \mathbb{R}^{m-1\times p}}\frac{\left|\mathbf{U} \Sigma_b \mathbf{U}^\intercal\right|}{\left|\mathbf{U} \Sigma \mathbf{U}^\intercal\right|}
$$

where the rows of $\mathbf{C}$ are the $m-1$ canonical coordinates. It has been shown that the solution to the equation above corresponds to the generalized eigenvectors of $\Sigma_b$ and $\Sigma$:

$$
\Sigma_b \mathbf{V} = \Sigma \mathbf{V} \Lambda
\quad \implies \quad
\mathbf{C} = \mathbf{V}^{\intercal}
$$

where $\mathbf{V}$ is a matrix of generalized eigenvectors (columns), $\Lambda$ is a positive diagonal matrix of generalized eigenvalues. Since $\mathbf{\Sigma}$ is a positive definite matrix by design, we can transform the generalized eigendecomposition into a regular eigendecomposition using the following procedure:

$$
\Sigma_b \mathbf{V} = (\mathbf{W}^{\intercal}\mathbf{W})^{-1} \mathbf{V} \Lambda
\quad \implies \quad
\mathbf{W} \Sigma_b \mathbf{V} = \mathbf{W}^{-\intercal} \mathbf{V} \Lambda
$$

Let $\tilde{\mathbf{V}} = \mathbf{W}^{-\intercal}\mathbf{V}$ so that $\mathbf{V} = \mathbf{W}^\intercal \tilde{\mathbf{V}}$, then substitute $\tilde{\mathbf{V}}$ into the above equation:

$$
\mathbf{W} \Sigma_b \left(\mathbf{W}^\intercal \tilde{\mathbf{V}}\right)
= \mathbf{W}^{-\intercal} \left(\mathbf{W}^\intercal \tilde{\mathbf{V}} \right) \Lambda
\quad \implies \quad
\mathbf{W} \Sigma_b \mathbf{W}^\intercal \tilde{\mathbf{V}}
= \tilde{\mathbf{V}} \Lambda
$$

Now, $\tilde{\mathbf{V}}$ can be solved for by decomposing $\mathbf{W} \Sigma_b \mathbf{W}^\intercal$ using an ordinary eigensolver. We can compute $\mathbf{C}$ by inverting the transformations above:

$$
\tilde{\mathbf{V}} = \mathbf{W}^{-\intercal}\mathbf{C}^\intercal
\quad \implies \quad
\mathbf{C} = \tilde{\mathbf{V}}^\intercal \mathbf{W}
$$

## Implementation Best Practice

For row data, the whitening matrix must be right applied

$$
\mathbf{X}_{\text{r}} = \mathbf{Q}\mathbf{D}\mathbf{V}^\intercal
\quad \implies \quad
\mathbf{W}^{\text{SVD}} = \mathbf{V} \mathbf{D}^{-1}
$$

Using the QR decomposition, the Cholesky whitening matrix can be computed
$$
\mathbf{X}_{\text{r}} = \mathbf{Q}\mathbf{R}
\quad \implies \quad
\mathbf{W}^{\text{Chol}} = \mathbf{R}^{-1}
$$

Similarly for column data, the whitening matrices must be left-applied

$$
\mathbf{X}_{\text{c}} = \mathbf{Q}\mathbf{D}\mathbf{V}^\intercal
\quad \implies \quad
\mathbf{W}^{\text{SVD}} = \mathbf{D}^{-1} \mathbf{Q}^\intercal
$$

$$
\mathbf{X}_{\text{c}} = \mathbf{L}\mathbf{Q}
\quad \implies \quad
\mathbf{W}^{\text{Chol}} = \mathbf{L}^{-1}
$$

Data matrices

QR
SVD

## References

  * Friedman J. 1989. *Regularized discriminant analysis.* Journal of the American statistical association 84.405; p. 165-175.
  * Hastie T, Tibshirani R, Friedman J, Franklin J. 2005. *The elements of statistical learning: data mining, inference and prediction*. The Mathematical Intelligencer, 27(2); p. 83-85.


text:
# MediaKit

## How to run it

First open `Terminal` and go to the the root of the example project `cd MediaKit/MediaKit Example` and then do a `pod update`. After the update finishes open the `MediaKit Example.xcworkspace`.

repository: wonderkiln/MediaKit

repo_name: wonderkiln/MediaKit


text:
# Plugins for OverlayPlugin

This is a set of plugins that will work with ACT's OverlayPlugin(https://github.com/RainbowMage/OverlayPlugin)

While OverlayPlugin offers already lots of cool features, I can NOT and do NOT want to include every feature directory in the core.

Therefore you can enhance and/or change the OverlayPlugin experience by adding plugins which add and/or change UI and UX.
Install these plugins as with the other cool plugins.

### PetEnPlugin.cs
While using FFXIV client in Japanese, Pets' name is displayed as Japanese on miniparse.
Therefore translate them from Japanese to English by this plugin.
You can specify {NameEn} on miniparse.html.

### NameMosaPlugin.cs
Player's name is translated to Mosaic Unicode by this plugin.
You can specify {NameMosa} on miniparse.html.

repository: krbysh/FFXIV-ACT-OverlayPlugin-Plugins

repo_name: krbysh/FFXIV-ACT-OverlayPlugin-Plugins


text:
# Kick Assembler (... and chew bubble gum) | ChangeLog

## [1.9.0]

### Changed
- dependency upgrades
- Gradle-wrapper update
- other minor updates

## [1.8.0]

### Changed
- upgraded plugin-dependencies
- improved syntax highlighting (revised Flex/BNF definitions)

## [1.7.0]

### Changed
- upgraded library-/plugin-dependencies
- various refactorings (mostly code-inspection warnings)

### Fixed
- fixed RunConfiguration handling (which was unnoticeably broken due to plugin-API changes; showed "SDK is not specified for module")

## [1.6.0]

### Changed
- updated library-/plugin-dependencies ("Gradle IntelliJ Plugin", etc.)
- reorganized directory-structure (including migration to Kotlin DSL for build-script)
- Gradle-wrapper update
- min IDE version set to "2021.3"

## [1.5.0]

### Changed
- necessary adjustments to work with the latest plugin APIs
- automatic lexer/parser source generation upon build
- updated library-/plugin-dependencies
- Gradle-wrapper update
- other minor improvements

## [1.4.0]

### Fixed
- bugfixes (file template, localization, filetype handling)

## [1.3.0]

### Added
- added plugin-icon

### Changed
- several code-changes/refactorings in order to eliminate usage of deprecated APIs
- raised min-version of compatibility to 201 (2020.1)
- Gradle-wrapper update

### Fixed
- fix for KickAssembler SDK-configuration

## [1.2.0]

### Changed
- updated plugin name ("[beta]" removed)
- updated plugin dependencies
- Gradle-wrapper update
- other minor configuration updates

## [1.1.0]

### Fixed
- fixed SDK-/JRE-handling for run-configurations

### Added
- syntax highlighting: missing assembler-directives added ('.cpu', '.fillword', '.lohifill')

### Changed
- updated plugin dependencies

## [1.0.5]

### Fixed
- fixed since-build number

## [1.0.4]

### Changed
- adjusted "IDEA compatibility version"... again ;-)

## [1.0.3]

### Fixed
- updated/fixed description

## [1.0.2]

### Changed
- minimum and maximum "IDEA compatibility version" now being set via Gradle-plugin

## [1.0.1]

### Changed
- updated plugin description

## [1.0.0]

### Changed
- initial release

gha_language: Java


text:
# Setup

npm install -g browserify
npm install -g watchify

# Running page locally
file:///Users/jostrin/jeffostrin/ffxvtrainer/web2/web/index.html

# Helpful links

## source for setup
https://medium.com/jeremy-keeshin/hello-world-for-javascript-with-npm-modules-in-the-browser-6020f82d1072

## S3 hosted static website
https://docs.aws.amazon.com/AmazonS3/latest/dev/website-hosting-custom-domain-walkthrough.html

repository: jeffostrin/ffxvtrainer

repo_name: jeffostrin/ffxvtrainer


text:
# gearman [![Build Status](https://travis-ci.org/peonone/gearman.svg?branch=master)](https://travis-ci.org/peonone/gearman) [![Go Report Card](https://goreportcard.com/badge/peonone/gearman)](https://goreportcard.com/report/github.com/peonone/gearman)

It is a go implementation of [gearman](http://gearman.org/)

For now only the server is implemented, client and worker will be added in future.

## [server](server/README.md)
## client (TODO)
## worker (TODO)

repository: peonone/gearman

repo_name: peonone/gearman


text:
# Bash Template Command

*This `README.md` is autogenerated.*

This is a GitHub template repo that will be copied instead of forked to
create a new Bash command with a command something like this:

```
gh repo create rwxrob/mycmd -p rwxrob/template-bash-command
```

This `command` inside can then be renamed and finished.

Obviously, not all of this is needed for many Bash scripts, but anything
with more than two subcommands will benefit from the builtin tab
completion, embedded Markdown help documentation support, and included
functions (`usage`, `_filter`, `_buffer`, `_have`, etc.)

## Naming Conventions

* Name repos containing single bash commands with `cmd-`
* Name template repos beginning with `template-`
* Start command functions with `command_` to be completed
* Start command functions with `command__` to not be completed

## Dependencies

Required:

* Bash 4+

Optional:

* `pandoc` - for rich help docs

## Justification

Bash is the dominate shell scripting language and the official default
Linux interactive shell, which reduces cognitive overhead; every command
line *is* a line of code that could be put into script as is. Bash
scripts are at the core of cloud, containers, and Kubernetes. Bash 4+
with its associative array support, powerful regular expressions, and
multiple ways of feeding data to loops easily covers the needs
previously requiring Python and Perl scripts. Bash scripts are also much
more powerful, safer, flexible, and performant than POSIX shell or Zsh.

## Guidelines

* Write GitHub Flavored Markdown only
* Use present tense ("outputs" over "will output")
* Prefer "output" and "display" over ~~print~~
* Follow the [naming conventions](#naming-conventions)
* Use the official bash path: `#!/bin/bash`
* Use of `#!/usr/bin/bash` is outdated
* Using `#!/usr/bin/env bash` introduces unnecessary risk
* Explicitly export `PATH` in script when possible
* Always check script with [`shellcheck`] before releasing
* Always use `bc` for *any* floating point math

[`shellcheck`]: <https://www.shellcheck.net>

## Legal

Copyright 2021 Rob Muhlestein<EMAIL_ADDRESS>
Released under Apache-2.0 License
Please mention <https://rwxrob.tv>

## Commands

### The `bar` Command

Bars.

### The `foo` Command

Foos.

### Display Help Information

```
help [<command>]
```

Displays specific help information. If no argument is passed displays
general help information (main). Otherwise, the documentation for the
specific argument keyword is displayed, which usually corresponds to
a command name (but not necessarily). All documentation is written in
GitHub Flavored Markdown and will displayed as a web page if `pandoc`
and `$HELP_BROWSER` are detected, otherwise, just the Markdown is sent
to `$PAGER` (default: more).

Also see `readme` and `usage` commands.

### The `json` Command

Converts input into JSON string using `jq` containing only escaped
(`
`) line returns.

### Generate `README.md` File

```
command readme > README.md
```

The `readme` command will output the embedded help documentation in raw
GitHub Flavored Markdown suitable for use as a `README.md` file on
GitHub or similar hosting service.

### The `usage` Command

Displays a summary of usage.

----

*Autogenerated Sun Aug 15 04:56:38 PM EDT 2021*

repository: sdconrox/template-bash-command

repo_name: sdconrox/template-bash-command


text:
Mercato.AspNet.OData.DataTable
=========

Adds support for [OData](https://odata.github.io/) query syntax over ADO.Net [DataTables](https://docs.microsoft.com/en-us/dotnet/api/system.data.datatable) in WebApi projects.

This is an initial implementation to allow for core functionality in cases where there is no fixed structure for the datatable at design time, meaning that use of the standard Microsoft.AspNet.OData nuget is precluded by the lack of a fixed EdmModel or underlying Entity source.

The implementation as it stands currently supports the following elements of the OData syntax:

* $filter - supporting all standard operators with the exception of has
* $select - not including support for $expand as there is no concept of related entities
* $top
* $skip
* $orderby

At the time of writing there is no support for functions implemented

## Usage ##

### Getting Started ###

    Install-Package Mercato.AspNet.OData.DataTableExtension

This will install the standard Microsoft OData dependencies

### OData Initialisation ###

To correctly intitialise the OData parsing for your API project add the following to your startup:

```csharp
using Microsoft.AspNet.OData.Extensions;

...

        public static void Register(HttpConfiguration config)
        {
            config.EnableDependencyInjection();

			...
        }

```

In your controller, once you have your populated DataTable:

```csharp
using Mercato.AspNet.OData.DataTableExtension;
...

            DataTable BaseData = ....;

            DataTable Output = BaseData.ApplyODataQuery(Request);
```

## Swagger Support ##

The class ODataParametersSwaggerDefinition adds support for indicating the supported OData parameters in OpenApi (Swagger) documentation using [Swashbuckle](https://github.com/domaindrivendev/Swashbuckle).

The class implements the IOperationFilter interface to allow use according to the Swashbuckle documentation. In addition a static method is exposed to allow for direct addition of the parameters if building the operation representations manually.

```csharp
using Mercato.AspNet.OData.DataTableExtension;

…

            Swashbuckle.Swagger.Operation TargetOperation = ….;
            ODataParametersSwaggerDefinition.AppendOdataParametersToOperation(TargetOperation);
```

repository: delradie/DataTableOData

gha_language: C#

repo_name: delradie/DataTableOData


text:
# Radius-Puppy

[![Netlify Status](https://api.netlify.com/api/v1/badges/5d131df1-5565-4a04-bb76-dbab4e16836a/deploy-status)](https://app.netlify.com/sites/radius-puppy/deploys)

![alt text](https://radius-puppy.netlify.app/Screenshot.png "Screenshot")

This tool helps you create beautiful css border radius for your website fast and free.

[Use Now](https://radius-puppy.netlify.app/)

# How to use

Visit [https://radius-puppy.netlify.app/] and click on the "Get Started" button, it will tage you to the app page, from there you can create beautiful border radius and grab the code.

# Contribution

To contribute to this project, clone this repository and make a pr.

# Lincense

MIT License

Copyright (c) 2020 [Valentine Elum](https://twitter.com/vahlcode)

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

 IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

repository: vahlcode/Radius-Puppy

gha_language: CSS

repo_name: vahlcode/Radius-Puppy


text:
# Docker Rootless

Rootless docker enables unprivileged end-users to utilize docker containers.
One motivation for this is that typically it is easier to manage unprivileged
users within HPC clusters such as Slurm. Alternatives, such as Singularity and
Enroot, also enable an unprivileged user to utilize containerization. The added
convenience of rootless docker is that if one is working with docker containers
it would be more straightforward to build and run docker containers instead of
having to convert to another container format.

- [Docker Rootless](#docker-rootless)
  - [Installing Rootless Docker](#installing-rootless-docker)
  - [Using Rootless Docker in Slurm](#using-rootless-docker-in-slurm)
    Further information about rootless docker can be found here:
    <https://docs.docker.com/engine/security/rootless/>

## Installing Rootless Docker

An ansible role and playbook are provided to install rootless docker [docker-rootless.yml](../../playbooks/container/docker-rootless.yml). The default install location is set via variable `rootlessdocker_install_dir` with default setting of `/sw/software/rootless_docker`. Set the variable to a different value (use `--extra-vars "rootlessdocker_install_dir=<somepath>"`) if a different install location is desired. Run the playbook via ansible command:

```bash
ansible-playbook -K --limit slurm-cluster playbooks/container/docker-rootless.yml
```

For networking to properly work with rootless docker the `br_netfilter` kernel
module should be loaded. Check via:

```bash
lsmod | grep br_netfilter
```

The `br_netfilter` kernel module is typically installed by default on various
Linux platforms. If not loaded then load via:

**Ephemeral**

```
$ sudo modprobe br_netfilter
```

**_or_**

**Persistent**

```bash
sudo sh -c 'echo "br_netfilter" > /etc/modules-load.d/br_netfilter.conf'
```

## Using Rootless Docker in Slurm

The playbook installs an environment module for loading rootless docker via
modules. Users with bash shells will see the following modules in a typical
DeepOps deployed Slurm cluster:

```console
module avail

-------------------------------------------------------------------------- /sw/hpc-sdk/modulefiles ----------------------------------
   nvhpc/20.7    nvhpc/20.9 (D)    nvhpc-byo-compiler/20.7    nvhpc-byo-compiler/20.9 (D)    nvhpc-nompi/20.7    nvhpc-nompi/20.9 (D)

------------------------------------------------------------------ /sw/software/rootless-docker/modulefiles -------------------------
   rootless-docker

  Where:
   D:  Default Module
```

Once the rootless docker module is loaded scripts "start_rootless_docker.sh"
and "stop_rootless_docker.sh" will become available (added via PATH). Use
these scripts to start an stop rootless docker daemon. The commands below
illustrate how to start and run a rootless docker container on Slurm.

```bash
srun --ntasks=1 --gpus-per-task=1 --cpus-per-task=5 --gres-flags=enforce-binding --pty bash

module load rootless-docker

start_rootless_docker.sh # specify --quiet option to hide rootles docker messages

docker run --gpus all -it --rm nvcr.io/nvidia/cuda:11.0-base-ubuntu18.04

root@445bf5cca686:/# echo NGPUS: $(nvidia-smi -L | wc -l)
NGPUS: 1

root@445bf5cca686:/# exit # exit docker interactive sessions
exit

stop_rootless_docker.sh # Optionally explicitly stop rootless docker. Will be killed on Slurm exit regardless.

exit # end slurm session
exit

```

It is important to be aware that rootless docker runs via user namespace
remapping. Therefore even though one might appear as root in a docker
container, files created are owned by the user, and within the container a user
would not have write/execute permissions to filesystem or executables that the
user already does not have permission to outside of the container.

repository: NVIDIA/deepops

gha_language: Shell

repo_name: NVIDIA/deepops


text:
# Solution Document

## Tick Data Notes
High quality tick data has been sourced from Tick Data LLC at the cost of approximately 1000 USD. The focus for our research will be on S&P 500 E-mini futures, for the period 10 September 1997 - 13 February 2019. The S&P 500 E-Mini futures data is the set which de Prado regularly references in his work and by using the same set we create a natural way to benchmark our implementations.

The folder contains the details of the tick data and the small nuances related to it.

## Chapter 3
An implementation of the answers pertaining to chapter three's questions in *Advances in Financial Machine Learning*. By answering these questions we also complete the objectives of our mini 6 week Capstone. This research will then be used later in the longer 6 month capstone as we look for a novel contribution to the literature.

This folder contains the following:
* mlfinlab: A folder containing the snippets of code from the book, needed to answer the chapters questions.
* Chapter3 notebook: Answers to the questions in chapter 3.
* requirements.txt: The packages and version numbers used in the notebook.
* sample_dolalr_bars.csv: A 1 year sample of dollar bars for S&P500 Emini futures. Sampled at 1/50 of the daily avg dollars.

repository: surya-datascientist/research

repo_name: surya-datascientist/research


text:
# Neighborhood Map - React Map

This project was developed for [Udacity's Front-End Developer Nanodegree Programm](https://udacity.com/course/front-end-web-developer-nanodegree--nd001).

## Overview
The goal of the project was to use React, the Google Maps API, plus data from a third-party API, to create a web application from scratch.

### Requeriments
  * Includes a text input field that filters the map markers and list items to locations matching the text input or selection.
  * A list-view of location names is provided which displays all locations by default, and displays the filtered subset of locations when a filter is applied.
  * Map displays all location markers by default, and displays the filtered subset of location markers when a filter is applied.

## Local Installation

1. [Download](https://github.com/nybragaramos/neighborhood-map/archive/master.zip) or [Clone](https://github.com/nybragaramos/neighborhood-map.git) the Repository.
2. Run `npm install` at the project folder to install the project dependencies.
3. Run the app using `yarn start` after all of the dependencies have been installed.
4. A new browser window should automatically open displaying the app. If it doesn't, navigate to [http://localhost:3000/](http://localhost:3000/) in your browser

## Live APP

[CLICK TO TRY IT OUT!](https://nybragaramos.github.io/neighborhood-map/)

## Important
 * This application uses API's from Google maps and Foursquare, and developer free plans are only limited to a certain number of requests per day so you may experience not being able to load content.
 * The service worker is only functional in production mode hat is deploying to the github pages(Please try it on the hosted [site](https://nybragaramos.github.io/neighborhood-map/)).

## Project Tools
[Create ReactApp](https://github.com/facebook/create-react-app)

[Yarn](https://yarnpkg.com/)

[Google Maps API](https://developers.google.com/maps/documentation/javascript/tutorial)

[Foursquare API](https://developer.foursquare.com/)

[Font Awesome](https://github.com/FortAwesome/react-fontawesome)

[React-Debounce-Input](https://github.com/nkbt/react-debounce-input)

[gh-pages](https://github.com/tschaub/gh-pages)

## License
[MIT](https://github.com/nybragaramos/neighborhood-map/blob/master/LICENSE)

repository: nybragaramos/neighborhood-map

repo_name: nybragaramos/neighborhood-map


text:
# Arthrinium arundinis (Corda) Dyko & B. Sutton, 1979 SPECIES

#### Status
SYNONYM

#### According to
The Catalogue of Life, 3rd January 2011

#### Published in
Mycotaxon 8(1): 119 (1979)

#### Original name
Gymnosporium arundinis Corda, 1838

### Remarks
null

repository: mdoering/backbone

path: /life/Fungi/Ascomycota/Sordariomycetes/Apiosporaceae/Apiospora/Apiospora montagnei/ Syn. Arthrinium arundinis/README.md

repo_name: mdoering/backbone


text:
Shop Redux 👋

![badge](https://img.shields.io/badge/license-MIT-brightgreen)

## Description
🔍 Web developers frequently have to immerse themselves in a new technology to solve a problem, with only that tool’s documentation for help. They must sift through it to find the information that matches the specific problem they’re trying to solve.
## Table of Contents
- [Description](#description)
- [Installation](#installation)
- [Usage](#usage)
- [License](#license)
- [Contributing](#contributing)
- [Tests](#tests)
- [Questions](#questions)
## Installation
💾 run npm install, and then npm start.
## Usage
💻 It is a shop application for purchasing items, and has been refactored with the redux new technology to help improve it.
## License
![badge](https://img.shields.io/badge/license-MIT-brightgreen)

This application is covered by the MIT license.
## Contributing
👪 Ethan Morris
## Tests
✏ Yes
## Questions
✋ Contact me

:octocat: Find me on GitHub: [Gimbalbyte](https://github.com/Gimbalbyte)

✉ Email me with any questions<EMAIL_ADDRESS>/>

repository: Gimbalbyte/Shop-Redux

repo_name: Gimbalbyte/Shop-Redux


text:
## GO NEWS APP
# EDITED BY
- BRIAN MBUGUA NDERITU

## Description
Go News App is a web application that displays a list of various news sources, top headlines on the landing page and world leading news caster BBC. Clicking a news article will redirect the user to read it fully from the news source. It achieves this by using the News API.

You can view the site at: Heroku

# User Stories
These are the behaviours/features that the application implements for use by a user.

As a user I would like to:

- See various news sources
- Select the ones they prefer
- See the top news articles from that news source
- See the image, description and time the news article was created
- Click on an article and read it fully from the news source

## SetUp / Installation Requirements
### Prerequisites

- python3.6
- pip
- virtualenv

## Cloning
 - In your terminal:

  $ git clone https://github.com/Brayoh-Ux/Go_News-App/
  $ cd Go_News-App

## Technologies Used
- Python3.6
- Flask

## License
MIT License

Copyright (c) 2021 Brian M.Nderitu


text:
# iCrawler
iCrawler (intelligent Crawler) is an effective and efficient Web content extractor for optimizing the crawling process

iCrawler is an open source project that has three different features:

* Automatically and efficiently extracts necessary contents including headline, summary, main content and other contents
* Automatically determines crawling depth
* Quickly discovers new hyperlinks in web pages

# Publications
An effective and efficient web content extractor for optimizing the crawling process. Uzun, E.; Güner, E., S.; Kılıçaslan, Y.; Yerlikaya, T.; and Agun, H., V. Software - Practice and Experience, 44(10): 1181-1199. 2014.

Click for bibtex, downloads, all publications...

# Licence
Copyright (c) 2013 Erdinç Uzun

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

repository: erdincuzun/iCrawler

repo_name: erdincuzun/iCrawler


text:
# PredigWebApp-prototype

PredigSystem WebApp prototype. This will be the portal used for doctors.

* [Demo](https://predigsystem-webapp.herokuapp.com/login.html)
* [Android App](https://github.com/PredigSystem/PredigApp)
* [Wiki](https://github.com/PredigSystem/PredigApp/wiki)

## Authors

- [Sultan](https://github.com/sultanbeisen)
- [Didac](https://github.com/didacflorensa)
- [Pau](https://github.com/pbalaguer19)

See also the list of [contributors](https://github.com/your/project/contributors) who participated in this project.

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details

repository: PredigSystem/PredigWebApp-prototype

repo_name: PredigSystem/PredigWebApp-prototype


text:
###Participants
* Ewa Janczukowicz, Simon Becot (Orange)
* Ancuta Corici (Fokus)
* Kay Hänsge (DT)
* Paulo Chainho (PT)

###Minutes
* Ewa: presantation of the context and of two possible architectures
* Kay: there is a need of an AF (based on standards), another achitecture proposal (merging 1 and 2 solution), by puting more functionality to a broker
* Paulo: would it be possible to use a messaging server as a broker?
* Ancuta: LHCB broker presentation
* Other points:
*   - not sure yet if messaging server can be used since broker functionalities have not beed defined yet in detail
*   - LHCB is not the same as a broker for mobile access networks
*   - interfaces will depend on a global architecture

###Action points
* AP1: Work offline on the architecture definition (29/07 - All) - ppt on BSCW in WP3.3 folder
*   AP1.1: Work on a global architecture merging solutions 1 and 2 (Kay, 24/07)
*   AP1.2: Detail solution 1 and 2 (Ewa, 24/07)
*   AP1.3: Comments (ALL, 29/07)
* AP2: Review global architecture (29/07, next meeting)
* AP3: Discuss interfaces (29/07, next meeting)
* AP4: Decide on methodology (29/07, next meeting)

repository: reTHINK-project/core-framework

repo_name: reTHINK-project/core-framework


text:
---
layout: post
title: Making an Online Github Notebook
date: '2018-05-08'
categories: Protocols
tags: [Protocols, Github]
---

  #  <center> Protocol to make an Online Github Notebook

This protocol will guide you through making your own online notebook forked from Jekyll-now. For more information about the original webside layout, click [here](https://github.com/barryclark/jekyll-now). To set up your online notebook, you will need to have the following programs on your computer:
  - Gitbash (for PCs, Macs have Terminal already installed)
  - A Markdown editor (e.g. Atom or MOU)

# <center> Steps:

## 1. Fork The Repository from [Mass_Lab_Notebook] (https://github.com/Mass-Lab/Open_Lab_Notebook_Mass_Lab) or [Jekyll-now](https://github.com/barryclark/jekyll-now)

* Fork the repository to **yourgithubusername**.github.io
* Make sure you have a directory on your computer

## 2. Edit config.yml file

* Name of your site (displayed in the header)
name: **Fill in here**
* Short bio or description (displayed in the header)
description: **Fill in here**
* URL of your avatar or profile pic
avatar: **Add File Link Here**
* Edit the following lines appropriately: **6, 9, 12, 20 - 32**

** If you are unsure what to change, compare other notebook config.yml files and determine what is different**

## 3.  Add config.yml to site

Download Gitbash (PC) or Open Terminal (Mac)

```
cd Desktop/Notebook/XXXXXX_Lab_Notebook
git add config.yml
git commit -m "adding new config file"
git push origin master
```

## 4. Add New Admin Link:

In your computer folder (XXXXXX_Lab_Notebook):
- Open **_layouts**
- Edit **default.html**
  * Change **line 45** to your Github notebook link
- Save and push file to origin master:

```
cd Desktop/Notebook/XXXXXX_Lab_Notebook
cd _layouts
git add default.html
git commit -m "adding new admin link"
git push origin master
```

## 5. Edit about.md page

In your computer folder (XXXXXX_Lab_Notebook):
* Open and edit **about.md**
  * Change all information to your personal information
  * Add a CV
* Save and Push to origin master

```
cd Desktop/Notebook/XXXXXX_Lab_Notebook
git add about.md
git commit -m "adding new about page"
git push origin master
```

## 6. Edit READMe.md file

In your computer folder (XXXXXX_Lab_Notebook):
* Open and edit ReadMe.md
  * Edit all information
* Save and push to origin master

```
cd Desktop/Notebook/XXXXXX_Lab_Notebook
git add READMe.md
git commit -m "adding new READMe"
git push origin master
```

## 7. How to add a post

* Make a new post in a markdown editor using the **post_template.sh**
* Save new post in **_posts folder**
* Push to origin master

```
cd Desktop/Notebook/XXXXXX_Lab_Notebook/_posts
git add New_Post.md
git commit -m "adding new post"
git push origin master
```

path: /_posts/<center> Steps-.md

filename: <center> Steps-.md


text:
BASE-MERN

A robust but light starter/boilerplate for mern development

MongoDB, Expressjs, React/Redux, Nodejs

> MERN is the utilisation of JavaScript in handling the different aspects of a fullstack app.

MERN stack is an implementation of MongoDB, Expressjs, React, Nodejs.

## clone or download

```terminal
$ git clone https://github.com/samodum/base-mern.git
$ npm i
```

## project structure

```terminal
LICENSE
package.json
server/
   package.json
   .env (to create .env, check [prepare your secret session])
client/
   package.json
...
```

# Local usage

## Required software

You will need to have the following installed to able to run this project locally.

- [MongoDB](https://gist.github.com/nrollr/9f523ae17ecdbb50311980503409aeb3)
- [Node](https://nodejs.org/en/download/) ^10.0.0
- [npm](https://nodejs.org/en/download/package-manager/)

## Client-side usage(PORT: 3000)

Here is how to initialize and run the client side

```terminal
$ cd client   // go to client folder
$ npm i       // npm install pacakges
$ npm run dev // run it locally

// deployment for client app
$ npm run build
$ npm run start
```

## Server-side usage(PORT: 8000)

Here is how to initialize and run the server side

### Prepare your secret

Because you need to add a JWT_SECRET in .env to connect to MongoDB, first run the following script

```terminal
// in the root level
$ echo "JWT_SECRET=YOUR_JWT_SECRET" >> ./server/src/.env
```

Then get into the server folder and take the following steps

```terminal
$ cd server   // go to server folder
$ npm i       // npm install pacakges
$ npm run dev // run it locally
$ npm run build // this will build the server code to es5 js codes and generate a dist file
```

## Deploy Server to [Heroku](https://dashboard.heroku.com/)

```terminal
$ npm i -g heroku
$ heroku login
...
$ heroku create
$ npm run heroku:add <what-youd-like-to-name-your-heroku-app>

// remember to run this command in the root level, not the server level, so if you follow the documentation along, you may need to do `cd ..`
$ pwd
/Users/<your-name>/mern
$ npm run deploy:heroku
```

### After creating heroku

remember to update the file of [client/webpack.prod.js](https://github.com/samodum/base-mern/blob/master/client/webpack.prod.js)

```javascript
 'API_URI': JSON.stringify('https://what-youd-like-to-name-your-heroku-app.herokuapp.com')
```

# Dependencies(tech-stacks)

| Client-side              | Server-side               |
| ------------------------ | ------------------------- |
| axios: ^0.19.2           | bcryptjs: ^2.4.3          |
| react: ^16.12.0          | cors: ^2.8.5              |
| react-dom: ^16.12.0      | cross-env: ^7.0.0         |
| react-redux: ^7.2.0      | dotenv: ^2.0.0            |
| react-router: ^5.1.2     | express: ^4.17.1          |
| react-router-dom: ^5.1.2 | express-validator: ^6.4.0 |
| redux: ^4.0.5            | jsonwebtoken: ^8.5.1      |
| redux-thunk: ^2.3.0      | mongoose: ^5.9.1          |
| webpack: ^4.41.6         | morgan: ^1.9.1            |
| @babel/core: ^7.8.4      | babel-core: ^6.26.3       |

## Standard

[![JavaScript Style Guide](https://cdn.rawgit.com/standard/standard/master/badge.svg)](https://github.com/standard/standard)

## BUGs or comments

[Create new Issues](https://github.com/samodum/base-mern/issues)

repository: SamOdum/base-mern

repo_name: SamOdum/base-mern


text:
# [The Office V - Find a Chair ](https://www.codewars.com/kata/the-office-v-find-a-chair "https://www.codewars.com/kata/57f6051c3ff02f3b7300008b")

So you've found a meeting room - phew! You arrive there ready to present, and find that someone has taken one or more of the chairs!! You need to find some quick.... check all the other meeting rooms to see if all of the chairs are in use.

Your meeting room can take up to 8 chairs. `need` will tell you how many have been taken. You need to find that many.

Find the spare chairs from the array of meeting rooms.
```
public class Room {
  public final String occupants;  // number of occupants, each occupant is represented by 'X'
  public final int chairs;        // number of chairs in the room
}
```

You should return an array of integers that shows how many chairs you take from each room in order, up until you have the required amount.

example:
`[Room("XXX", 3), Room("XXXXX", 6), Room("XXXXXX", 9), Room("XXX",2)]` when you need 4 chairs:

result -- > `[0, 1, 3]` (no chairs free in room 0, take 1 from room 1, take 3 from room 2. No need to consider room 4 as you have your 4 chairs already.

If you need no chairs, return `'Game On'`. If there aren't enough spare chairs available, return `'Not enough!'`

repository: ParanoidUser/codewars-handbook

repo_name: ParanoidUser/codewars-handbook


text:
General Installation Guide
==========================

# Installation from source

Fetch the sources from:
    <URL:https://dist.opendnssec.org/source/testing/opendnssec-2.0.0a6.tar.gz>
Verify the integrity of the distribution using one of the three commands:
* sha256sum opendnssec-2.0.0a6.tar.gz
* sha1sum opendnssec-2.0.0a6.tar.gz
* gpg --verify opendnssec-2.0.0a6.tar.gz.sig

These three should result respectively in:
* "SHA256(opendnssec-2.0.0a6.tar.gz)= 4da0bca47e8d17099a69f10d27f22fb3616fb8c6c2d361301ddf0dfeb0d89758";
* "SHA1(opendnssec-2.0.0a6.tar.gz)= f71a413936dd3f03b80c550bdefe0dde9a73e6b0";
* exit with a success (ie. with a zero execution status).

In order to use GPG you should first have imported the PGP
public signing key of OpenDNSSEC.  This needs to be performed
only once for any future download.  Obtain the PGP public key
from <URL:https://wiki.opendnssec.org/display/OpenDNSSEC/PGP>, in
the quotation box of the most recent distribution key on that page.
Save the key to a file named "opendnssec.asc" and import it
using "gpg --import opendnssec.asc".

OpenDNSSEC is build using automake/autoconf, and thus includes a configure
script to detect the right compilation requirements and configure any
options if needed.  Different operating system distributions and different
requirements may apply.  Therefor there is no one right configuration,
one possible way of configuration would be to install the package as
root using:

    ./configure \
      --prefix=/usr --sysconfdir=/etc --localstatedir=/var --mandir=/usr/man \
      --without-cunit --with-readline
    make install

# Installation as non-root

This installation procedure was performed as root in order to install
everything in the root installation path.  If you wish, you can also install
OpenDNSSEC in some alternate location as a normal user.  There is however a
better solution to install program as root, but have a separate user and group
to control OpenDNSSEC.  With this OpenDNSSEC would initially still be
installed as root with "/" as the main prefix installation path.  But now an
additional user and group are created to use OpenDNSSEC.  You can start the
OpenDNSSEC daemons from the start-up sequencs, and instruct it to lower its
priviledges to this user.

Create an additional unix group to manage opendnssec.  Users which are
members of this group can access the important files and make changes.
We suggest the name "ods" (or "opendnssec") for this.

Under generic Linux this could be accomplished using:

    groupadd ods

Create an additional user to own the important files.  We suggest the
name "ods" (or "opendnssec").  Again under generic Linux this can be
accomplished using:

    useradd --no-create-home --base-dir /var/opendnssec --gid ods \
      --no-log-init --no-create-home --shell /sbin/nologin ods

This user will not directly be used, so you need to actively make other
users member of this group in order to continue.

Now limit the access to OpenDNSSEC to users of the just created group:

    chown -R ods:ods /etc/opendnssec /var/opendnssec \
                     /var/run/opendnssec /usr/bin/ods-* /usr/sbin/ods-*
    chmod -R ug+rwX,o-rwx /etc/opendnssec /var/opendnssec \
                     /var/run/opendnssec /usr/bin/ods-* /usr/sbin/ods-*

Make sure the ods user has access to the PKCS#11 key repository.
Failing to do so will not give any immediate errors, but your zones will
never get signed.  OpenDNSSEC will endlessly keep attempting to access
the interface.

# Initial configuration

First make sure your PKCS#11 implementation is installed, accessible and
initialized.  Both SoftHSM version 1 and 2 may be used with OpenDNSSEC 2,
see also the notes on SoftHSM.

We now assume you have installed OpenDNSSEC and a suitable PKCS#11
with the root directory as installation path.  This means that the main
configuration files go into /etc/opendnssec and the working directory
where OpenDNSSEC saves state is in /var/opendnssec.  Now OpenDNSSEC is
installed, you need a basic configuration set-up.

## Initial configuration conf.xml

The primary configuration file is conf.xml.  There may have been a sample
configuration file pre-installed or one available as conf.xml.sample.
Most configuration is suitable for first use, for details see the
OpenDNSSEC wiki.

The following items do however need checking or amending.

The Configuration/RepositoryList/Repository item needs to match your
PKCS#11 infrastructure.  PKCS#11 interfaces are delivered as shared
libraries that can either be directly linked or dynamically loaded into
the user application.  OpenDNSSEC uses the latter and therefor needs
to know the exact path to the dynamic library that it needs to load.
PKCS#11 interfaces manage multiple stores, protected with a PIN number.
It therefor needs to know the Label (not slot-id) and the PIN number
to use.  When using SoftHSM these should match with the arguments given
to initialize the token store.

Multiple Repository items may be declared.  In the kasp.xml configuration
files they will later be referred by with the name attribute of the
Repository tag.
Each Repository item should define at least:
* Module -- a full path to the shared library (e.g.
  /usr/lib/softhsm/libsofthsm.so or /usr/lib/softhsm/libsofthsm2.so
  for SoftHSM1 and SoftHSM2 respectively);
* TokenLabel -- the name of the token (as specified with the --label
  attribute when initializing SoftHSM)
* PIN -- the user PIN number (not the security officer PIN) to access
  the token store
Other arguments are often not necessary, refer to limited storage
capabilities and can be changed later.

When having installed OpenDNSSEC as root, but using it is non-root,
you should specify the unix user and group name to use.  This allows
for OpenDNSSEC to be started from a startup script on computer restart,
where it will be started with root privileges changing these to the right
credentials.  Failing to do so while still using OpenDNSSEC as root will
give very unexpected results.  Both Configuration/Enforcer/Privileges
and Configuration/Signer/Privileges need to be changed to the same
configuration to indicate the right unix user and group to use.

Configuration/Signer/WorkerThreads should be set to the number of
processor cores to use when signing.  Set this to parallelism available
in your PKCS#11 infrastructure for maximum performance.  When using
SoftHSM this will be equivalent to the number of processor cores.

Other parameters do not need changing at this time.  This gives you
a basic set-up with using file-based zone files without connecting to
other name servers.  It is good to be familiar with this set-up first.

## Initial configuration  addns.xml

File based zone-files without interfacing directly with other name
servers will not require anything from this configuration file.

## Initial configuration zonelist.xml

This file specifies pre-loading of zones.  We now strongly suggest NOT
editing this file yourself ever but using the command line interface to
add zones.  The sample zonelist.xml file should essentially be empty.

## Initial configuration kasp.xml

The key and signing policy file needs to be present and we advice to have
a policy named "default" in there.  The policy dictates how OpenDNSSEC
will behave, when to sign, how to sign, when to change signing keys,
etcetera.  Nearly all parameters will depend on your own needs, therefor
there are no true defaults or guidelines that can be given.

# First time initialization and first start-up

After a minimal of initial configuration, the enforcer database of
OpenDNSSEC needs initialization using:
    ods-enforcer-db-setup
Do not run this command as root when using an alternate user for
further use.

OpenDNSSEC can now be started using
    ods-control start
Policy, zonelist and PKCS#11 files are not loaded automatically.
Initially they need to be loaded using
    ods-enforcer update all

A common mistake would be to think that re-running ods-enforcer-db-setup
would reset the installation.  This is not true as there is still state
kept by the signer.

# Some notes on using SoftHSM

It is outside of the scope of OpenDNSSEC on how to install and
configure the PKCS#11 infrastructure.  Since SoftHSM may be used for
quick installations and testing purpose we provide some hints here.
Both SoftHSM versions 1 and 2 are suitable for OpenDNSSEC, where the
former is better tested at this time.

A common mistake is to initialize SoftHSM as root and then using it as
a different user.  This may give very unexpected results.

For SoftHSM2, when not using OpenDNSSEC as root, remember to change the
ownership of /var/lib/softhsm/tokens to the appropriate user, and have
the configuration file /etc/softhsm2.conf readable for this user.
First time initialization of the token store is performed using the
softhsm2-util command.

    chown -R ods:ods /etc/softhsm2.conf /var/lib/softhsm/tokens
    chmod -R ug+rwX,o-rwx /etc/softhsm2.conf /var/lib/softhsm/tokens
    chmod -R g+s /var/lib/softhsm/tokens
    sudo -u ods softhsm2-util --init-token --label OpenDNSSEC --pin 1234 --so-pin 0000 --slot 0

Note that failing to run softhsm2-util as user ods will give equal
unexpected results.  Token label and pin number will be referenced
from the opendnssec conf.xml configuration file, so these must match up.
You might want to store ZSKs and KSKs separately.  If so, perform multiple
initializations with unique labels and slots specified.

SoftHSM 2 is very picky in ownership of files.  This places a demand
on OpenDNSSEC, where you always need to start OpenDNSSEC daemons as the
target ods user.  So always use "sudo -u ods ods-control start"
Other commands may be given as any user that is member of group ods.

repository: opendnssec/opendnssec

branch_name: refs/heads/develop

gha_language: C

repo_name: opendnssec/opendnssec


text:
# July 2, 2017 — 0.2.0

- **[BREAKING_CHANGE]** Design usage around importing a generated
`app/styls/_ember-cli-savvy-css.css' file ([#8](https://github.com/savvy-css/ember-savvy-css/pull/8)).

# May 28, 2017 — 0.1.1

- **[PATCH]** Add check for presence of `vendorTree` in `treeForVendor` hook.

# May 28, 2017 — 0.1.0

- Bump to `0.1.0` to begin recommending usage.

# May 28, 2017 — 0.0.0

- Initial project setup.

repository: IcarusWorks/ember-savvy-css

repo_name: IcarusWorks/ember-savvy-css