text:
Webex SDK Component Adapter

Webex adapter to share SDK data with the components

**Webex SDK Adapter** is a library of adapters to provide live data from [Webex JavaScript SDK](https://github.com/webex/webex-js-sdk) to [Webex Components](https://github.com/webex/components).

## Table of Contents

- [Install](#install)
- [Usage](#usage)
- [Contributing](#contributing)
- [License](#license)
- [Support](#support)
- [Team](#team)

## Install

```bash
npm install --save @webex/components @webex/sdk-component-adapter
```

## Usage

### Components

For more information on how to use **Webex Components**, visit [this page](https://github.com/webex/components/blob/master/README.md).

Putting everything together - SDK adapters and components - this is a simple example of how using a component would look like:

```js
import<EMAIL_ADDRESS>
import React from 'react';
import ReactDOM from 'react-dom';
import Webex from 'webex';
import WebexSDKAdapter from '@webex/sdk-component-adapter';
import {WebexAvatar} from '@webex/components';

const webex = new Webex({
  credentials: <YOUR WEBEX ACCESS_TOKEN>,
});

const adapter = new WebexSDKAdapter(webex);

ReactDOM.render(
  <WebexDataProvider adapter={adapter} >
    <WebexAvatar personId="XYZ" />,
  </WebexDataProvider>
  document.getElementById('root')
);
```

_Happy Coding!_

## Contributing

We'd love for you to contribute to our source code and to make **Webex SDK Adapter** even better than it is today! Here are some [guidelines](https://github.com/webex/sdk-component-adapter/blob/master/CONTRIBUTING.md) that we'd like you to follow.

### Issues

Please open an [issue](https://github.com/webex/sdk-component-adapter/issues) and we will get to it in an orderly manner.
Please leave as much as information as possible for a better understanding.

### Contributing Code

We are using [Webex Style Guide eslint rule](https://github.com/webex/web-styleguide/tree/master/packages/node_modules/%40webex/eslint-config-react) and [prettier](https://github.com/prettier/prettier) to lint the code style.
You can "prettify" your code before committing via:

```bash
npm run prettier:write
```

### Release Process

There is a list of commit types provided [here](https://github.com/webex/sdk-component-adapter/blob/master/CONTRIBUTING.md#type). However, not all commits trigger our release process.
We are using [semantic-release](https://github.com/semantic-release/semantic-release) to fully automate the version management and package publishing.
By default `semantic-release` uses the [Angular Commit Message Conventions](https://github.com/angular/angular.js/blob/master/DEVELOPERS.md#-git-commit-guidelines) and triggers release and publishing based on the following rules:

| Commit                             | Release type  |
| ---------------------------------- | ------------- |
| Commit with type `BREAKING CHANGE` | Major release |
| Commit with type `feat`            | Minor release |
| Commit with type `fix`             | Patch release |
| Commit with type `perf`            | Patch release |

#### Commit linter

We are using [commitlint](https://github.com/conventional-changelog/commitlint) to lintify the commit messages.
Please make sure to choose the appropriate commit [type](https://github.com/webex/sdk-component-adapter/blob/master/CONTRIBUTING.md#type), [scope](https://github.com/webex/sdk-component-adapter/blob/master/CONTRIBUTING.md#scope) and [subject](https://github.com/webex/sdk-component-adapter/blob/master/CONTRIBUTING.md#scope).

## License

[MIT License](https://opensource.org/licenses/MIT)

## Support

For more developer resources, tutorials and support, visit the Webex developer portal, https://developer.webex.com.

## Team

| [![Adam Weeks](https://github.com/adamweeks.png?size=100)](https://github.com/adamweeks) | [![Arash Koushkebaghi](https://github.com/akoushke.png?size=100)](https://github.com/akoushke) | [![Lalli Flores](https://github.com/lalli-flores.png?size=100)](https://github.com/lalli-flores) | [![Timothy Scheuering](https://github.com/InteractiveTimmy.png?size=100)](https://github.com/InteractiveTimmy) | [![David Hoff](https://github.com/harborhoffer.png?size=100)](https://github.com/harborhoffer) | [![Taymoor Khan](https://github.com/taymoork2.png?size=100)](https://github.com/taymoork2) |
| ---------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------ |
| [Adam Weeks](https://github.com/adamweeks)                                               | [Arash Koushkebaghi](https://github.com/akoushke)                                              | [Lalli Flores](https://github.com/lalli-flores)                                                  | [Timothy Scheuering](https://github.com/InteractiveTimmy)                                                      | [David Hoff](https://github.com/harborhoffer)                                                  | [Taymoor Khan](https://github.com/taymoork2)                                               |

repository: adamweeks/sdk-component-adapter

repo_name: adamweeks/sdk-component-adapter


text:
aurae Build Container
---------------------

The Build Container is used to provide a build environment, that is consistent across different build hosts.
Currently the Build Container is derived from the official [Rust 1-bullseye Docker container](https://hub.docker.com/_/rust). It is used to build the Linux kernel, the auraed rust application and the initramfs.

All dynamically linked libraries, that will end up in the initramfs are sourced from this Build Container!
So if there's a vulnerability in the Build Container's libraries, it will also be in the final aurae initramfs!

You should care about keeping this container up to date!
Rebuild it from time to time using `make build-container`!

repository: aurae-runtime/aurae

branch_name: refs/heads/main

extension: md

gha_language: Rust

license_type: permissive

repo_name: aurae-runtime/aurae


text:
# selfbot

Welcome to my project!
I made this Discord selfbot in Node.js using Discord.js
You can use it for your own.

Requirements:

Node.js installed

---

If you have all requirements, hop over to the config.json file. When you are there, replace the "ownerID" with your user ID.
Replace the "token" with your token.
And if you want, you can change the prefix. You can always change this from Discord with `prefix`setprefix <new prefix here>.

---

How to start the bot:

1. First, install Node.js
2. Open now the file "install_requirements.bat"
3. Change the config.json file so it works for you
4. Now, open the file "launch.bat" and you are ready to go!
---

If you did everything correct, you will see this in your terminal:

Selfbot is online!
Prefix: `your setted prefix in the config file`

Logged in as: `your discord username#your discord discriminator`

Use: `your setted prefix in the config file`help

If you get any errors or if you have any problems/questions, feel free to open an issue. i will take asap contact with you and try to help you out. Questions about the code will I ignore. Problems that are listed here above will I ignore

Support server:

https://discord.gg/tcBpMJS

---

If you want to update your bot, do the following steps:

1. Delete the whole code of your selfbot.js

2. Copy the new code from here and paste it in your selfbot.js

3. Save your new selfbot.js code and you are ready to go!

license: Unlicense

repository: bryx-kun/selfbot-

branch_name: refs/heads/master

repo_name: bryx-kun/selfbot-


text:
# How ClearlyDefined determines the declared license

## Crawler
* OSS components are harvested by the [ClearlyDefined Crawler](https://github.com/clearlydefined/crawler)
* The Crawler uses 4 tools for harvest - ClearlyDefined itself, [Scancode](https://scancode-toolkit.readthedocs.io/en/latest/getting-started/home.html), [Licensee](https://github.com/licensee/licensee), and [Reuse](https://reuse.software/)
* See below for how it handles different types of components
* The Crawler then sends the harvest data to the ClearlyDefined Service

## Service
* The harvests are processed into definitions by the [ClearlyDefined Service](https://github.com/clearlydefined/service/tree/9e0a677a74c36c6ea276c4548b520b7c91db05ce)
* The service summarizes the data using the ClearlyDefined summarizer, Scancode summarizer, Licensee summarizer, and Reuse summarizer
* The ClearlyDefined summarizer does different things based on the component type, see below for how it handles different types of components
* The Scancode summarizer pulls any declared license information detected by Scancode (for more information, see the [code here](https://github.com/clearlydefined/service/blob/2d1e52caf5c07c3b6ef2565b5b77f1b677c82033/providers/summary/scancode.js))
* The Licensee summarizer pulls any declared license information detected by Licensee (for more information, see the [code here](https://github.com/clearlydefined/service/blob/master/providers/summary/licensee.js))
* The Reuse summarizer pulls any declared license information detected by Reuse (for more information, see the [code here](https://github.com/clearlydefined/service/blob/master/providers/summary/reuse.js))
* Then the ClearlyDefined service aggregates the information from the four tools - when there is conflicting information, the order of precedence is 'clearlydefined', 'reuse', 'licensee', 'scancode', 'cdsource'

## Curations
* If the declared license is changed through [the human curation process](https://github.com/clearlydefined/clearlydefined/blob/master/docs/curation-guidelines.md), the declared license in the curation will take precedence.

## Harvesting and Determining Declared License (by the ClearlyDefined Summarizer)

### npm
* source: https://www.npmjs.com
* The crawler pulls registry data for the component from https://registry.npmjs.com
* In the service, the ClearlyDefined summarizer parses license(s) from the registry data and sets them as the declared license

### gem
* source: https://rubygems.org
* The crawler pulls registry data for the component from https://rubygems.org
* The ClearlyDefined summarizer determines the declared license based on the license in the registry data

### pypi
* source: https://pypi.org
* First, the crawler pulls registry information from https://pypi.org [Code](https://github.com/clearlydefined/crawler/blob/f461b2358fbde130bcc5d183de01a4212c4cd66d/providers/fetch/pypiFetch.js#L42)
* It then extracts the declared license from the registry data [Code](https://github.com/clearlydefined/crawler/blob/f461b2358fbde130bcc5d183de01a4212c4cd66d/providers/fetch/pypiFetch.js#L71)
* The service uses the declared license set by the crawler

### maven
* sources https://mvnrepository.com/repos/central, https://maven.google.com/ and https://plugins.gradle.org/m2/

**maven central**

* The crawler downloads the maven artifact from maven.org
* The crawler then extracts all pom files from the artifact
* And then merges the poms (including all the licenses defined in the poms)
* The ClearlyDefined summarizer parses the merged poms and sets the declared license(s) based on that data

**google maven**

* The crawler gets pom files for the component from https://dl.google.com/android/maven2/
* It then merges the poms (including all the licenses defined in the poms)
* The ClearlyDefined summarizer parses the merged poms and sets the declared license(s) based on that data

**gradle plugin**

* The crawler gets pom files for the component from https://plugins.gradle.org/m2/
* It then merges the poms (including all the licenses defined in the poms)
* The ClearlyDefined summarizer parses the merged poms and sets the declared license(s) based on that data

### nuget
* source: https://www.nuget.org/
* The crawler gets registry information for the component from https://api.nuget.org
* If the registry information has a licenseExpression field, the ClearlyDefined summarizer sets the declared license to that license expression
* If the registry information has a licenseUrl field, the ClearlyDefined summarizer extracts the license from that license url and sets the declared license to the extracted license
* If the ClearlyDefined summarizer cannot extract the license from the license URL, it sets the declared license to NOASSERTION

**Checking for the packageEntries field**

* The ClearlyDefined summarizer then checks whether the registry information has a packageEntries field
* If it does not, it leaves the declared license as it is
* If it does have a packageEntries field, the ClearlyDefined summarizer creates a new definition with the files field set to those packageEntries

**Merging definitions**

* It then merges the definitions and, in the process, merges the declared licenses
* If the original definition (prior to the merge) has a declared license of 'OTHER', it sets the declared license (on the merged definition) to the license on the new definition
* Otherwise, it combines the original definition license and the new definition license with AND

### git
* sources: https://github.com and https://gitlab.com
* The crawler clones the repo for the component from either https://gitlab.com or https://github.com
* TODO - how is the declared license decided?

### crate
* source: https://crates.io/
* The crawler gets registry information from https://crates.io/api/v1/crates/
* The ClearlyDefined summarizer sets the declared license to the license(s) in the registry information

### deb
* source: http://ftp.debian.org/
* First, the crawler downloads a package file map from http://ftp.debian.org/debian/indices/package-file.map.bz2 and caches it (if there is not one already cached) for 8 hours [Code](https://github.com/clearlydefined/crawler/blob/f461b2358fbde130bcc5d183de01a4212c4cd66d/providers/fetch/debianFetch.js#L87)
* It then pulls the registry information for the particular component from that package map file [Code](https://github.com/clearlydefined/crawler/blob/f461b2358fbde130bcc5d183de01a4212c4cd66d/providers/fetch/debianFetch.js#L114)
* It then finds the relevant copyright URL from the registry information [Code](https://github.com/clearlydefined/crawler/blob/f461b2358fbde130bcc5d183de01a4212c4cd66d/providers/fetch/debianFetch.js#L295) [Example](https://metadata.ftp-master.debian.org/changelogs/main/0/0ad-data/0ad-data_0.0.17-1_copyright)
* It then pulls information from the copyright URL [Code](https://github.com/clearlydefined/crawler/blob/f461b2358fbde130bcc5d183de01a4212c4cd66d/providers/fetch/debianFetch.js#L306)
* And parses that information [Code](https://github.com/clearlydefined/crawler/blob/f461b2358fbde130bcc5d183de01a4212c4cd66d/providers/fetch/debianFetch.js#L320) to determine the declared license(s)
* The ClearlyDefined summarizer then parses the declared licenses and, if there is more than one, joins them with 'AND'

### debsrc
* source: http://ftp.debian.org/
* Appears to be the same as `deb`

### composer
* source: https://packagist.org/
* The crawler pulls registry information from https://repo.packagist.org/
* The ClearlyDefined summarizer then sets the declared license based on the registry information

### pod
* source: https://cocoapods.org/
* The service then sets the declared license based on the registry information
* The ClearlyDefined summarizer pulls registry information from 'https://raw.githubusercontent.com/CocoaPods/Specs/master

license: MIT

repository: clearlydefined/service

gha_language: JavaScript

gha_license_id: MIT

repo_name: clearlydefined/service


text:
# Setup OpenCGA on Azure
The following guide shows how to successfully configure OpenCGA on Azure using different storage engines. It sets up a single virtual machine with OpenCGA, Tomcat, MongoDB, Solr and Redis Cache. Optionally it also sets up an HDInsight HBase cluster with either Azure Storage or Azure DataLake.

## Deploy resources
Depending on what storage engine you want to use, several resources have to be created in Azure. Remember the username and password for each resources you create, as we have to ssh into the virtual machines to configure them later.

### OpenCGA Virtual Machine
The only required resource for a minimum working product is a virtual machine in Azure.

- Create a new resource
- Search for **Ubuntu Server 16.04 LTS** (18.04 is incompatible with MongoDB 3.x)
- For better performance, select a storage optimized VM (e.g. L8s or L16s)

### Azure DataLake (optional)
If you want to leverage Hadoop as a backend with DataLake instead of Azure Storage, DataLake needs to be deployed. DataLake is a bit more expensive, but more performant and required for large loads (+500TB)

- Create a new resource
- Search for **Data Lake Storage Gen1** (Gen2 might be available in the future)
- Make sure to deploy it in the same region as your OpenCGA VM

### Azure HDInsights - HBase (optional)
If you want to leverage OpenCGA's more performant Hadoop backend instead of MongoDB, you have to create an Azure HDInsight instance with HBase.

- Create a new resource
- Search for **HDInsight**
- Step 1: Click on the Custom tab (instead of Quick Create)
- Step 1: Select **HBase 1.1.2 (HDI 3.6)** as the Cluster type
- Step 1: Deploy it in the same region as your OpenCGA VM
- Step 2: Place it in the same Virtual Network as your OpenCGA VM (select the virtual network that the VM has created when it was deployed)
- Step 3: Configure Storage with either _Azure Storage_ or (optionally) the newly created _Data Lake Storage Gen1_ instance
- Step 5: Depending on the required performance any cluster size is possible from 2 region nodes with minimum specs to more nodes with higher specs

## Setup resources
After successfully deploying the resources, they have to be configured

### OpenCGA Virtual Machine
SSH into your machine (replace username and IP address)

```
ssh<EMAIL_ADDRESS>````

Install the latest updates
```
sudo apt-get update
sudo apt-get upgrade -y
```

Install Java SDK

```
sudo -- sh -c 'echo oracle-java8-installer shared/accepted-oracle-license-v1-1 select true | debconf-set-selections &&  add-apt-repository -y ppa:webupd8team/java &&  apt-get update &&  apt-get install -y oracle-java8-installer &&  rm -rf /var/lib/apt/lists/* &&  rm -rf /var/cache/oracle-jdk8-installer'
```

Install Redis, Tomcat, Maven and Git

```
sudo add-apt-repository universe && sudo apt-get update && sudo apt-get install redis-server redis-tools tomcat8 maven git-core -y
```

Install MongoDB 3.6

```
sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv 2930ADAE8CAF5059EE73BB4B58712A2291FA4AD5
echo "deb [ arch=amd64,arm64 ] https://repo.mongodb.org/apt/ubuntu xenial/mongodb-org/3.6 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-3.6.list
sudo apt-get update
sudo apt-get install -y mongodb-org
sudo systemctl enable mongod.service # start on boot
```

Install Solr

```
wget https://www-eu.apache.org/dist/lucene/solr/6.6.5/solr-6.6.5.tgz
tar xvfz solr-6.6.5.tgz
sudo ./solr-6.6.5/bin/install_solr_service.sh ./solr-6.6.5.tgz
```

Clone OpenCGA
```
git clone -b azure https://github.com/opencb/opencga.git
cd opencga/
```

**Option 1: Build OpenCGA with MongoDB**
```
mvn clean install -DskipTests
```

**Option 2: Build OpenCGA with Hadoop**
```
mvn clean install -DskipTests -Dstorage-hadoop -Popencga-storage-hadoop-deps -Phdp-2.6.5 -DOPENCGA.STORAGE.DEFAULT_ENGINE=hadoop
```

Move OpenCGA to `/opt/opencga`
```
sudo mkdir /opt/opencga
sudo cp -r ~/opencga/build/* /opt/opencga
```

Increase memory heap space for tomcat to avoid running out of memory
```
printf '#!/bin/sh\nexport CATALINA_OPTS="$CATALINA_OPTS -Xmx1024m"\nexport CATALINA_OPTS="$CATALINA_OPTS -Xms512m"' | sudo tee -a /usr/share/tomcat8/bin/setenv.sh
```

Create OpenCGA user and group to run Tomcat server
```
sudo service tomcat8 stop #stop tomcat to make changes
sudo addgroup opencga
sudo adduser -ingroup opencga --disabled-password --gecos "" opencga #create user opencga
sudo sed -i 's/=tomcat8/=opencga/' /etc/default/tomcat8 # change both user and group
sudo chown -R opencga:adm /var/log/tomcat8
sudo chown -R opencga:opencga /var/lib/tomcat8/webapps
sudo chown opencga:adm /var/cache/tomcat8
sudo chown -R opencga:opencga /var/cache/tomcat8/Catalina
sudo usermod -a -G tomcat8 opencga
sudo service tomcat8 start #start tomcat
```

Copy OpenCGA build to Tomcat server
```
sudo cp /opt/opencga/opencga*.war /var/lib/tomcat8/webapps/opencga.war
sudo chown -R tomcat8 /opt/opencga/ #give tomcat8 user ownership of opencga folder
sudo chmod -R 777 /opt/opencga/ #necessary to write in sessions folder
```

If you chose Hadoop as a backend, configure Tomcat to use this configuration:
```
sudo -- sh -c 'echo "<Context>\n\t<Resources>\n\t\t<PostResources className=\"org.apache.catalina.webresources.DirResourceSet\" webAppMount=\"/WEB-INF/classes\" base=\"/opt/opencga/conf/hadoop\" />\n\t</Resources>\n</Context>" >> /var/lib/tomcat8/conf/Catalina/localhost/opencga.xml'
```

Reboot VM to load your configuration
```
sudo reboot
```

### Azure HDInsight cluster (optional)
SSH into the HDInsight cluster (change domain name)
```
ssh<EMAIL_ADDRESS>```

Change hbase.client.keyvalue.maxsize to 0 in `/etc/hbase/conf/hbase-site.xml` on hadoop cluster to avoid 'KeyValue size too large' error
```
sudo sed -i '/<name>hbase.client.keyvalue.maxsize<\/name>/!b;n;c<value>0</value>' /etc/hbase/conf/hbase-site.xml
```

Copy required Hadoop and HBase configuration files to the OpenCGA Virtual Machine (change username & IP address)
```
sudo scp -r /etc/hadoop/conf/* azure@139.349.12.49:/opt/opencga/conf/hadoop
sudo scp -r /etc/hbase/conf/* azure@139.349.12.49:/opt/opencga/conf/hadoop
```

repository: opencb/opencga

branch_name: refs/heads/develop

gha_language: Java

repo_name: opencb/opencga


text:
# Screen Corner
Redesign your mobile screen corner by various styles.

FEATURES:

✔ Enable or disable rounded corners screen decorator app's functionality at any time.

✔ Rounds - Awesome Screen Corner is able to decorate lockscreen corners.

✔ Able to adjust the radius of the rounded corners.

✔ Able to specify which corners to round | rounded : top left, top right, bottom left, bottom right.

✔ Rounds - Awesome Screen Corner allow to overlapp corners of the status bar.

✔ Corners screen decorator decorate your touchscreen with many free corner’s styles

repository: MaTriXy/screen-corner

repo_name: MaTriXy/screen-corner


text:
## VirtualPhoneNumber
**free virtual numbers, right now!**
**For starters, look below, there will be sites with working and free virtual numbers!**

- **SmsActivator.ru**
- **sms-online.co/receive-free-sms**
- **receive-sms-online.info**
- **receivefreesms.com**
- **www.proovl.com/ru/test**
- **www.proovl.com/ru/numbers**
- **receive-smss.com**
- **freephonenum**
- **www.receiveasms.com**
- **www.freeonlinephone.org**
- **www.receivesms.org**
- **sms-receive.net**

## Supporters
[![Stargazers repo roster for @mishakorzik/VirtualPhoneNumber](https://reporoster.com/stars/mishakorzik/VirtualPhoneNumber)](https://github.com/mishakorzik/VirtualPhoneNumber/stargazers)
[![Forkers repo roster for @mishakorzik/VirtualPhoneNumber](https://reporoster.com/forks/mishakorzik/VirtualPhoneNumber)](https://github.com/mishakorzik/VirtualPhoneNumber/members)


text:
# .NET Reflector Plugins
As and when I create them, this is a repo where I'll keep plugins for .NET Reflector.

| Plugin | Description |
| ------ | ----------- |
| ReorderAssemblies | Reorder the assemblies in the list so they're alphabetical with System ones at the top. |

repository: bubdm/ReflectorPlugins

repo_name: bubdm/ReflectorPlugins


text:
# Monitor

![](https://i.imgur.com/iYqVRRM.png)

[Science](https://en.wikipedia.org/wiki/Science) wouldn't work if we ran experiments but didn't bother to record the results. Same goes for governance. There needs to be a [feedback loop](https://en.wikipedia.org/wiki/Feedback) between decisions and results. Monitoring allows you to verify the results of decisions to see if they had their intended effects.

If a proposal succeeds you'll want to see if it actually has the effect you intended. If so, then great. If not, then figure out why.

If a proposal doesn't succeed that's OK too. If you had a hypothesis of what will happen if your proposal does not pass then you can validate that. This can provide data to support your original proposal, potentially allowing you to resubmit a modified version with more evidence (*"I told you so!"*).

Monitoring complex systems is a lot of work, but there's tools that can help. You'll probably want to automate things like feeding raw data into recurring model runs and alerts based on key metrics - and you'll probably want to manually read community discussions to understand context and sentiment. Analysis of both objective data and subjective social activity are important to understand the global view of a system. One without the other is likely to lead to a [local optimum](https://en.wikipedia.org/wiki/Local_optimum).

## Concepts

### Success

If the proposal passes monitor the relevant metrics to ensure it behaves as expected. If not, suggest ways to adjust accordingly.

### Iteration

If the proposal does not pass still monitor the relevant metrics to see if your prediction holds (then you can say "I told you so" and/or give your proposal another go if it's still relevant).

## Tools

### Automated Alerts

If possible setup automated alerts for activity that matters in the context of a proposal. This way you can know if expected milestones/thresholds/etc were reached and/or what performance looks like.

### Recurring Runs

If you can get a raw data-feed from the system, you might be able to pipe that into your model and setup recurring runs. This would regularly pull new data into the model and run it to see if anything changed. This can provide more detailed insights than simple metrics. You'll also be able to modify the model to explore potential future scenarios based on new updates.

### Manual

Not all data is packaged in a convenient numerical format. Sometimes you need to also review human readable proposals and/or gauge sentiment on community forums and chats. This can sometimes provide insight related to the satisfaction and/or desires of stakeholders. This is important because governance proposals determine how resources are distributed between stakeholders so even if the results are technically what was expected, if stakeholders are unhappy then it's important to understand why and take that into consideration.

## Notes

```
MOTIVATION
- feedback

CONCEPTS
- success
- failure

TOOLS
- automated alerts
- recurring runs
- manual review
```

repository: Blazingthirdeye/cag-map

repo_name: Blazingthirdeye/cag-map


text:
# vlt.signal.xcorr_discrete

```
  XCORR_DISCRETE - Calculate the cross-correlation between two signals without FFT

   XC = vlt.signal.xcorr_discrete(SIGNAL1, SIGNAL2, N, NORMSTRING)

   Computes the cross-correlation between SIGNAL1 and SIGNAL2 for lags up to N.

   If NORMSTRING is left off, then the correlation is not normalized.
   Otherwise it is normalized according to the following values of NORMSTRING:
     'none' : no normalization
    'biased': divides by length of SIGNAL1
  'unbiased': divides by the absolute value of length of SIGNAL - LAG

```

repository: VH-Lab/vhlab-toolbox-matlab

gha_language: MATLAB

repo_name: VH-Lab/vhlab-toolbox-matlab


text:
# CAP examples

A repository of examples of what can be done with Caselaw Access Project data.
- [CAP Github repo](https://github.com/harvard-lil/capstone)
- [CAP homepage](https://case.law/)

## Table of Contents
- [Examples](#examples)
- [Contributing instructions](#interested-in-contributing-your-own-examples)
- [Download bulk data](#downloading-bulk-data)
- [Using the API](#using-the-api)
- [Installation Instructions](#install) - install this repo to run examples on your own machine

## Examples
- [Bulk Case Extract](bulk_extract/extract_cases.ipynb) - Get cases from our api's /bulk endpoint. Extract cases into a dataframe.
- [Full Text Search](full_text_search/full_text_search.ipynb) - Get all cases that include a keyword.
- [Full Text Search with Context](api_text_search/api_text_search.py) - Like full text search, only this time using your API key to get the context around the word.
- [Ngrams](ngrams/ngrams.ipynb) – Use the open Arkansas bulk cases to explore interesting words.
- [Bulk Exploration: ngrams and Justice Cartwright](bulk_exploration/cartwright.ipynb) – Use the open Illinois bulk cases to explore interesting words, and look at a Judge's opinion publishing history.
- [Map Courts](map_courts/map_courts.ipynb) - Map all the courts on a U.S. map.
- [Python Wrapper](python_wrapper/cap.py) - Python wrapper for searching cases, downloading to CSV, etc.
- [Get Judges](get_judges/get_judges.ipynb) - Get judges and return [CourtListener Person urls](https://www.courtlistener.com/api/rest/v3/people/?name_last=Pregerson&name_first=Harry)
- [API to CSV](api_to_csv/api_to_csv.py) - Command line Python3 script with no external dependencies, fetching search results from the cases endpoint and writing to a CSV.
- [Labelling case parties and summarizing cases](labelling_summarizing/labelling_summarizing.ipynb) - Using some basic machine learning to label who the parties in each case were, and then summarizing the case text.

## Interested in contributing your own examples?
1. Fork this repository
2. Add your work
3. Make sure to add any requirements your project needs to [requirements.in](requirements.in)
4. Run ```pip-compile --output-file requirements.txt requirements.in```
5. Add a link in the [Examples section](#examples)
6. Create a [pull request](https://github.com/harvard-lil/cap-examples/compare)
7. Receive gratitude (thank you so much!!)

## Downloading bulk data

#### Helper methods to download whitelisted bulk data
Download the Illinois dataset
```
(capexamples) $ fab get_cases_from_bulk:Illinois
```

Or, download the Arkansas dataset
```
(capexamples) $ fab get_cases_from_bulk:Arkansas
```

Download a dataset with casebody format as xml
```
(capexamples) $ fab get_cases_from_bulk:Illinois,data_format=xml
```

## Using the API
[Read our API documentation.](https://case.law/api/)

In order to download [non-whitelisted](https://case.law/api/#limits) cases, you must [register for an API key](https://case.law/user/register/).

Once you have your API key, copy and paste it into your secret keys file [settings.py](config/settings.py).

## Install
`3.5.4` is the python version we're currently using on CAP, so to keep things simple, we'll be using the same version for these examples.

We recommend installing pyenv — [follow instructions to install here](https://github.com/pyenv/pyenv).

Install your python version using pyenv and activate your virtual environment:
```
$ pyenv install 3.5.4
$ pyenv virtualenv 3.5.4 capexamples
$ pyenv activate capexamples
(capexamples) $
```

Set up!
```
(capexamples) $ pip install -r requirements.txt
(capexamples) $ fab setup
```

To run jupyter notebook examples (i.e. any file ending in .ipynb):
```
(capexamples) $ jupyter notebook
```

repository: anastasia/cap-examples

repo_name: anastasia/cap-examples


text:
<img src="https://raw.github.com/Loganair/aws-sftp/master/images/loganair.png" alt="Logo" width="300">

# AWS Secure File Transfer Protocol (SFTP)

## WinSCP Setup

WinSCP is a free Windows-based SFTP client that should be used to upload and download files from the SFTP server. It can be obtained from the [WinSCP site](https://winscp.net/eng/download.php).

After WinSCP is installed it should be configured with the settings detailed in the sections below. All configuration steps will be described from the "Login (New Site)" dialog box.

![WinSCP Login](https://raw.github.com/Loganair/aws-sftp/master/images/winscp-login.png)

### Timestamp settings

Storage for AWS SFTP is provided by Amazon Simple Storage Service (S3) which does not support manually setting file timestamps. To prevent an `The server does not support the operation. SETSTAT unsupported` error when uploading files, the WinSCP "Preserve timestamp" setting should be disabled:

1. Click "Tools" then "Preferences..."
2. In the preferences dialog box, click "Transfer".
3. Ensure "**Default**" is selected in "Transfer settings presets" and click "Edit..."
4. Uncheck "Preserve timestamp" under "Common options".
5. Click "Ok" twice.

![Timestamp Settings](https://raw.github.com/Loganair/aws-sftp/master/images/timestamp-settings.png)

### Private key settings

Public key cryptography is used to authenticate users to the SFTP server instead of passwords. To set the private key for the account, do the following:

1. Click "Advanced" under the Password box.
2. Choose SSH > Authentication.
3. Click the "..." icon next to the "Private key file" box.
4. Browse to the location of the private key file (\*.ppk) and choose "Open".
5. Click "Ok" to return to the Login dialog box.

![Advanced Settings](https://raw.github.com/Loganair/aws-sftp/master/images/advanced-settings.png)

### Server settings

Once the timestamp and private key settings have been configured, the server details should be entered and saved so subsequent logins will not require any typing.

Enter the following details in the "Login (New Site)" dialog box then click "Save":

```Shell
File protocol: SFTP
Host name: sftp.loganair.co.uk
Port number: 22
User name: <the user name given to you>
Password:
```

In the "Save session as site" dialog box, Enter "Loganair SFTP" as the "Site name" and click "Ok".

For subsequent logins, the user can simply choose the saved "Loganair SFTP" site on the left-hand side and then click "Login".

## Server Building

The SFTP server is build entirely via [Terraform](https://terraform.io).

When building or altering the SFTP server configuration the following variables should be set in your PowerShell session. For obvious reasons the required values are detailed elsewhere.

```shell
$Env:AWS_ACCESS_KEY_ID="<aws id>"
$Env:AWS_SECRET_ACCESS_KEY="<aws key>"
$Env:TF_VAR_cloudflare_email="<cloudflare account>"
$Env:TF_VAR_cloudflare_token="<cloudflare api key>"
```

A simple `terraform apply` in the same directory as the code will build or alter the configuration as required.

repository: Loganair/aws-sftp

repo_name: Loganair/aws-sftp


text:
[![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=BenWibking_TwoMomentRad&metric=alert_status&token=5049c56ffe08dcc83afd5ca4c8e0d951a2836652)](https://sonarcloud.io/dashboard?id=BenWibking_TwoMomentRad)
[![Bugs](https://sonarcloud.io/api/project_badges/measure?project=BenWibking_TwoMomentRad&metric=bugs&token=5049c56ffe08dcc83afd5ca4c8e0d951a2836652)](https://sonarcloud.io/dashboard?id=BenWibking_TwoMomentRad)
[![Lines of Code](https://sonarcloud.io/api/project_badges/measure?project=BenWibking_TwoMomentRad&metric=ncloc&token=5049c56ffe08dcc83afd5ca4c8e0d951a2836652)](https://sonarcloud.io/dashboard?id=BenWibking_TwoMomentRad)
[![AMReX](https://amrex-codes.github.io/badges/powered%20by-AMReX-red.svg)](https://amrex-codes.github.io)
[![yt-project](https://img.shields.io/static/v1?label="works%20with"&message="yt"&color="blueviolet")](https://yt-project.org)

# Quokka
*Quadrilateral, Umbra-producing, Orthogonal, Kangaroo-conserving Kode for Astrophysics!*

**The Quokka methods paper is now available: https://arxiv.org/abs/2110.01792**

**NOTE: The code documentation is still a work in progress. Please see the Installation Notes below. You can start a [Discussion](https://github.com/BenWibking/quokka/discussions) for technical support, or open an [Issue](https://github.com/BenWibking/quokka/issues) for any bug reports.**

Quokka is a two-moment radiation hydrodynamics code that uses the piecewise-parabolic method, with AMR and subcycling in time. Runs on CPUs (MPI+vectorized) or NVIDIA GPUs (MPI+CUDA) with a single-source codebase. Written in C++17. (100% Fortran-free.)

...with advanced Adaptive Quokka Refinement:tm: technology:

![Image of Quokka with Baby in Pouch](extern/quokka2.png)

## Installation Notes

To run Quokka, download this repository to your local machine:
```
git clone git@github.com:BenWibking/quokka.git
```
Then download all submodules (this downloads `AMReX` and the string-formatting library `fmt`):
```
cd quokka
git submodule update --init
```
Create a build/ subdirectory and compile Quokka:
```
mkdir build; cd build
cmake .. -DCMAKE_BUILD_TYPE=Release
make -j6
```
Congratuations! You have now built all of the 1D test problems on CPU. You can run the automated test suite:
```
make test
```
You should see output that indicates all tests have passed, like this:
```
100% tests passed, 0 tests failed out of 20

Total Test time (real) = 111.74 sec
```
To run in 2D or 3D, edit the `AMReX_SPACEDIM` option in the `CMakeLists.txt` file, for example:
```
set(AMReX_SPACEDIM 3 CACHE STRING "" FORCE)
```
to compile Quokka for 3D problems.

Have fun!

## Running on GPUs
By default, Quokka compiles itself to run only on CPUs. If you want to run on NVIDIA GPUs, re-build Quokka with the following options:
```
cmake .. -DCMAKE_BUILD_TYPE=Release -DAMReX_GPU_BACKEND=CUDA
make -j6
```
The compiled test problems are in the test problem subdirectories in `build/src/`. Example scripts for running Quokka on compute clusters are in the `scripts/` subdirectory. Please note that you must configure your compute cluster to run with 1 MPI rank per GPU in order for Quokka to work correctly. Quokka is only supported on Volta-class (V100) GPUs or newer.

**AMD or Intel GPUs:** Running on AMD or Intel GPUs is currently experimental and has *not been tested* by the Quokka developers. AMReX is currently undergoing rapid advances in its support for GPUs from these vendors, so please get in touch by starting a Discussion before attempting this.

## Problems?
If you run into problems, please start a [Discussion](https://github.com/BenWibking/quokka/discussions) for technical support. If you discover a bug, please let us know by opening an [Issue](https://github.com/BenWibking/quokka/issues).


text:
---
id: test-projects
title: "Projects"
---

A project is logical group of tests running with the same configuration. We use projects so we can run tests on different browsers and devices. Projects are configured in the `playwright.config.ts` file and once configured you can then run your tests on all projects or only on a specific project. You can also use projects to run the same tests in different configurations. For example, you can run the same tests in a logged-in and logged-out state.

By setting up projects you can also run a group of tests with different timeouts or retries or a group of tests against different environments such as staging and production, splitting tests per package/functionality and more.

## Configure projects for multiple browsers

By using **projects** you can run your tests in multiple browsers such as chromium, webkit and firefox as well as branded browsers such as Google Chrome and Microsoft Edge. Playwright can also run on emulated tablet and mobile devices. See the [registry of device parameters](https://github.com/microsoft/playwright/blob/main/packages/playwright-core/src/server/deviceDescriptorsSource.json) for a complete list of selected desktop, tablet and mobile devices.

```js
import { defineConfig, devices } from '@playwright/test';

export default defineConfig({
  projects: [
    {
      name: 'chromium',
      use: { ...devices['Desktop Chrome'] },
    },

    {
      name: 'firefox',
      use: { ...devices['Desktop Firefox'] },
    },

    {
      name: 'webkit',
      use: { ...devices['Desktop Safari'] },
    },

    /* Test against mobile viewports. */
    {
      name: 'Mobile Chrome',
      use: { ...devices['Pixel 5'] },
    },
    {
      name: 'Mobile Safari',
      use: { ...devices['iPhone 12'] },
    },

    /* Test against branded browsers. */
    {
      name: 'Microsoft Edge',
      use: {
        ...devices['Desktop Edge'],
        channel: 'msedge'
      },
    },
    {
      name: 'Google Chrome',
      use: {
        ...devices['Desktop Chrome'],
        channel: 'chrome'
      },
    },
  ],
});
```

## Run projects

Playwright will run all projects by default.

```bash
npx playwright test

Running 7 tests using 5 workers

  ✓ [chromium] › example.spec.ts:3:1 › basic test (2s)
  ✓ [firefox] › example.spec.ts:3:1 › basic test (2s)
  ✓ [webkit] › example.spec.ts:3:1 › basic test (2s)
  ✓ [Mobile Chrome] › example.spec.ts:3:1 › basic test (2s)
  ✓ [Mobile Safari] › example.spec.ts:3:1 › basic test (2s)
  ✓ [Microsoft Edge] › example.spec.ts:3:1 › basic test (2s)
  ✓ [Google Chrome] › example.spec.ts:3:1 › basic test (2s)
```

Use the `--project` command line option to run a single project.

```bash
npx playwright test --project=firefox

Running 1 test using 1 worker

  ✓ [firefox] › example.spec.ts:3:1 › basic test (2s)
```

The VS Code test runner runs your tests on the default browser of Chrome. To run on other/multiple browsers click the play button's dropdown from the testing sidebar and choose another profile or modify the default profile by clicking **Select Default Profile** and select the browsers you wish to run your tests on.

Choose a specific profile, various profiles or all profiles to run tests on.

## Configure projects for multiple environments

By setting up projects we can also run a group of tests with different timeouts or retries or run a group of tests against different environments. For example we can run our tests against a staging environment with 2 retries as well as against a production environment with 0 retries.

```js title="playwright.config.ts"
import { defineConfig } from '@playwright/test';

export default defineConfig({
  timeout: 60000, // Timeout is shared between all tests.
  projects: [
    {
      name: 'staging',
      use: {
        baseURL: 'staging.example.com',
      },
      retries: 2,
    },
    {
      name: 'production',
      use: {
        baseURL: 'production.example.com',
      },
      retries: 0,
    },
  ],
});
```

## Splitting tests into projects

We can split tests into projects and use filters to run a subset of tests. For example, we can create a project that runs tests using a filter matching all tests with a specific file name. We can then have another group of tests that ignore specific test files.

Here is an example that defines a common timeout and two projects. The "Smoke" project runs a small subset of tests without retries, and "Default" project runs all other tests with retries.

```js title="playwright.config.ts"
import { defineConfig } from '@playwright/test';

export default defineConfig({
  timeout: 60000, // Timeout is shared between all tests.
  projects: [
    {
      name: 'Smoke',
      testMatch: /.*smoke.spec.ts/,
      retries: 0,
    },
    {
      name: 'Default',
      testIgnore: /.*smoke.spec.ts/,
      retries: 2,
    },
  ],
});
```
## Dependencies

Dependencies are a list of projects that need to run before the tests in another project run. They can be useful for configuring the global setup actions so that one project depends on this running first. When using project dependencies, [test reporters](./test-reporters.md) will show the setup tests and the [trace viewer](/trace-viewer.md) will record traces of the setup. You can use the inspector to inspect the DOM snapshot of the trace of your setup tests and you can also use [fixtures](./test-fixtures.md) inside your setup.

In this example the chromium, firefox and webkit projects depend on the setup project.

```js title="playwright.config.ts"
import { defineConfig } from '@playwright/test';

export default defineConfig({
  projects: [
    {
      name: 'setup',
      testMatch: '**/*.setup.ts',
    },
    {
      name: 'chromium',
      use: { ...devices['Desktop Chrome'] },
      dependencies: ['setup'],
    },
    {
      name: 'firefox',
      use: { ...devices['Desktop Firefox'] },
      dependencies: ['setup'],
    },
    {
      name: 'webkit',
      use: { ...devices['Desktop Safari'] },
      dependencies: ['setup'],
    },
  ],
});
```
### Running Sequence

When working with tests that have a dependency, the dependency will always run first and once all tests from this project have passed, then the other projects will run in parallel.

Running order:
1. Tests in the 'setup' project run. Once all tests from this project have passed, then the tests from the dependent projects will start running.

2. Tests in the 'chromium', 'webkit' and 'firefox' projects run together. By default, these projects will [run in parallel](./test-parallel.md), subject to the maximum workers limit.

If there are more than one dependency then these project dependencies will be run first and in parallel. If the tests from a dependency fails then the tests that rely on this project will not be run.

Running order:
1. Tests in the 'Browser Login' and 'DataBase' projects run in parallel:
  - 'Browser Login' passes
  - ❌ 'DataBase' fails!

1. The 'e2e tests' project is not run!

### Teardown

You can also teardown your setup by adding a [`property: TestProject.teardown`] property to your setup project. Teardown will run after all dependent projects have run. See the [teardown guide](./test-global-setup-teardown.md#teardown) for more information.

## Custom project parameters

Projects can be also used to parametrize tests with your custom configuration - take a look at [this separate guide](./test-parameterize.md#parameterized-projects).

repository: microsoft/playwright

gha_language: TypeScript

repo_name: microsoft/playwright


text:
# BioWorkbench

This repository contains a Docker recipe for the construction of BioWorkbench, a high-performance framework for managing and analyzing bioinformatics experiments.

Each experiment comprises a set of activities to be executed in a chained way, also known as workflows. Thus, they were modeled and defined using the Swift, a scientific workflow management system that allows them to run in high-performance computing environments.

The Docker recipe contains all the programs and configurations required to run the following workflows:

* SwiftGecko: https://github.com/mmondelli/swift-gecko

* SwiftPhylo: https://github.com/mmondelli/swift-phylo

* RASflow: https://github.com/mmondelli/rasflow

Please refer to the links above for a better description of each of the experiments, as well as instructions for their execution.

To build an image from the Dockerfile you can run (assuming you are inside the directory where the file is located):

```
docker build -t bioworkbench:latest .
```

To run a container for this image, you can run:

```
docker run --rm -p 3837:3838 --name bio bioworkbench:latest
```

And with this you can access a web interface to analyze the provenance of the workflows executed through the address:
http://localhost:3837/workbench

This interface provides a menu where it is necessary to inform which workflow will be analyzed (Script name). When choosing a date range (Date range), the field below (Script ID) will list all the identifiers of each execution of this workflow performed during the reported period. The user must then choose one of these options and click on the Update button. The analyses presented on the right side will be updated according to the chosen workflow execution.

To run the experiments and other commands in the running container, you can use (from another terminal):

```
docker exec -ti bio /bin/bash
```

This Dockerfile is also configured for automatic build in [this Docker hub repository](https://hub.docker.com/r/malumondelli/bioworkbench). Thus, you can use the pull command to get the BioWorkbench image:

```
docker pull malumondelli/bioworkbench
```

repository: mmondelli/bioworkbench

repo_name: mmondelli/bioworkbench


text:
# HOPE
Approximate inference for MRF based on ECC

# Disclaimer
The project has only been tested on Ubuntu 12.04

# Prerequisites
CPLEX

LocalSolver: sign up at http://www.localsolver.com. You can download the library .jar file. There is a hard cap on the problem size for trial license. You can also apply for academic license.

Eclipse (or any Java IDE that supports Eclipse's project configuration, ex: IntelliJ IDEA)

# Setup
git clone https://github.com/pjiangtw/HOPE.git

Open Eclipse. Import project.

Modify "Config.java", specifically the variable: public static final String output = "/home/jp/output/" (You should create a work folder anywhere you like and point this variable to the folder.)

Import localsolver.jar by modifying Java build path. In Eclipse, you can right click on the project, select "Properties", and choose "Java Build Path".

# Running
An example can be seen in the main() function in Hope.java:

		Hope hope = new Hope();
		RunParams params = new RunParams(30, ConstraintType.PARITY_CONSTRAINED,
				CodeType.PEG, SolverType.CPLEX);
		double est = hope.fastRun("/home/user/test.uai", 7, params);

Some notes on the parameter:

		RunParams params = new RunParams(30 [timeout in seconds], ConstraintType.PARITY_CONSTRAINED[what type of constraints to use],
				CodeType.PEG[what code to use], SolverType.CPLEX[what solver to use]);

		double est = hope.fastRun("/home/user/test.uai"[path to .uai file], 7 [how many optimization instances per quantile], params);

Therefore, for CPLEX+Parity(PEG LDPC), one can use:

		Hope hope = new Hope();
		RunParams params = new RunParams(30, ConstraintType.PARITY_CONSTRAINED,
				CodeType.PEG, SolverType.CPLEX);
		double est = hope.fastRun("/home/user/test.uai", 7, params);

Similarly, for LocalSolver+affine map(Unconstrained), one can use

		Hope hope = new Hope();
		RunParams params = new RunParams(30, ConstraintType.UNCONSTRAINED,
				CodeType.PEG, SolverType.LocalSolver);
		double est = hope.fastRun("/home/user/test.uai", 7, params);

If one would like to use LDPC for large domain and affine map for low domain to get the best of both worlds, as recommended,

		Hope hope = new Hope();
		RunParams params = new RunParams(30, ConstraintType.TWO_THIRD,
				CodeType.PEG, SolverType.BY_CONSTRAINTS);
		double est = hope.fastRun("/home/user/test.uai", 7, params);

In this case, if the code rate r is greater than or equal to 2/3, CPLEX+Parity will be used. Otherwise, the base solver will be switched to LocalSolver+affine map. If we would like to switch between solvers automatically based on optimization performance, instead of using a fixed switch point, we can change the constraint type to "ConstraintType.GO_WITH_THE_BEST".

# Interface with CPLEX
The interface with CPLEX is adapted from the source code of the UAI version of WISH. A modified version has been packaged under the folder "WishCplex". Here we modify the WishCplex by providing a few additional arguments:

-skipelim: if provided, WishCplex will skip Gaussian elimination. For LDPC it is recommended to skip Gaussian elimination as the elimination process will impair the structure of parity matrix.

-matrix [parity matrix]: We also provide the option to specify a parity matrix for WishCplex to use. The parity matrix is expressed in the following format:

00111_10110_01000

where "_" is used as the row delimiter. This string represents a parity matrix of 5 variables and 3 checks.

We can use the following command to invoke WishCplex on the problem "test.uai" with a 30-second timeout, 3 checks
and the parity matrix 00111_10110_01000

WH_cplex -paritylevel 1 -timelimit 30(timeout in seconds) -number 3(number of checks) -skipelim -matrix 00111_10110_01000 /home/user/test.uai

# A quick guide to the source code

Hope.java: the core of the inference algorithm. It will choose which quantile to estimate and generate optimization instances.

RunParams.java: the class to hold the parameters (timeout, solver, constraint type,...etc). It also provide the function to generate an optimization instance based on the parameters.

CplexInstance: a Cplex optimization instance. It will invoke the WishCplex and provide a desired parity matrix.

LSInstance: a LocalSolver optimization instance. It will parse the .uai file and convert the problem into LocalSolver format.

The aforementioned files constitute the core of this project. The rest are mostly helpers.


text:
# Azure Kubernetes Service (AKS) - Hands-on Lab Script

Mark Harrison : 27 Nov 2017, last update 24 Sep 2018

![](Images/AKS.png)

- [Part 1 - Azure Kubernetes Service (AKS)](aks-1.md) ... this document
- [Part 2 - Helm Package Management](aks-2.md)
- [Part 3 - Monitoring Kubernetes](aks-3.md)

## Overview

Azure Container Service (ACS) allows you to quickly deploy a production ready Kubernetes, DC/OS, or Docker Swarm cluster.

AKS provides a fully managed Kubernetes based ACS cluster - it reduces the complexity and operational overhead of managing a Kubernetes cluster by offloading much of that responsibility to the Azure platform.

## Create AKS instance

All Azure resources must reside with an Azure resource group.

- Invoke the following:
  - Amend the resource group name to that required - and in the subsequent instructions
  - Amend the location to that require (check AKS is available in the region)

```text
az login
az group create --name AKS-rg --location westeurope
az configure --defaults group=AKS-rg
```

A couple of useful commands to check what regions support AKS and what versions of Kubernetes are available at a specific location

```text
az provider show --namespace Microsoft.ContainerService `
                 --query "resourceTypes[?resourceType=='managedClusters'].locations | [0]"

az aks get-versions -l westeurope -o table
```

We can now create an AKS instance using the `az aks create` command.

- Invoke the following:
  - Amend the AKS name to that required - and in the subsequent instructions
  - Amend the Kubernetes version to that required

```text
 az aks create --name markaks --generate-ssh-keys --kubernetes-version 1.9.6
```

![](Images/AKSCreate.png)

## Connect to cluster

The Kubernetes command-line tool, kubectl, is used to deploy and manage applications on Kubernetes.

- If kubectl is not installed, then invoke the following:

```text
az aks install-cli
```

To configure kubectl to connect to out Kubernetes cluster, invoke the following:

```text
az aks get-credentials --name markaks

kubectl config view
kubectl config current-context
```

![](Images/AKSGetCredentials.png)

- To display the Kubernetes dashboard, invoke the following:

```text
kubectl create clusterrolebinding kubernetes-dashboard --clusterrole=cluster-admin `
                                    --serviceaccount=kube-system:kubernetes-dashboard

az aks browse --name markaks
```

- If using the cloud shell then append `--enable-cloud-console-aks-browse`:

```text1
az aks browse --name markaks --enable-cloud-console-aks-browse
```

![](Images/AKSDashboard.png)

![](Images/AKSDashboard2.png)

Other commands to show connection to the cluster:

```text
kubectl cluster-info
kubectl get nodes
kubectl get deployments --all-namespaces
kubectl get pods --all-namespaces
kubectl get svc --all-namespaces
az aks list -o table
```

## Deployments

The next task is to deploy our container and enable a service.  This will be a Web API application pulled from a container registry.

- Invoke the following:

```text
kubectl get deployments

kubectl run colorapi --image=markharrison/colorapi:v1 --port=80
```

![](Images/AKSRun.png)

![](Images/AKSRun2.png)

Expose the service, invoke the following:

```text
kubectl expose deployment colorapi --type="LoadBalancer" --port=80

kubectl get services --watch
```

![](Images/AKSExpose.png)

![](Images/AKSExpose2.png)

- Browse to the assigned URL (append `/swagger`) e.g. <http://<IP_ADDRESS>:80/swagger>

- This is V1 of the container - note that the RandomColor API returns a random shade of green.

![](Images/AKSDeployedService.png)

Alternatively, can we can deploy the service from within the kubernetes dashboard:

- Select [Create] top right
- Specify App name - and docker image (ColorApi) to pull
- Check logs

![](Images/AKSDeploymentDB1.png)

![](Images/AKSDeploymentDB2.png)

![](Images/AKSDeploymentDB3.png)

![](Images/AKSDeploymentDB4.png)

![](Images/AKSDeploymentDB5.png)

## Scale

To scale up the service, we can increase the number of pods.

- Invoke the following:

```text
kubectl get pods

kubectl scale deployment colorapi --replicas=3

kubectl get pods
```

![](Images/AKSScale.png)

![](Images/AKSScaleDB.png)

## Resilience

Lets see what happens when a Pod dissapears.

- Invoke the following

```text
kubectl get pods

kubectl delete pod <pod-id>

kubectl get pods
```

![](Images/AKSKillPod.png)

- Notice that a new Pod is started, so that the number of pods remains at the required level

## Update

To update the service to a new version of the sofware, we can update the deployment definition.

- Invoke the following:

```text
kubectl edit deployment colorapi
```

- Edit the container image to point to V2 - save the file

![](Images/AKSUpdate.png)

- Browse to the service - same URL as before
- Note that V2 of the RandomColor API returns a random shade of blue (from above, it was previously shades of green).

![](Images/AKSDeployedService2.png)

## Stop / Delete

To tidy up, delete the resource group

- Invoke the following :

```text
az group delete --name aks-rg -y
```

---
[Home](aks-0.md) | [Next](aks-2.md)


text:
# Iranites Rahaghi, 1976 GENUS

#### Status
ACCEPTED

#### According to
IRMNG Homonym List

#### Published in
Publs Geol. Lab. Natn. Iran. Oil Comp. No. 6: 13. [This part of series also entitled: Publication No. 6 Societe National Iranienne des Petroles. Laboratoire de Micropaleontologie. Tehran].

#### Original name
null

### Remarks
null

repository: mdoering/backbone

repo_name: mdoering/backbone


text:
# Make Impact
An iOS app that empowers users to make an impact to current issues or crisis

## Table Of Contents:
1. [Planning Phase](https://github.com/SamuelFolledo/MakeImpact/tree/master/static/plans)
    - [Prototypes](https://github.com/SamuelFolledo/MakeImpact/tree/master/static/plans#prototype)
    - [Digital Mockups](https://github.com/SamuelFolledo/MakeImpact/tree/master/static/plans#digitalMockups)
    - [Wireframes](https://github.com/SamuelFolledo/MakeImpact/tree/master/static/plans#wireframes)
    - [User Stories](https://github.com/SamuelFolledo/MakeImpact/tree/master/static/plans#userstories)
2. [Prototypes](#prototypes)
3. [Important Links](#importantLinks)
4. [Contributors](#contributors)

## Prototypes
### Version 1 - Completed by Samuel P. Folledo on December 11, 2019 12:06PM
### Demo
- Browse's Issue Cells are clickable and shows Issue's details.
- MVVM Architecture following industry level patterns and architecture, separating concerns and responsibilities

#### Issue List Tab
- ViewController in a tab which contains all the issues available and clickable to display its detail

#### Issue Details VC
- ViewController which shows the detail of an issue selected

#### Settings Tab
- ViewController in a tab which contains all the settings available and clickable for the user to select

### Version 2
#### Discover Detail Screen
- ViewController which displays a selected category of an issue. Currently still in working progress

## Important Links
- [SPD 1.2 UI/UX Project Assignment](https://docs.google.com/document/d/15m8P9ic7sJqVovTozIRdikWCI7HQ_f5TOc5qpqyiAYs/edit#)

## Contributors
- Lead Developer: [Samuel Folledo](https://github.com/SamuelFolledo)

License under the [MIT License](LICENSE)

repository: SamuelFolledo/MakeImpact

gha_language: Swift

repo_name: SamuelFolledo/MakeImpact


text:
# luxwastecalendar/web_crawler
Web crawler of waste pickup calendars in various cities in Luxembourg.
Datasets are matched against CACLR address database from data.public.lu

----------
# Functionalities
In the current version, it crowls from:
- www.vdl.lu
- www.sidec.lu
- www.valorlux.lu

Which results in 3447 different postal codes accross Luxembourg country.
The script outputs 1 JSON file per postal code (total approx. 30 MB) containing all waste pickup events.

Sample of one output JSON file :
```
[
  {
    "uid": "5e8a5f0732fc6",
    "event_date": "1608073200000",
    "city": "Luxembourg",
    "location": "Côte d'Eich",
    "streetNumbers": "1-25, 2-24",
    "codepostal": 1450,
    "summary": "BULKY"
  },
  {
    "uid": "5e8a5f074f2c3",
    "event_date": "1608505200000",
    "city": "Luxembourg",
    "location": "Côte d'Eich",
    "streetNumbers": "1-25, 2-24",
    "codepostal": 1450,
    "summary": "PAPER"
  },
  {
    "uid": "5e8a5f0760dcc",
    "event_date": "1608678000000",
    "city": "Luxembourg",
    "location": "Côte d'Eich",
    "streetNumbers": "1-25, 2-24",
    "codepostal": 1450,
    "summary": "GLASS"
  },
  {
    "uid": "5e8a5f07716b4",
    "event_date": "1608678000000",
    "city": "Luxembourg",
    "location": "Côte d'Eich",
    "streetNumbers": "1-25, 2-24",
    "codepostal": 1450,
    "summary": "ORGANIC"
  }
]
```

# Requirements
Developed and tested on Nodejs v12

# Usage
`node install`
`node index.js`
Output files can be found in output/${timestamp}/ folder

# Pickup types
| API Type | VDL                  | Sidec              | Valorlux |
|----------|----------------------|--------------------|----------|
| BULKY    |                      | encombrants        |          |
| GLASS    | Verre                | verre              |          |
| ORGANIC  | Déchets alimentaires | dechets organiques |          |
| PAPER    | Papier/Carton        | papiers cartons    |          |
| PMC      | Emballages Valorlux  |                    | PMC      |
| RESIDUAL | Déchets résiduels    | dechets menagers   |          |
----------
# Known issues
## CACRL
- Several streets from "registre-national-des-localites-et-des-rues" resolve to null or empty postal codes. These streets are then ignored in waste calendar parsing.
## Valorlux
- No support for Esch-sur-Alzette, Differdange and Dudelange. Missing the mapping between postal codes and calendars
- No support for Pétange, Rodange, Lamadelaine and Walferdange. Need to add additional logic for those
## General
- Any change in data source format (json, html, ics ...) might break this library
----------
# Credits
Biggest credits go to data owners from the following web sites:
- https://data.public.lu/fr/datasets/registre-national-des-localites-et-des-rues/
- https://www.vdl.lu/fr/vivre/domicile-au-quotidien/collecter-et-trier-ses-dechets/calendrier-des-collectes/
- http://sidec.lu
- https://calendar.valorlux.lu/
----------
# Roadmap
List of identified sources to be crawled:

## Bertrange, Garnich, Kehlen, Koerich, Kopstal, Mamer, Steinfort, Habscht
- https://sicaapp.lu/
- format: html and pdf

## Differdange
- https://differdange.lu/wp-content/uploads/2020/01/Emweltkalenner.pdf
- format: pdf

repository: synapzlu/luxwastecalendar

repo_name: synapzlu/luxwastecalendar


text:
# CMD World
CMD World is a platform game written in Pascal and made only with ASCII characters in a command console. Many aspects of a game were implemented, like gravity, collision detection, rendering, update, input, character control and more. The game contains a total of 10 levels, in which the player must collect a key to open a door in order to finish the level. But it is not as simple as it seems to be, actually it is a pretty hard game.  Having that in mind, I even implemented a state saving/loading functionally for the less patient players.

![Main Menu](https://portfolium1.cloudimg.io/fit/960x540/c000000/https://cdn.portfolium.com/ugcs3%2Fentry%2FO7PUwd9UTQyNR8x14TeV_Screenshot3.png)

If you want to know more about it, you can check it out in my [portfolio](https://portfolium.com/entry/cmd-world).

## License

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

repository: CharlesNascimento/CMD-World

repo_name: CharlesNascimento/CMD-World


text:
# HeapAndBST
Heap & BST basic tasks:

* Make a set of maximums for real numbers (double type) using table. The heap should support the following functions:
    insert: insert an item into the pile,
    deleteMax: delete maximum item,
    max: maximum item return &
    destroy: heap destruction, deletion of all elements of the heap.

* Also implement a BST for real numbers using pointers. The tree should support the following functions:
    insert: enter an item in the tree,
    search: search for an item in the tree,
    deleteMax: delete maximum item,
    max: maximum item return,
    rotate left / right: left / right rotation &
    destroy: tree destruction, deletion of all tree elements.

It first reads from the user a integer N and create a heap of maximum size N and a blank BST. It will then produce random N numbers in the space [0, 100) which it will enter one by one into the heap and BST. It will then perform the maximum deletion function element N / 2 times both in the heap and in the search tree. It will print the current maximum for both structures on the screen. It will then randomly select one of the elements of the heap and search for that element in the search tree and report its number comparisons required to be found. At the location where the item was located in the tree, an attempt will be made to make a right turn first, and if not a left turn. In any case, a message will be printed on whether a rotation has been performed and if so. Finally, the program will destroy the heap and the BST and end it.

repository: AlexandrosPlessias/HeapAndBST

repo_name: AlexandrosPlessias/HeapAndBST


text:
# healthcheck
[![Codecov](https://img.shields.io/codecov/c/github/rmasclef/healthcheck.svg?style=flat&maxAge=60)]()
[![Build Status](https://travis-ci.org/rmasclef/healthcheck.svg?branch=master)](https://travis-ci.org/rmasclef/healthcheck)
[![Go Report Card](https://goreportcard.com/badge/github.com/rmasclef/healthcheck)](https://goreportcard.com/report/github.com/rmasclef/healthcheck)
[![GoDoc](https://godoc.org/github.com/rmasclef/healthcheck?status.svg)](https://godoc.org/github.com/rmasclef/healthcheck)

Healthcheck is a library for implementing Kubernetes [liveness and readiness](https://kubernetes.io/docs/tasks/configure-pod-container/configure-liveness-readiness-probes/) probe handlers in your Go application.

## Features

 - Integrates easily with Kubernetes. This library explicitly separates liveness vs. readiness checks instead of lumping everything into a single category of check.

 - Optionally exposes each check as a [Prometheus gauge](https://prometheus.io/docs/concepts/metric_types/#gauge) metric. This allows for cluster-wide monitoring and alerting on individual checks.

 - Supports asynchronous checks, which run in a background goroutine at a fixed interval. These are useful for expensive checks that you don't want to add latency to the liveness and readiness endpoints.

 - Includes a small library of generically useful checks for validating upstream DNS, TCP, HTTP, and database dependencies as well as checking basic health of the Go runtime.

## Usage

See the [GoDoc examples](https://godoc.org/github.com/rmasclef/healthcheck) for more detail.

 - Install with `go get` or your favorite Go dependency manager: `go get -u github.com/heptiolabs/healthcheck`

 - Import the package: `import "github.com/heptiolabs/healthcheck/checks"` & `import "github.com/heptiolabs/healthcheck/handlers"`

 - Create a `healthcheck.Handler`:
   ```go
   health := handlers.NewHandler(handlers.Options{})
   ```
You can also pass some metadata when creating a handler. Those metadata will be returned by the Endpoints
   ```go
   health := handlers.NewHandler(handlers.Options{
      Metadata: map[string]string{"foo": "bar"},
   })
   ```
> A great use case can be to pass the app-name, the app-version and the commit number in order to know which commit is making the app unhealthy

 - Configure some application-specific liveness checks (whether the app itself is unhealthy):
   ```go
   // Our app is not happy if we've got more than 100 goroutines running.
   health.AddLivenessCheck("goroutine-threshold", healthcheck.GoroutineCountCheck(100))
   ```

 - Configure some application-specific readiness checks (whether the app is ready to serve requests):
   ```go
   // Our app is not ready if we can't resolve our upstream dependency in DNS.
   health.AddReadinessCheck(
       "upstream-dep-dns",
       healthcheck.DNSResolveCheck("upstream.example.com", 50*time.Millisecond))

   // Our app is not ready if we can't connect to our database (`var db *sql.DB`) in <1s.
   health.AddReadinessCheck("database", healthcheck.DatabasePingCheck(db, 1*time.Second))
   ```

 - Expose the `/live` and `/ready` endpoints over HTTP (on port 8086):
   ```go
   go http.ListenAndServe("<IP_ADDRESS>:8086", health)
   ```

 - Configure your Kubernetes container with HTTP liveness and readiness probes see the ([Kubernetes documentation](https://kubernetes.io/docs/tasks/configure-pod-container/configure-liveness-readiness-probes/)) for more detail:
   ```yaml
   # this is a bare bones example
   # copy and paste livenessProbe and readinessProbe as appropriate for your app
   apiVersion: v1
   kind: Pod
   metadata:
     name: heptio-healthcheck-example
   spec:
     containers:
     - name: liveness
       image: your-registry/your-container

       # define a liveness probe that checks every 5 seconds, starting after 5 seconds
       livenessProbe:
         httpGet:
           path: /live
           port: 8086
         initialDelaySeconds: 5
         periodSeconds: 5

       # define a readiness probe that checks every 5 seconds
       readinessProbe:
         httpGet:
           path: /ready
           port: 8086
         periodSeconds: 5
   ```

 - If one of your readiness checks fails, Kubernetes will stop routing traffic to that pod within a few seconds (depending on `periodSeconds` and other factors).

 - If one of your liveness checks fails or your app becomes totally unresponsive, Kubernetes will restart your container.

## HTTP Endpoints
### Default routes
When you run `go http.ListenAndServe("<IP_ADDRESS>:8086", health)`, two HTTP endpoints are exposed:

  - **`/live`**: liveness endpoint (HTTP 200 if healthy, HTTP 503 if unhealthy)
  - **`/ready`**: readiness endpoint (HTTP 200 if healthy, HTTP 503 if unhealthy)

### Custom routes
You can also use other routes than **/live** & **/ready** by setting the `HEALTH_LIVENESS_PATTERN` and/or `HEALTH_READYNESS_PATTERN` env var on your application

### Endpoint response
Pass the `?full=1` query parameter to see the full check results as JSON. These are omitted by default for performance.

JSON result will look like this:
```json
{
  "Checks": {
    "test-readiness-check": "failed readiness check",
    "redis-check":  "error message from check"
  },
  "Metadata": {
    "some fake metadata": "fake value",
    "app_name":  "fake service name"
  }
}
```

repository: rmasclef/healthcheck

gha_language: Go

repo_name: rmasclef/healthcheck


text:
Sample code for VMware NSX-T Python SDK
=======================================

NSX-T SDK Sample Code

Copyright 2017 VMware, Inc.  All rights reserved

The BSD-2 license (the "License") set forth below applies to all
parts of the NSX-T SDK Sample Code project.  You may not use this
file except in compliance with the License.

BSD-2 License

Redistribution and use in source and binary forms, with or
without modification, are permitted provided that the following
conditions are met:

	Redistributions of source code must retain the above
	copyright notice, this list of conditions and the
	following disclaimer.

	Redistributions in binary form must reproduce the above
	copyright notice, this list of conditions and the
	following disclaimer in the documentation and/or other
	materials provided with the distribution.

Overview
--------

This repository contains code samples for the NSX-T Python
SDK.

Installation
------------
To install the SDK samples, clone this git repository into a
directory in your file system. You also need to have Python
2.7 or later or Python 3.4 or later.

The easiest way to install the NSX-T python SDK and its dependencies
is to use Python virtualenv. This allows you to install the SDK
and its dependencies without having to alter your system python
libraries, and also doesn't require root privileges.

To set up the NSX-T python SDK using virtualenv, make sure that the
following are installed:

* python2, version 2.7.9 or later, or python3, version 3.4 or later
* virtualenv
* pip

To install the SDK and its dependencies, issue the following commands:

    # 1) install a virtual env into directory "venv"
    virtualenv venv

    # 2) activate the virtual environment
    source venv/bin/activate

    # 3) Copy the NSX-T SDKs and vapi runtime:
    # For NSX-T 2.1, navigate to the VMware{code} website python SDK
    # site at https://code.vmware.com/sdks and follow the
    # VMware NSX-T for Python link.
    # Copy all SDK files to the lib directory in this repo.

    # 4) install the NSX-T SDK, and the vapi runtime
    pip install lib/*.whl

Preparing to run the samples
----------------------------

Be sure you are in the top level of the SDK examples, then add
the current directory to your PYTHONPATH:

    export PYTHONPATH=`pwd`

To run the samples, you need to have a working NSX-T manager
installed. To run the NSX policy SDK examples, you will need
to have a working NSX-T Policy appliance running.

Running the samples
-------------------

Each sample takes the following command-line arguments:

     -h,--help                     Get help
     -n,--nsx_host <arg>           NSX host to connect to
     -t,--tcp_port <arg>           TCP port for NSX server (optional, defaults
                                   to 443)
     -u,--user <arg>               User to authenticate as
     -p,--password <arg>           Password

Each sample has a comment block at the top with more information.

As an example, to run the crud.py example on host <IP_ADDRESS>,
authenticating as user "admin" with password "Secret!23":

    python basics/crud.py -n <IP_ADDRESS> -u admin -p "Secret!23"

Cleaning Up
-----------

When you are finished with the virtual environment, you can
deactivate it by typing:

    deactivate

Troubleshooting
---------------

If you are running on MacOS, the following guides may help you get
python, pip, and virtualenv installed:

[Install Python on Mac OS X for development](http://exponential.io/blog/2015/02/11/install-python-on-mac-os-x-for-development/)
[Install virtualenv and virtualenvwrapper on Mac OS X](http://exponential.io/blog/2015/02/10/install-virtualenv-and-virtualenvwrapper-on-mac-os-x/)

repository: etlars/backup

repo_name: etlars/backup


text:
## Simplified - Simple Octopress Theme

Simplified is a clean, single column theme for Octopress which is heavily inspired by [Jest](http://facebook.github.io/jest/).

This theme has a live preview [here](http://yangweilim.com).

### Install
```
cd octopress
git clone https://github.com/yang-wei/simplified.git .themes/simplified
rake install['simplified']
rake generate
```
####Installation when using zsh shell
`rake install\['simplified'\]`

### Customization
You can change the theme color easily by changing `$theme-color` at your `octopress/sass/base/_theme.scss`.

The social icon at landing page can be removed or added by editing `octopress/source/post/social_icon.html`.

This theme used [Font Awesome](http://fortawesome.github.io/Font-Awesome/icons/) icons, so you can add any icon as you like from there.

This theme also disable Octopress default sidebar and footer. So to get this to work you have to customize your `_config.yml` .
```
sidebar: collapse

default_asides: [asides/recent_posts.html, ... , asides/footer_in_sidebar.html]
```

### License
This theme is licensed under a MIT License - http://opensource.org/licenses/mit-license.html

### Update
Updated with a cleaner interface(24 May 2014). Below are the main updates.
 + Replace landing page with blog page
 + Minimal search form
 + Pretty syntax highlight

### More to come
More features will be updated.

Feel free to use.

repository: skipsuva/simplified

extension: markdown

repo_name: skipsuva/simplified