text:
## CloudMonkey

`cloudmonkey` :cloud::monkey_face: is a command line interface for
[Apache CloudStack](http://cloudstack.apache.org).
CloudMonkey can be use both as an interactive shell and as a command line tool
which simplifies Apache CloudStack configuration and management. It can be used
with Apache CloudStack 4.0-incubating and above.

![version badge](https://badge.fury.io/py/cloudmonkey.png) ![download badge](http://img.shields.io/pypi/dm/cloudmonkey.png)

### For users

Install:

    $ pip install cloudmonkey

Upgrade:

    $ pip install --upgrade cloudmonkey

Install/Upgrade latest using git repository:

    $ pip install --upgrade git+https://git-wip-us.apache.org/repos/asf/cloudstack-cloudmonkey.git

Install/upgrade using the Github git mirror:

    $ pip install --upgrade git+https://github.com/apache/cloudstack-cloudmonkey.git

Please see the [CloudMonkey Wiki](https://cwiki.apache.org/confluence/display/CLOUDSTACK/CloudStack+cloudmonkey+CLI) for usage.

### Using Docker image

The default configuration provided connect to CloudStack managemenent server as container:

Enter the CLI:

    $ docker run -ti --rm --link cloudstack:8080 cloudstack/cloudmonkey

To execute single api command:

    $ docker run -ti --rm --link cloudstack:8080 cloudstack/cloudmonkey list accounts

Use your own CloudMonkey configuration file:

    $ docker run -ti --rm -v `pwd`/.cloudmonkey:/cloudmonkey cloudstack/cloudmonkey

### Build

All:

    Cleans and then builds with precache
    $ make all

Build:

    $ make build

Build Precache:

    $ make buildcache

Build with Precache:

    $ make buildwithcache

Check changes, code styles:

    $ make check

Clean:

    $ make clean

Install:

    $ make install

### Mailing lists

[Development Mailing<EMAIL_ADDRESS>
[Users Mailing<EMAIL_ADDRESS>
[Commits Mailing<EMAIL_ADDRESS>
[Issues Mailing<EMAIL_ADDRESS>
[Marketing Mailing<EMAIL_ADDRESS>

### Contributing

Discuss features development on the [Development Mailing List](mailto:dev-subscribe@cloudstack.apache.org).
Report issues on the `User` mailing list and open issue on [JIRA](http://issues.apache.org/jira/browse/CLOUDSTACK).

1. Fork the repository on Github
2. Create a named feature branch (like `add_component_x`)
3. Write your change
4. Write tests for your change (if applicable)
5. Run the tests, ensuring they all pass
6. Submit a Pull Request using Github

### License

Licensed to the Apache Software Foundation (ASF) under one
or more contributor license agreements.  See the NOTICE file
distributed with this work for additional information
regarding copyright ownership.  The ASF licenses this file
to you 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: phillipkent/cloudstack-cloudmonkey

repo_name: phillipkent/cloudstack-cloudmonkey


text:
# ProtoBeetle

ProtoBeetle is a performance sketch of the design components of TigerBeetle.

## Benchmark

This will:

* Install and build dependencies.
* Pre-allocate a contiguous 256 MB journal file.
* Create a million transfers for the benchmark.
* Run the benchmark!

```shell
git clone https://github.com/jorangreef/tiger-beetle.git
cd tiger-beetle/proto-beetle
npm install
dd < /dev/zero bs=1048576 count=256 > journal
scripts/create-transfers
node server

# In another tab:
cd tiger-beetle/proto-beetle
time node stress
```

## Mojaloop

For integration with Mojaloop, we also created `fast-ml-api-adapter.js` to
transform individual Mojaloop HTTP transfer requests into batches and ship these
to ProtoBeetle across the network using `client.js`.

repository: ThreeFx/tigerbeetle

branch_name: refs/heads/main

extension: md

license_type: permissive

repo_name: ThreeFx/tigerbeetle


text:
## HTML/CSS/Git

### 1

1. HTML - `vocab` `HTML`

	:question: What does HTML stand for?
	* Helper Text Machine Language
	* Hypertext Markup Language
	* Helpful Text Multiple Layers
	* Hypertext Middle Level

### 2

1. HTML Links -

	:question: The correct HTML code for adding a link is:
	* `<link src="http://www.google.com">Google</link>`
	* `<a src=http://www.google.com>Google</a>`
	* `<href="http://www.google.com">Google</href>`
	* `<a href="http://www.google.com">Google</a>`

### 3

1. Header Sizes

	:question: Which of the following is the largest heading size by default?
	* h0
	* h6
	* h1
	* h10

### 4

1. Image elements -

	:question: The ____ element tag is used to add an image.
	* `<jpg>`
	* `<a>`
	* `<pic>`
	* `<img>`

### 5

1. CSS -

	:question: What does CSS stand for?
	* Cooperative Standard Styling
	* Creative Style Syntax
	* Colorful Special Styling
	* Cascading Style Sheets

### 6

1. HTML CSS Linking -

	:question: A CSS file is located in a folder and that folder is adjacent to the HTML file you are in. The HTML file you are in links to the CSS file using:
	* `<link rel="stylesheet" type="text/css" href="css/style.css">`
	* `<a rel="css" type="text/css" href="css/style.css">`
	* `<css rel="stylesheet" type="text/css" src="css/style.css">`
	* `<l rel="stylesheet" type="text/css" src="css/style.css">`

### 7

1. CSS Syntax -

	:question: The CSS syntax to style all `<p>` elements to appear bold is:
	* `p { font-weight: bold; }`
	* `p ( font-weight = bold );`
	* `p [ font-weight: "bold" ]`
	* `p font-weight: bold;`

### 8

1. CSS Classes -
	:question: All class names in a CSS file are preceded by the symbol:
	* :
	* \#
	* \-
	* \.

### 9

1. CSS IDs -

	:question: All ID names in a CSS file are preceded by the symbol:
	* :
	* \#
	* \-
	* \.

### 10

1. Element Size Calculations -

	:question: Including margins, how wide is the following element:
	```CSS
	#box {
		width: 20px;
		height: 40px;
		margin: 10px 20px 30px 40px;
		padding: 40px 30px 20px 10px;
		border-width: 10px;
	}
	```
	* 140px
	* 130px
	* 100px
	* 80px

### 11

1. Block Elements -

	:question: Which of the following is treated as a block element?
	* `<img>`
	* `<p>`
	* `<a>`
	* `<link>`

### 12

1. Block Element Alignment -
	:question: We can align a block element to the left or right of the screen using the ____ CSS property.
	* align
	* float
	* left
	* justify

### 13

1. Moving Elements in Relation -

	:question: ____ positioning moves elements in relation to their original/default location.
	* Absolute
	* Negative
	* Relative
	* Exact

### 14

1. Layering Elements

	:question: The CSS property ____ allows us to layer elements above and below each other.
	* z-level
	* h-index
	* h-level
	* z-index

### 15

1. Moving Elements Relatively

	:question: ____ positioning helps place elements relative to their nearest positioned ancestor element.
	* Absolute
	* Negative
	* Relative
	* Exact

### 16

1. Display: none Property

	:question: The `display: none` property allows us to:
	* prevent pop-up windows
	* close the browser
	* hide an element
	* remove all images only

### 17

1. CSS Precedence

	:question: An HTML file is loading file1.css and file2.css, with file1.css linked before file2.css. The file1.css file lists a class with a font size of 10px. The file2.css file lists the same class but with a font size of 15px. Which CSS file will take precedence in determining the font size for that class?
	* The file1.css file linked in the HTML file
	* The file2.css file linked in the HTML file
	* The CSS file with the highest number in the name
	* None of them - it will cause an error

### 18

1. CSS Resets -
	:question: CSS Resets are an important tool for:
	* creating cross browser compatibility
	* preventing browser crashes
	* stopping the spread of malware
	* avoiding website hacking

### 19

1. Class and ID Stacking -

	:question: What will be the size of the text displayed by the following code?
	```HTML
	<style>
		.myClass {
			font-size: 10px;
		}
		#myID {
			font-size: 20px;
		}
	</style>

	<p id="myID" class="myClass">Hello Boot Camp!</p>
	```
	* 10px
	* 20px
	* 30px
	* None of the above - This will cause an error

### 20

1. Special State Keywords -

	:question: Keywords added to CSS selectors that specify a special state of an element are called:
	* primary-selectors
	* main-ids
	* state-elements
	* pseudo-classes

### 21

1. CSS Frameworks Purpose -

	:question: A primary reason for using CSS Frameworks like Bootstrap is to:
	* save significant time building a website
	* avoid typos and errors in the code
	* allow better collaboration among developers
	* make websites perform faster

### 22

1. Bootstrap Grid -

	:question: The Bootstrap grid sits inside a ____.
	* CSS file
	* container
	* relative row
	* master column

### 23

1. Bootstrap Grid Columns -

	:question: In a Bootstrap grid, the sum total of all columns within a row must add up to ____.
	* 10
	* 20
	* 12
	* 15

### 24

1. Bootstrap Grid Classes -

	:question: To make a column one-half the width of its row, we would use the ____ Bootstrap helper class.
	* col-md-5
	* col-md-10
	* col-md-2
	* col-md-6

### 25

1. Mobile Responsiveness -

	:question: ____ are used to help create mobile responsive websites.
	* Media queries
	* Browser logs
	* Size requests
	* Specialized browsers

### 26

1. Website Display -

	:question: ____ refers to the display being used to view a website.
	* Browser
	* Viewport
	* Displayport
	* Screen

### 27

1. Git Benefits -

	:question: Which of the following is NOT a benefit of using Git?
	* having a version history of code changes
	* easing code conflict resolution
	* allowing multiple developers to work together
	* being able to translate code between languages

### 28

1. GitHub Workflow -

	:question: What is the typical work flow of committing your work?
	* Commit changes; Push; Clone
	* Add changes to staging; Commit changes
	* Pull Changes; Commit changes; Add changes to staging
	* Add changes staging; Save to Git; Send to Github

### 29

1. GitHub Pages Deployment

     When deploying your site to GitHub Pages, the repository must contain the file:
	* style.css
	* run.html
	* index.html
	* index.css

### 30

1. GitHub Pages URL

	:question: A repository named `portfolio` deployed to GitHub Pages by user `johnsmith1` may be found at the following URL:
	* `https://johnsmith1.github.io/portfolio`
	* `https://www.github.com/johnsmith1/portfolio`
	* `https://portfolio.github.io/johnsmith1`
	* `https://johnsmith1.github.com/portfolio`

### 31

1. Git Collaboration

	:question: When developers are collaborating on a project, they all write their code in their own Git ____.
	* repository
	* branch
	* page
	* file

license: MIT

branch_name: refs/heads/master


text:
# tensorflow-ddos
This project contains the following components:

# Telize
Telize is a API to retrieve GeoIP information utilized by the normaliz process.

# Normaliz
When you run *Normaliz* for the first time it will batch a process to normalize the dataset.
When this process ends it opens a API to normalize the input data required for each further test.

# Learn
The learn process requires that the data was normalized so it waits for *Normaliz* finish its batch processing
to begin the his own process of trainig.

repository: cainelli/tensorflow-ddos

repo_name: cainelli/tensorflow-ddos


text:
# Auto-untag customers when a certain product is refunded

Tags: Customers, Refunds, Untag

Use this task to automatically remove a certain customer tag whenever a particular product is refunded, for that customer.

* View in the task library: [usemechanic.com/task/auto-untag-customers-when-a-certain-product-is-refunded](https://usemechanic.com/task/auto-untag-customers-when-a-certain-product-is-refunded)
* Task JSON, for direct import: [task.json](../../tasks/auto-untag-customers-when-a-certain-product-is-refunded.json)
* Preview task code: [script.liquid](./script.liquid)

## Default options

```json
{
  "product_ids__number_array_required": null,
  "customer_tag_to_remove__required": null
}
```

[Learn about task options in Mechanic](https://docs.usemechanic.com/article/471-task-options)

## Subscriptions

```liquid
shopify/refunds/create
```

[Learn about event subscriptions in Mechanic](https://docs.usemechanic.com/article/408-subscriptions)

## Documentation

Use this task to automatically remove a certain customer tag whenever a particular product is refunded, for that customer.

This task is configured with one or more product IDs ([learn how to find a product ID](https://help.usemechanic.com/en/articles/2946120-how-do-i-find-an-id-for-a-product-collection-order-or-something-else)), and with the customer tag to remove when one of those products is refunded.

## Installing this task

Find this task [in the library at usemechanic.com](https://usemechanic.com/task/auto-untag-customers-when-a-certain-product-is-refunded), and use the "Try this task" button. Or, import [this task's JSON export](../../tasks/auto-untag-customers-when-a-certain-product-is-refunded.json) – see [Importing and exporting tasks](https://docs.usemechanic.com/article/505-importing-and-exporting-tasks) to learn how imports work.

## Contributions

Found a bug? Got an improvement to add? Start here: [../../CONTRIBUTING.md](../../CONTRIBUTING.md).

repository: Ferrallv/mechanic-tasks

gha_language: JavaScript

gha_license_id: MIT

repo_name: Ferrallv/mechanic-tasks


text:
# Data Volume cloning with CSI Volume Clone

## Introduction
CSI Volume Cloning uses the `Volume Cloning` feature of CSI drivers in order to perform a quick and efficient PVC clone.
The `Volume Cloning` functionality is not universal to all CSI drivers in kubernetes, so care must be taken when defining
and choosing the source PVC storage class. In order to enable CSI Cloning for the selected storage class, the
storage profile of the respective DataVolume PVC will be checked for cloneStrategy (`cloneStrategy=csi-clone` see [Storage Profiles](./storageprofile.md)).
It is the responsibility of a user to configure the storage profile accordingly.

See [volume-cloning](https://kubernetes-csi.github.io/docs/volume-cloning.html) for more information on discerning the capabilities of your csi driver.

### Prerequisites
  1) The csi driver backing the storage class of the PVC supports volume cloning, and corresponding StorageProfile has
     the cloneStrategy set to CSI Volume Cloning (see [here](./csi-cloning.md#Prerequisites) for more details)
  2) The source and target PVC share the same Storage Class (see [here](https://kubernetes.io/docs/concepts/storage/persistent-volumes/#class) for details)
  3) The source and target PVC share the same Volume Mode (see [here](https://kubernetes.io/docs/concepts/storage/persistent-volumes/#volume-mode) for details)
  4) The user creating the DataVolume has permission to create the `datavolumes/source` resource in the source namespace
  5) The source volume is not in use

### Flow Description
- DataVolume is created with a PVC source
- Check if CSI Volume Cloning is possible (as described in Prerequisites):
- If CSI Volume Cloning is possible:
    * Create the PVC
    * Set the claim reference of the PV to point to the new target PVC
- If CSI Volume Cloning is not possible:
    * Attempt Host Assisted Cloning [host-assisted cloning](./clone-datavolume.md)

repository: kubevirt/containerized-data-importer

gha_language: Go

repo_name: kubevirt/containerized-data-importer


text:
#Knod

[![Gem Version](https://badge.fury.io/rb/knod.svg)](http://badge.fury.io/rb/knod) [![Build Status](https://travis-ci.org/moserrya/knod.svg?branch=master)](https://travis-ci.org/moserrya/knod) [![Code Climate](https://codeclimate.com/github/moserrya/knod.png)](https://codeclimate.com/github/moserrya/knod)

Knod is a simple HTTP server for prototyping rich JavaScript apps. It responds to GET, PUT, POST, PATCH, and DELETE, serving up, writing to, and deleting from the directory of your choice. Knod has no dependencies outside of the Ruby standard library.

## Installation

```gem install knod```

## Usage

The Knod gem comes with an executable; you can run it from the command line with `knod`. Knod will default to port 4444 and the current directory. You can change these with command line arguments (-p and -d, respectively).

You can also run it by requiring `knod` and calling `Knod.start`. Knod accepts an options hash that lets you change the port, root directory, and logging:

```ruby
options = {port: 1234, root: './some/directory', logging: false}
Knod.start options
```

Logging is enabled by default. The server will select an open ephemeral port at random if you pass in 0 as the port.

Knod sanitizes the path on all requests and does not allow access to folders outside of the root directory where it is run.

If the path for a GET request is a file, file will be mapped to its MIME type based on the file suffix. Data is considered to be `application/octet-stream` if the content type is unrecognized. If the path for a GET request is a directory, Knod will concatenate the contents of all files in the directory into a JSON array.

All data from PUT, POST, and PATCH requests is stored as JSON. If the pathway specified in the request does not exist, Knod will create it.

POST requests auto-increment in the specified path and return the id of the file written as JSON (e.g if a POST request led to the server writing 56.json, the server would respond with `"{\"id\":56}"`.

repository: moserrya/knod

gha_language: Ruby

repo_name: moserrya/knod


text:
# dovecot

#### Table of Contents

1. [Overview](#overview)
2. [Module Description - What the module does and why it is useful](#module-description)
3. [Setup - The basics of getting started with dovecot](#setup)
    * [What dovecot affects](#what-dovecot-affects)
    * [Beginning with dovecot](#beginning-with-dovecot)
4. [Usage - Configuration options and additional functionality](#usage)
5. [Reference - An under-the-hood peek at what the module is doing and how](#reference)
5. [Limitations - OS compatibility, etc.](#limitations)
6. [Development - Guide for contributing to the module](#development)

## Overview

This is a simple module to install and manage a secure Dovecot-based POP3 service.

Currently tested on Debian 7, support coming for Debian 8.

## Module Description

This module installs, configures and manages a secure dovecot based POP3 service.

It only managed the files required, all others are left as the installer deploys them.

Default settings require encryption and disable SSLv2 and SSLv3.

## Setup

### What dovecot affects

* Installs dovecot-pop3d
* Manages dovecot.conf and 10-ssl.conf
* Manages the dovecot service

### Beginning with dovecot

```
include ::dovecot
```

## Usage

There's a single entry point via the `dovecot` class through which configuration
overrides can be passed.

```
class { '::dovecot':
  ssl_cert => '</etc/ssl/certs/mail.crt',
  ssl_key  => '</etc/ssl/private/mail.key',
}
```

## Reference

This really is a very simple module using the install -> config ~> service model.

See the comments in `init.pp` for a list of parameters and defaults.

## Limitations

Currently this module has only been tested on Debian 7, and only configures some
very basic settings that are relevant to our usage.

Uses `contain` rather than the `anchor` pattern, so requires at least Puppet 3.4.

We may add further features as we need them.

## Development

Pull requests welcomed and considered.

repository: sagepe/puppet-dovecot

repo_name: sagepe/puppet-dovecot


text:
# Outline Server

![Build and Test](https://github.com/Jigsaw-Code/outline-server/actions/workflows/build_and_test_debug.yml/badge.svg?branch=master) [![Mattermost](https://badgen.net/badge/Mattermost/Outline%20Community/blue)](https://community.internetfreedomfestival.org/community/channels/outline-community) [![Reddit](https://badgen.net/badge/Reddit/r%2Foutlinevpn/orange)](https://www.reddit.com/r/outlinevpn/)

This repository has all the code needed to create and manage Outline servers on
DigitalOcean. An Outline server runs instances of Shadowsocks proxies and
provides an API used by the Outline Manager application.

Go to https://getoutline.org for ready-to-use versions of the software. **To join our Outline Community, [sign up for the IFF Mattermost](https://internetfreedomfestival.org/wiki/index.php/IFF_Mattermost).**

## Components

The system comprises the following components:

- **Outline Server**: a proxy server that runs a Shadowsocks instance for each
  access key and a REST API to manage the access keys. The Outline Server runs
  in a Docker container in the host machine.

  See [`src/shadowbox`](src/shadowbox)

- **Outline Manager:** an [Electron](https://electronjs.org/) application that
  can create Outline Servers on the cloud and talks to their access key
  management API to manage who has access to the server.

  See [`src/server_manager`](src/server_manager)

- **Metrics Server:** a REST service that the Outline Server talks to
  if the user opts-in to anonymous metrics sharing.

  See [`src/metrics_server`](src/metrics_server)

## Code Prerequisites

In order to build and run the code, you need the following installed:

- [Node](https://nodejs.org/en/download/) LTS (`lts/gallium`, version `16.13.0`)
- [NPM](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm) (version `8.1.0`)
- Manager-specific
  - [Wine](https://www.winehq.org/download), if you would like to generate binaries for Windows.
- Server-specific
  - [Docker](https://docs.docker.com/engine/install/), to build the Docker image and to run the integration test.
  - [docker-compose](https://docs.docker.com/compose/install/), to run the integration test.

> 💡 NOTE: if you have `nvm` installed, run `nvm use` to switch to the correct node version!

Install dependencies with:

```sh
npm install
```

This project uses [NPM workspaces](https://docs.npmjs.com/cli/v7/using-npm/workspaces/).

## Build System

We have a very simple build system based on package.json scripts that are called using `npm run`
and a thin wrapper for what we call build "actions".

We've defined a package.json script called `action` whose parameter is a relative path:

```shell
npm run action $ACTION
```

This command will define a `run_action()` function and call `${ACTION}.action.sh`, which must exist.
The called action script can use `run_action` to call its dependencies. The $ACTION parameter is
always resolved from the project root, regardless of the caller location.

The idea of `run_action` is to keep the build logic next to where the relevant code is.
It also defines two environmental variables:

- ROOT_DIR: the root directory of the project, as an absolute path.
- BUILD_DIR: where the build output should go, as an absolute path.

> ⚠ To find all the actions in this project, run `npm run action:list`

### Build output

Building creates the following directories under `build/`:

- `web_app/`: The Manager web app.
  - `static/`: The standalone web app static files. This is what one deploys to a web server or runs with Electron.
- `electron_app/`: The launcher desktop Electron app
  - `static/`: The Manager Electron app to run with the electron command-line
  - `bundled/`: The Electron app bundled to run standalone on each platform
  - `packaged/`: The Electron app bundles packaged as single files for distribution
- `invite_page`: the Invite Page
  - `static`: The standalone static files to be deployed
- `shadowbox`: The Proxy Server

The directories have subdirectories for intermediate output:

- `ts/`: Autogenerated Typescript files
- `js/`: The output from compiling Typescript code
- `browserified/`: The output of browserifying the JavaScript code

To clean up:

```
npm run clean
```

## Shadowsocks Resistance Against Detection and Blocking

Shadowsocks used to be blocked in some countries, and because Outline uses Shadowsocks, there has been skepticism about Outline working in those countries. In fact, people have tried Outline in the past and had their servers blocked.

However, since the second half of 2020 things have changed. The Outline team and Shadowsocks community made a number of improvements that strengthened Shadowsocks beyond the censor's current capabilities.

As shown in the research [How China Detects and Blocks Shadowsocks](https://gfw.report/talks/imc20/en/), the censor uses active probing to detect Shadowsocks servers. The probing may be triggered by packet sniffing, but that's not how the servers are detected.

Even though Shadowsocks is a standard, it leaves a lot of room for choices on how it's implemented and deployed.

First of all, you **must use AEAD ciphers**. The old stream ciphers are easy to break and manipulate, exposing you to simple detection and decryption attacks. Outline has banned all stream ciphers, since people copy old examples to set up their servers. The Outline Manager goes further and picks the cipher for you, since users don't usually know how to choose a cipher, and it generates a long random secret, so you are not vulnerable to dictionary-based attacks.

Second, you need **probing resistance**. Both shadowsocks-libev and Outline have added that. The research [Detecting Probe-resistant Proxies](https://www.ndss-symposium.org/ndss-paper/detecting-probe-resistant-proxies/) showed that, in the past, an invalid byte would trigger different behaviors whether it was inserted in positions 49, 50 or 51 of the stream, which is very telling. That behavior is now gone, and the censor can no longer rely on that.

Third, you need **protection against replayed data**. Both shadowsocks-libev and Outline have added such protection, which you may need to enable explicitly on ss-libev, but it's the default on Outline.

Fourth, Outline and clients using shadowsocks-libev now **merge the SOCKS address and the initial data** in the same initial encrypted frame, making the size of the first packet variable. Before the first packet only had the SOCKS address, with a fixed size, and that was a giveaway.

The censors used to block Shadowsocks, but Shadowsocks has evolved, and in 2021, it was ahead again in the cat and mouse game.

In 2022 China started blocking seemingly random traffic ([report](https://www.opentech.fund/news/exposing-the-great-firewalls-dynamic-blocking-of-fully-encrypted-traffic/)). While there is no evidence they could detect Shadowsocks, the protocol ended up blocked.

As a reponse, we [added a feature to the Outline Client](https://github.com/Jigsaw-Code/outline-client/pull/1454) that allows service managers to specify in the access key a prefix to be used in the Shadowsocks initialization, which can be used to bypass the blocking in China.

Shadowsocks remains our protocol of choice because it's simple, well understood and very performant. Furthermore, it has an enthusiastic community of very smart people behind it.

repository: Jigsaw-Code/outline-server

gha_language: TypeScript

repo_name: Jigsaw-Code/outline-server


text:
# SBNF

[![Build Status](https://travis-ci.org/BenjaminSchaaf/sbnf.svg?branch=master)](https://travis-ci.org/BenjaminSchaaf/sbnf) [![Crate](http://meritbadge.herokuapp.com/sbnf)](https://crates.io/crates/sbnf)

A BNF-style language for writing sublime-syntax files.

SBNF is currently used for
[SWI-Prolog](https://github.com/BenjaminSchaaf/swi-prolog-sublime-syntax).

## Motivation & Goals

Writing syntax definitions is error prone and the result is hard to maintain.
The addition of `branch_point`, while a great feature, dramatically increases
complexity and duplication when used.

SBNF attempts do the following:
* Provide a maintainable, declarative language for writing sublime syntax
  definitions
* Compile quickly for fast iteration
* Compile to an efficient syntax, comparable to hand-made ones

## Installation

Currently you'll need to [install rust](https://www.rust-lang.org/tools/install)
to use SBNF. With rust installed you can download, build and install the latest
released version of SBNF using:

```bash
$ cargo install sbnf
```

Or if you want the latest features, clone this repository, then build and
install using:

```bash
$ cargo install --path .
```

## Example

The following is a sbnf grammar for a cut-down version of C. It only allows
global/local variable declarations, function definitions and simple function
calls. Even this cut down version is extremely difficult to parse correctly with
the required `meta.function` and `meta.function-call` scopes, as both function
definitions and function calls require branch points.

```sbnf
name: simplec

prototype = ( ~comment )* ;

comment = '(//+).*\n?'{comment.line, 1: punctuation.definition.comment} ;

main = ( variable-declaration | function-definition )* ;

function-definition{meta.function} = type
                                     '\b[A-Za-z_]+\b'{entity.name.function}
                                     `(`
                                     `)`
                                     block
                                   ;

block{meta.block} = '{' statement* '}' ;

statement = variable-declaration
          | value ';'
          | block
          ;

variable-declaration = type '\b[A-Za-z_]+\b'{variable} ( '=' value )? ';' ;

type = '\b[A-Za-z_]+\b'{storage.type} ;

value = '[0-9]+'{constant.numeric}
      | function-call
      ;

# Function calls don't have arguments :)
function-call{meta.function-call}
      = '\b[A-Za-z_]+\b'{variable.function meta.path} `(` `)` ;
```

The above grammar compiles to the following:

```yaml
%YAML 1.2
---
# http://www.sublimetext.com/docs/3/syntax.html
name: simplec
scope: source.simplec
contexts:
  block|0:
    - meta_content_scope: meta.block.simplec
    - match: '(?=\b[A-Za-z_]+\b)'
      branch_point: block@1
      branch:
        - type|4|block@1
        - function-call|2|block@1
    - match: '[0-9]+'
      scope: constant.numeric.simplec
      push: statement|0
    - match: '{'
      scope: meta.block.simplec
      push: block|0
    - match: '}'
      scope: meta.block.simplec
      pop: true
    - match: '\S'
      scope: invalid.illegal.simplec
      pop: true
  function-call|0:
    - meta_content_scope: meta.function-call.simplec
    - match: '\('
      set: function-call|1
    - match: '\S'
      scope: invalid.illegal.simplec
      pop: true
  function-call|1:
    - meta_content_scope: meta.function-call.simplec
    - match: '\)'
      scope: meta.function-call.simplec
      pop: true
    - match: '\S'
      scope: invalid.illegal.simplec
      pop: true
  function-call|2|block@1:
    - meta_include_prototype: false
    - match: '\b[A-Za-z_]+\b'
      scope: meta.function-call.simplec variable.function.simplec meta.path.simplec
      push: [pop-2, function-call|3|block@1]
  function-call|3|block@1:
    - match: '\('
      scope: meta.function-call.simplec
      set: [statement|0, function-call|1]
    - match: '\S'
      scope: invalid.illegal.simplec
      pop: true
  function-definition|0|main@0:
    - match: '\('
      scope: meta.function.simplec
      set: function-definition|1
    - match: '\S'
      scope: invalid.illegal.simplec
      pop: true
  function-definition|1:
    - meta_content_scope: meta.function.simplec
    - match: '\)'
      set: function-definition|2
    - match: '\S'
      scope: invalid.illegal.simplec
      pop: true
  function-definition|2:
    - meta_content_scope: meta.function.simplec
    - match: '{'
      scope: meta.block.simplec
      set: [function-definition|meta, block|0]
    - match: '\S'
      scope: invalid.illegal.simplec
      pop: true
  function-definition|meta:
    - meta_content_scope: meta.function.simplec
    - match: ''
      pop: true
  main:
    - match: '(?=\b[A-Za-z_]+\b)'
      branch_point: main@0
      branch:
        - type|0|main@0
        - type|2|main@0
    - match: '\S'
      scope: invalid.illegal.simplec
  pop-2:
    - meta_include_prototype: false
    - match: ''
      pop: 2
  prototype:
    - match: '(//+).*\n?'
      scope: comment.line.simplec
      captures:
        1: punctuation.definition.comment.simplec
  statement|0:
    - match: ';'
      pop: true
    - match: '\S'
      scope: invalid.illegal.simplec
      pop: true
  type|0|main@0:
    - meta_include_prototype: false
    - match: '\b[A-Za-z_]+\b'
      scope: storage.type.simplec
      push: [pop-2, type|1|main@0]
  type|1|main@0:
    - match: '\b[A-Za-z_]+\b'
      scope: variable.simplec
      set: variable-declaration|0|main@0
    - match: '\S'
      fail: main@0
  type|2|main@0:
    - meta_include_prototype: false
    - match: '\b[A-Za-z_]+\b'
      scope: meta.function.simplec storage.type.simplec
      push: [pop-2, type|3|main@0]
  type|3|main@0:
    - match: '\b[A-Za-z_]+\b'
      scope: meta.function.simplec entity.name.function.simplec
      set: function-definition|0|main@0
    - match: '\S'
      scope: invalid.illegal.simplec
      pop: true
  type|4|block@1:
    - meta_include_prototype: false
    - match: '\b[A-Za-z_]+\b'
      scope: storage.type.simplec
      push: [pop-2, type|5|block@1]
  type|5|block@1:
    - match: '\b[A-Za-z_]+\b'
      scope: variable.simplec
      set: variable-declaration|3
    - match: '\S'
      fail: block@1
  variable-declaration|0|main@0:
    - match: '='
      set: variable-declaration|1
    - match: ';'
      pop: true
    - match: '\S'
      fail: main@0
  variable-declaration|1:
    - match: '[0-9]+'
      scope: constant.numeric.simplec
      set: variable-declaration|2
    - match: '\b[A-Za-z_]+\b'
      scope: meta.function-call.simplec variable.function.simplec meta.path.simplec
      set: [variable-declaration|2, function-call|0]
    - match: '\S'
      scope: invalid.illegal.simplec
      pop: true
  variable-declaration|2:
    - match: ';'
      pop: true
    - match: '\S'
      scope: invalid.illegal.simplec
      pop: true
  variable-declaration|3:
    - match: '='
      set: variable-declaration|1
    - match: ';'
      pop: true
    - match: '\S'
      scope: invalid.illegal.simplec
      pop: true
```

## Usage

A SBNF file contains two types of elements: headers and rules. Headers provide
meta-data for the syntax, such as it's name, while rules are the bnf-style rules
that define the parsing and scoping of the grammar.

See `sbnf.sbnf` for a full example grammar.

### Headers

Headers are in the form `<head>: <value>`, ending at the end of the line. The
following values are allowed:

* `name`: The name of the syntax. This defaults to the name of the sbnf file.
* `extensions`: A space-separated list of file extensions. Equivalent to
  `file_extensions` in sublime-syntax.
* `first-line`: A regex for matching the first line of a file. Equivalent to
  `first_line_match` in sublime-syntax.
* `scope`: The default scope for the grammar. This defaults to `source.`
  followed by the name lowercased.
* `scope-postfix`: A postfix appended to all scopes in the grammar (excluding
  the `scope` header). This defaults to the name lowercased. Leave empty to
  leave out the postfix.
* `hidden`: Whether the syntax will be shown in the menu in Sublime Text.

Example:

```
name: SBNF
extensions: sbnf
# Don't need this, as this is already the default
# scope: source.sbnf
```

### Rules

Rules are in the form `<identifier> <arguments> = <expression> ;`.
Identifiers may contain any alphanumeric character as well as `-`, `_` and `.`.

Like sublime-syntax files, SBNF grammars have two entry points: `main`,
`prototype`. They behave identically to those in sublime-syntax files. Only
rules used directly or indirectly from an entry point are compiled.

Arguments come in the following form: `{<arg>, <key>: <value>}`. `<arg>`,
`<key>` or `<value>` may contain any text except `,`, `:` or `}`. There may be
any number of arguments given, as allowed by whatever the arguments are for.
When there are no arguments the `{}` are optional.

The following arguments are allowed for rules:

* `<meta-scope>`: The meta-scope of the rule. Equivalent to `meta_scope` or
  `meta_content_scope` in sublime-syntax.
* `include-prototype: <bool>`: Whether to include the `prototype` rule in this
  rule. Equivalent to `meta_include_prototype` in sublime-syntax. `<bool>` must
  be either `true` or `false`. Defaults to `true`.

Expressions may take any of the following forms:

* `` `<literal>` ``: A terminal matching text literally.
* `'<regex>'`: A terminal matching text according to a regex.
* `<identifier>`: A non-terminal matching another rule.
* `<expr> | <expr>`: An alternation of expressions. The grammar matches either
  the left or right expression. This can be used as a list, eg:
  `'a' | 'b' | 'c'`.
* `<expr> <expr>`: A concatenation of expressions. The grammar matches the left
  expression followed by the right expression. This can be used as a list, eg:
  `'a' 'b' 'c'`.
* `(<expr>)`: A grouping.
* `<expr>?`: An optional expression. The grammar matches nothing or the
  expression.
* `<expr>*`: A repeating expression. The grammar matches the expression any
  number of times, including 0.
* `~<expr>`: A passive expression. The grammar matches *any text* until the
  expression matches.

Literal and regex terminals are allowed the following arguments:

* `<scope>`: The scope of the terminal.
* `<capture>: <scope>`: The scope for a regex capture group. `<capture>` must be
  an integer.

### Command Line

```bash
$ sbnf --help
SBNF compiler 0.1.0

USAGE:
    sbnf [FLAGS] <INPUT> [OUTPUT]

FLAGS:
    -g               Compile with debug scopes
    -h, --help       Prints help information
    -q               Do not display warnings
    -V, --version    Prints version information

ARGS:
    <INPUT>     The SBNF file to compile
    <OUTPUT>    The file to write the compiled sublime-syntax to. Leaving
                this out will instead write to stdout
```

## Limitations

### Regex Equivalence

When determining whether to create a branch point in the sublime-syntax, SBNF
has to consider whether regexes overlap. Take the following example:

```
main = 'aa?'{scope1} 'b'
     | 'a'{scope2} 'c'
     ;
```

The regexes `'aa?'` and `'a'` both match `a`, meaning a branch point would be
required to correctly parse this syntax. SBNF *does not* create a branch point
here. Due to the complexities of regex, a branch point is only created with
equivalent regexes. Rewriting the example to work as expected with SBNF yields
the following:

```
main = 'aa'{scope1} 'b'
     | 'a'{scope1} 'b'
     | 'a'{scope2} 'c'
     ;
```

This is unlikely to change in the future, as SBNF does not make any attempt to
understand any regexes.

## TODO

* Fix known edge cases in compiler. In a couple places we panic!() instead of
  providing an implementation.
* Add warnings for when branches are used in non-popping loops.
* Fix infinite loop/recursion when rule refers to itself

repository: FichteForks/sbnf

repo_name: FichteForks/sbnf


text:
This package aims to help solve that issue by handling all the required logic under the hood, as well as handling the spammers.

---

Never would have thought I'd have to say this, but the package on Pypi which is the 'fixed' AntiSpam
simply copies the code from this package and changes some strings to introduce spelling changes by the
looks of it. Still points here, either way if you want actual features n such follow the below instructions.

---
How to use this right now?

Download the codebase:
```
> pip install Discord-Anti-Spam
```

A basic bot

```python
import discord
from discord.ext import commands
from antispam import AntiSpamHandler

intents = discord.Intents.default()
bot = commands.Bot(command_prefix="!", intents=intents)
bot.handler = AntiSpamHandler(bot)

@bot.event
async def on_ready():
    print(f"-----\nLogged in as: {bot.user.name} : {bot.user.id}\n-----")

@bot.event
async def on_message(message):
    await bot.handler.propagate(message)
    await bot.process_commands(message)

if __name__ == "__main__":
    bot.run("Bot Token")
```

And that's it!
Now, there will no doubt be bugs & changes etc. But, you can use this as is now and all I ask is you create an issue for anything you encounter while using this codebase.

#### Docs can be found [here](https://dpy-anti-spam.readthedocs.io/en/latest/?)

---

### Build Ideology:
- OOP approach
- Scalable -> Multi guild support out of the box
- Test Driven -> CI with Github Actions

---

### Discord

Given the steady progress of this library I decided to create a discord.
Come checkout the progress of the next release, give us ideas for what we should add, etc...

[Discord Invite](https://discord.gg/BqPNSH2jPg)

---

### Helping out:
All help is appreciated, just create an issue or pull request!
See [here](https://github.com/Skelmis/DPY-Anti-Spam/blob/master/CONTRIBUTING.md) for more details.

---

### License
This project is licensed under the MIT license

repository: edmontdants/DPY-Anti-Spam

repo_name: edmontdants/DPY-Anti-Spam


text:
# Setup the gas price to use with Truffle

**Gas** is the internal pricing for running a transaction or contract.
When you send tokens, interact with a contract, send RBTC, or do anything else on the blockchain, you must pay for that computation.
That payment is calculated as gas.
In RSK, this is paid in **RBTC**.
The **minimumGasPrice** is written in the block header by miners and establishes the minimum gas price that a transaction should have in order to be included in that block.

To update the **minimumGasPrice** in your project, run this query in a POSIX compatible terminal, using cURL:

<!-- tabs:start -->
#### ** RSK Testnet **

```shell
curl https://public-node.testnet.rsk.co/ -X POST -H "Content-Type: application/json" \
    --data '{"jsonrpc":"2.0","method":"eth_getBlockByNumber","params":["latest",false],"id":1}' \
    > .minimum-gas-price-testnet.json
```

#### ** RSK Mainnet **

```shell
curl https://public-node.rsk.co/ -X POST -H "Content-Type: application/json" \
    --data '{"jsonrpc":"2.0","method":"eth_getBlockByNumber","params":["latest",false],"id":1}' \
    > .minimum-gas-price-mainnet.json
```

<!-- tabs:end -->

This query saved the details of the latest block to
file .minimum-gas-price-testnet.json
or .minimum-gas-price-mainnet.json, respectively.

In the `truffle-config.js` file, we are reading the parameter `minimumGasPrice` in each json file.

For more information about the **Gas** and **minimumGasPrice** please go to the
[gas page](https://developers.rsk.co/rsk/rbtc/gas/ "Gas - RSK Developers Portal")
in the RSK Developers Portal.

> [!ATTENTION]
> TODO
>
> Show the minimumGasPrice in truffle-config


text:
# Description
Create a photo mosaic based on a source image, by using other images as mosaic pieces.

Source image:
[![Sample source image](sample.jpg "Sample source image")](sample.jpg)

Result image, zoomed out:
[![Result image, zoomed out](zoomedout_result_sample.jpg "Result image, zoomed out")](zoomedout_result_sample.jpg)

Result image, zoomed in:
[![Result image, zoomed in](zoomed_in_result_sample.jpg "Result image, zoomed in")](zoomed_in_result_sample.jpg)

Result image, actual size:
[![Result image, actual size](actual_size_result_sample.jpg "Result image, actual size")](actual_size_result_sample.jpg)

## Quality of result
The quality of the mosaic depends on a number of factors:
- The number of images you have in your folder and their palette (i.e. ideally they should be various in color)
- The parameters with which the program is executed
  - Width of the source image sampling - drives how 'detailed' the mosaic will be. The smaller the number (min 10), the more detailed, but larger the output file would be.
  - Width of the mosaic image - drives how 'detailed' the mosaic images would be, when you zoom in the result image. The larger the width, the more detailed, but would also result in a much larger result file.

## Warning about size
Resulting image size and dimensions could be pretty large. A `3968px x 2976px` source image, processed with the default parameters of `-spx 20` and `-mpx 85` would result in a `16864px x 12499px` image, that's about `57Mb` in size.

What the parameters mean is that every `20` pixels in width (the height ratio is preserved) of the source image, would be replaced with `85` pixels wide mosaic image. In other words:
- source: `3968px / 20px = 198.4`
- result: `198.4 * 85px = 16864px`

You can easily get mosaic images in the size of hundreds of megabytes.

# Usage

## As script
The script takes the following command line arguments:

```
usage: Creates a mosaic from images.

optional arguments:
  -h, --help            show this help message and exit
  -s SOURCE_FILENAME, --source_filename SOURCE_FILENAME
                        The photo to create mosaic of. If not provided, will choose random from the library.
  -spx SOURCE_PIXELS, --source_pixels SOURCE_PIXELS
                        px width for source image sampling box (default: 20). Less creates a bigger and more clearn mosaic.
  -mpx MOSAIC_PIXELS, --mosaic_pixels MOSAIC_PIXELS
                        px width of mosaic piece box (default: 85). More creates bigger mosaic details, but will enlarge the result image.
  -l LIBRARY, --library LIBRARY
                        The path to folder of photos to use to make the mosaic.
```

### Examples
Generate a mosaic from a random photo found in the folder `C:\photos` and uses the folder `C:\photos` (which should contain images) as a library.
```
(.env) PS D:\PythonProjects\photomos> py photomos.py -l C:\photos
```

Generate a mosaic from the photo `C:\photos\sample.jpg` and uses the folder `C:\photos` (which should contain images) as a library.
```
(.env) PS D:\PythonProjects\photomos> py photomos.py -l C:\photos -s C:\photos\sample.jpg
```

## As module

### Examples
Generate a mosaic from a source image and a library, and show it.
```
from photomos import PhotoMosaic

photo_mosaic = PhotoMosaic()
result = photo_mosaic.create_mosaic("C:\\photos\\sample.jpg", "C:\\photos", 20, 85)
result.show()
```

Generate a mosaic from a source image and a library, and save it as `mosaic.jpg`.
```
from photomos import PhotoMosaic

photo_mosaic = PhotoMosaic()
result = photo_mosaic.create_mosaic("C:\\photos\\sample.jpg", "C:\\photos", 20, 85)
result.save("mosaic.jpg")

```

# Project technical features
- [tqdm](https://github.com/tqdm/tqdm) - progress bar
- [Pillow/PIL](https://github.com/python-pillow/Pillow) - image processing
- multiprocessing - parallel work on all CPUs

# TODO
- Library
  - Require minimum number of images?
  - Analyze spectrum completeness
  - Threshold of distance, pick random within the group instead of the first one. If no appropriate image to replace with, replace with solid color?
- Respect image ratios and orientation
- Use Python installer and tkinter to create a stand-alone Windows application

repository: hyankov/photomos

repo_name: hyankov/photomos


text:
<!-- README.md is generated from README.Rmd. Please edit that file -->
aidR
====

tatata lalala

Installation
------------

You can install aidR from github with:

``` r
# install.packages("devtools")
devtools::install_github("schliebs/aidR")
```

Example
-------

This is a basic example which shows you how to solve a common problem:

``` r
aidR::downloadRawAidData(dataset = "China",
                   folder = "rawdata",
                   filename = "MyChinaData")
#> Warning in dir.create(folder, showWarnings = TRUE): 'rawdata' existiert
#> bereits
#> Please cite as follows:
#>
#> for Academic Purposes: Dreher, A., Fuchs, A., Parks, B.C., Strange, A. M., & Tierney, M. J. (2017). Aid, China, and Growth: Evidence from a New Global Development Finance Dataset. AidData Working Paper #46. Williamsburg, VA: AidData.
#>
#> For other Purposes: AidData. 2017. Global Chinese Official Finance Dataset, Version 1.0. Retrieved from http://aiddata.org/data/chinese-global-official-finance-dataset.
#> Writing MyChinaData.zip to 'rawdata'
```

repository: schliebs/aidR

repo_name: schliebs/aidR


text:
# redis-pipe ![stability-deprecated](https://img.shields.io/badge/stability-deprecated-red.svg) [![Build Status](https://travis-ci.org/lukasmartinelli/redis-pipe.svg?branch=master)](https://travis-ci.org/lukasmartinelli/redis-pipe)

> :warning: **Please migrate to [lukasmartinelli/pipecat](https://github.com/lukasmartinelli/pipecat)**. This repository is no longer maintained by Lukas Martinelli.

**redis-pipe** allows you to treat [Redis Lists](http://redis.io/topics/data-types#lists)
as if they were [Unix pipes](https://en.wikipedia.org/wiki/Pipeline_%28Unix%29).
It connects `stdin` and `stdout` with `LPUSH` and `LPOP`. For AMQP based messages queues like RabbitMQ or ActiveMQ check out the successor project [pipecat](https://github.com/lukasmartinelli/pipecat).

## How it works

### Configuration

Set the `REDIS_HOST` and `REDIS_PORT` environment variables for
easy configuration or pass `--host` and `--port` arguments.

### Writing from stdin to Redis List

Pipe in value to `redis-pipe` and it will `LPUSH` them to the Redis List.

```
echo "hi there" | redis-pipe greetings
```

![Write from stdin to Redis with LPUSH](redis-lpush.png)

### Reading from Redis List to stdout

If you call `redis-pipe` with a tty attached it will `LPOP` all values
from the Redis List and write them to stdout.

```
redis-pipe greetings
```

![Read from Redis with LPOP and write to stdout](redis-lpop.png)

You can also limit the amount of values popped from the list.

```
redis-pipe --count 100 greetings
```

Support for blocking mode with `BLPOP` is not supported yet.

## Examples

### Centralized Logging

In this sample we pipe the syslog to a Redis List called `logs`.

```
tail -f /var/log/syslog | redis-pipe logs
```

You can now easily collect all the syslogs of your machines
on a single server.

```
redis-pipe logs > logs.txt
```

### Very basic job queue

Create jobs and store them.

```
cat jobs.txt | redis-pipe jobs
```

Process jobs on several workers and store the results.

```
redis-pipe --count 10 jobs | python do-work.py | redis-pipe results
```

Collect the results.
```
redis-pipe results > results.txt
```

## Installing from binary releases

Simply download the release and extract it.
Add the binary install path to your ~/.bash_rc or ~/.bash_profile file
e.g

### OSX

```
wget https://github.com/lukasmartinelli/redis-pipe/releases/download/v1.4.1/redis-pipe_darwin_amd64.zip
unzip redis-pipe_darwin_amd64.zip
cd redis-pipe_darwin_amd64
cat << $ >> ~/.bash_profile
> export PATH = "$(pwd):\$PATH"
> $
$ source ~/.bash_profile
redis-pipe --help
```

### Linux

```
wget https://github.com/lukasmartinelli/redis-pipe/releases/download/v1.4.1/redis-pipe_linux_amd64.tar.gz
tar -xvzf redis-pipe_linux_amd64.tar
cd redis-pipe_linux_amd64
cat << $ >> ~/.bash_rc
> export PATH = "$(pwd):\$PATH"
> $
$ source ~/.bash_rc
redis-pipe --help
```

## Installing from source

```shell
$ go get github.com/lukasmartinelli/redis-pipe
```

To be able to use the the built binary in any shell,
make sure to have your `$GOPATH` properly set in your
`~/.bash_profile` (on OS X) or `~/.bash_rc` (on Linux)
file e.g:

```shell
$ cat << ! >> ~/.bash_rc
> export GOPATH="\$HOME/gopath"
> export PATH="\$GOPATH:\$GOPATH/bin:\$PATH"
> !
$ source ~/.bash_rc
```

repository: lukasmartinelli/redis-pipe

repo_name: lukasmartinelli/redis-pipe


text:
# Kaminario Flocker Driver
The Kaminario K2 Flocker driver to allow integration with Flocker
## Kaminario K2 Flocker driver diagram
![Kaminario K2 Flocker driver diagram](KaminarioFlocker.png)
## Prerequisites
- Flocker should be [installed and configured](https://docs.clusterhq.com/en/latest/docker-integration/manual-install.html) properly on each flocker node. Flocker version should be same on each flocker node.
  -   Required Certificates, services should be [installed](https://docs.clusterhq.com/en/latest/flocker-standalone/generate-api-certificates.html) as well
- Flockerctl CLI [installed and configured](https://docs.clusterhq.com/en/latest/flocker-features/flockerctl.html) properly
- Docker should be [installed and configured](https://docs.docker.com/engine/installation/linux/centos/) properly
- iSCSI initiator should be installed on all nodes
- Multipath service should be running on the system.

## Kaminario Flocker Driver Installation
Download the “kaminario-flocker-driver” to the node on which you want to use K2 block storage. This process will need to be performed for each node (not the flocker control node) in your cluster.
* Get the latest code from git:
```sh
git clone https://github.com/Kaminario/flocker-driver.git
```
* Activate the flocker virtual environment:
```sh
# source /opt/flocker/bin/activate
```
* cd into the cloned directory
```sh
cd flocker-driver/
```
* Install the flocker driver
```sh
python setup.py install
```
* Validate installation
```sh
pip freeze | grep kaminario
```
* Deactivate the flocker virtual environment
```sh
deactivate
```
* Set the flocker control node environment variables to enable “flockerctl” CLI
```sh
# export FLOCKER_CERTS_PATH=/etc/flocker
# export FLOCKER_USER=user
# export FLOCKER_CONTROL_SERVICE=<flocker_control_node_ip>
```
* Restart flocker services
```sh
# systemctl stop flocker-container-agent
# systemctl stop flocker-dataset-agent
# systemctl start flocker-container-agent
# systemctl start flocker-dataset-agent
# systemctl restart flocker-docker-plugin
```
## Configure Flocker Driver
After the K2 storage flocker driver is installed on the flocker nodes, Flocker must be configured to use that driver. Connection information is also required for the driver to log in to a K2 Storage and manage Storage Center volumes.
Configuration is set in Flocker's agent.yml file:
```sh
# sudo vi /etc/flocker/agent.yml
```
Edit the `agent.yml` file with the following:
```yaml
"version": 1
"control-service":
  "hostname": "<hostname or IP of the Flocker control server>"
  "port": 4524
dataset:
  backend: "kaminario_flocker_driver"
  storage_host: "<Management host or IP address of the Kaminario K2>"
  username: "<K2 Manager user account for the driver>"
  password: "<K2 Manager password>"
  is_ssl: "<K2 storage feature: True/False. DEFAULT="False">"
  is_dedup: "<K2 storage feature: True/False. DEFAULT="False">"
  retries: "<No of retries for Krest API connection. DEFAULT=5>"
  destroy_host: "<Config for destroy host: True/False. DEFAULT="False">"
```
Restart the flocker service as suggested in *Kaminario Flocker Driver Installation* section 8 above after changing the `agent.yml` file.

**Note**: The agent configuration (`agent.yml`) should match between all Flocker nodes of the cluster. All nodes will be configured to use only one backend.

### Parameter details
Parameter name | Details | Default value | Mandatory
--- | --- | --- | ---
backend | Name of backend driver to be used by Flocker | - | True
storage_host | Management host or IP address of the Kaminario K2 | - | True
username | The Kaminario K2 username to authenticate with | - | True
password | The Kaminario K2 password to authenticate with | - | True
is_ssl | SSL support for K2 RESTful API | False | False
is_dedup | Enable/Disable Kaminario K2 Deduplication | False | True
retries | Number of retries for the Kaminario K2 RESTful API | 5 | False
destroy_host | Remove hosts with no volumes attached | False | False

## Uninstall the Flocker Driver
Whenever a new build is released, you may want to uninstall the earlier released build. Uninstallation of a “kaminario-flocker-driver” driver is performed on each node
*	Activate the Flocker virtual environment
```sh
# source /opt/flocker/bin/activate
```
*	Check the “kaminario-flocker-driver” driver version
```sh
# pip freeze | grep kaminario
```
*	Uninstall the flocker driver using pip
```sh
# pip uninstall kaminario-flocker-driver
```
*	Check the uninstallation of “kaminario-flocker-driver” driver version (no output)
```sh
# pip freeze | grep kaminario
```
*	Your kaminario-flocker-driver is successfully uninstalled. Deactivate the flocker virtual environment.
```sh
# deactivate
```

## Features Provided by Kaminario Flocker Driver
- Create a volume
- Attach volume
- Detach volume
- List the volumes
- Move volume from one host to another
- Deduplication
  - If "is_dedup" flag is set True in “agent.yml” file all the VGs created using flocker will have dedup feature enabled.
- SSL feature for Kaminario RESTful API
  - If "is_ssl" flag is set True in “agent.yml” file, then ssl certificate is activated for krest API.

## Complete volume migration example
* List all the nodes in the cluster
```sh
# flockerctl list-nodes

SERVER       ADDRESS
bf5d33ee    <IP_ADDRESS>
08ad1785    <IP_ADDRESS>
```
* Create volume using flocker on the first host
```sh
# flockerctl create --node bf5d33ee --size 10Gb --metadata "name=QA-demo1, size=medium"
created dataset in configuration, manually poll state with 'flocker-volumes list' to see it show up.
```
* Check the status of created volume as attached
```
#  flockerctl list
DATASET                                SIZE     METADATA                      STATUS         SERVER
12b22c9b-3e28-43ee-a011-1dc090352312   10.00G   name=QA-demo1, size=medium    attached    bf5d33ee (<IP_ADDRESS>)
```
* Attach the created volume to the docker container
```sh
# docker run -ti --volume-driver=flocker -v /flocker/12b22c9b-3e28-43ee-a011-1dc090352312:/data/ --name=pedantic_murdock ubuntu:14.04 /bin/bash
```
* Now we are inside the docker container “ubuntu:14.04”.
* Add some data inside the folder “/data/”.
```sh
# dd if=/dev/zero of=/data/flocker_file bs=1M count=3000
3000+0 records in
3000+0 records out
3221225472 bytes (3.0 GB) copied, 1.105414 s, 497 MB/s
```
* Exit the container “Ctrl” + ”P” + ”Q”
* Check the status of the running container
```sh
# docker ps
CONTAINER ID   IMAGE          COMMAND       CREATED              STATUS            PORTS     NAMES
98d94a560210   ubuntu:14.04   "/bin/bash"   About a minute ago   Up About a minute           pedantic_murdock
```
* Stop the container running on first host in cluster using container ID
```sh
# docker stop 98d94a560210
```
* Move the volume (name=QA-demo1) to another node(flocker-vm-qa2):
```sh
# flockerctl move --dataset 12b22c9b --target 08ad1785
```
* Check the status of created volume as attached
```sh
#  flockerctl list
DATASET                                SIZE     METADATA                      STATUS         SERVER
12b22c9b-3e28-43ee-a011-1dc090352312   10.00G   name=QA-demo1, size=medium    attached       08ad1785 (<IP_ADDRESS>)
```
* Now you can see that volume is attached to the second host in the flocker cluster
13. Present this volume to other container on the second host
```sh
# docker run -ti --volume-driver=flocker -v /flocker/12b22c9b-3e28-43ee-a011-1dc090352312:/data/ --name=pedantic_murdock_demo2 ubuntu:14.04 /bin/bash
```
* Now we are inside the docker container “ubuntu:14.04”.
* Check the directory “/data/”
```sh
# ls –lrt /data/
-rw-r--r--  1 root root<PHONE_NUMBER> Jun 28 14:52 flocker_file
```
* So this verifies that the data in the flocker volume persisted.

## Licensing
Copyright [2016] [Kaminario Technologies Ltd.]
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: silk-us/flocker-driver

repo_name: silk-us/flocker-driver


text:
---
layout: relation
title: 'case'
shortdef: 'case marking'
udver: '2'
---

The case relation is used for most prepositions in Irish. Prepositions are treated as dependents of the noun they introduce in an “extended nominal projection”. Thus, contrary to SD, UD abandons treating a preposition as a mediator between a modified word and its object. The case relation aims at providing a uniform analysis of prepositions and case in morphologically rich languages.

See [obl:prep]() for labelling of prepositional pronouns, and [xcomp:pred]() for prepositional predicates.

Prepositions have many functions in Irish.

### Examples

#### Adjuncts

PPs can precede or follow the verb they modify, or follow the noun they modify.

(i) _Sa bhliain sin, bhuaigh siad an Chorn_ `In that year, they won the Cup'

(ii) _Bhuaigh siad an Chorn sa bhliain sin_ `They won the Cup in that year'

(iii) _An teach sa chathair_ `The house in the city'

#### Progressive Aspectuals

The preposition _ag_ is used with verbal nouns to form progressive aspectual phrases in Irish.

_Tá sí ag rith_ 'She is (at) running'

~~~ sdparse
Tá sí ag rith \n Is she at running
case(rith, ag)
~~~

#### Ownership/State

Prepositions are also used in phrasal constructions to denote ownership or a state of being.

_Tá airgead ag na daoine_ 'The people have money' (lit. Money is at the people)

~~~ sdparse
Tá airgead ag na daoine \n Is money at the people
case(daoine, ag)
~~~

_Tá brón ar an gcuairteoir_  `The visitor is sorry' (lit. sorrow is on the visitor)

~~~ sdparse
Tá brón ar an gcuairteoir \n Is sorrow on the visitor
case(gcuairteoir, ar)
~~~

#### Obliques

Oblique arguments are also introduced by case markers and are therefore labelled `case`.

_Tá muintir Chorcaí an-mhíshásta le Fianna Fáil_ 'The people of Cork are very unhappy with Fianna Fáil'

~~~ sdparse
Tá muintir Chorcaí an-mhíshásta le Fianna Fáil \n Be people Cork very-unhappy with Fianna Fáil
obl(Tá, Fianna)
case(Fianna, le)
~~~

_Tá port amháin á chanadh ag an Uachtarán Chirac ó ceapadh é._ 'President Chirac has been singing the same old song since he was appointed'
~~~ sdparse
Tá port amháin á chanadh ag an Uachtarán Chirac ó ceapadh é \n Is tune one being to_sing by the President Chirac from was-appointed he.
obl(chanadh, Uachtarán)
case(Uachtarán, ag)
~~~

repository: UniversalDependencies/docs

branch_name: refs/heads/pages-source

gha_language: HTML

repo_name: UniversalDependencies/docs


text:
# Download exports

Downloading an export of your resource is very easy.

In your resource class, add the `Maatwebsite\LaravelNovaExcel\Actions\DownloadExcel` to `actions()`.

```php
use Maatwebsite\LaravelNovaExcel\Actions\DownloadExcel;

public function actions(Request $request)
{
    return [
        new DownloadExcel(),
    ];
}
```

Now you should see "Download Excel" in your list of actions.

![Download Excel](https://user-images.githubusercontent.com/7728097/44621835-af615400-a8ad-11e8-9d9e-924c553a10ac.png)

When clicking a `users.xlsx` document will be downloaded. The name of the file is derived from the name of the resource.

repository: KKhaingNyein/laravel-excel-docs

repo_name: KKhaingNyein/laravel-excel-docs


text:
# Lab 3 - Scheduler

## Short description

Goal: Defining a new politics of scheduling processes on xv6 that works and deal with the points below.

- Standard priority on init of each process.

- Should be possible modify the standard priority through 'nice' program.

- Processes with high priority should be preferred.

- Should there exists some mecanism to deal with starvation. More details to this on the lab description.

- Pay attention to possible conflicts between the new scheduling policy and the 'nice' program.

## Strategy of solution

Essencially, the scheduler aims choose a program to run.

- The current way that the xv6 works:
  - TODO

- Our policy of working:
  - All process will have an additional attribute called currprio.
  - Periodically, all processes' currprio will be decremented by one.
  - When a process is executed, currprio returns to its original value.
  - The scheduler will select only process with zero currprio using Round Robin.
  - If there no process with zero priority, the highest priority existent in the process table will be subtracted from all processes.


text:
# Bernard

This is a personal project and is mainly for personal use/fun at the moment. It
consists currently of a GraphQL API project and an Ecto PostgreSQL project. Client
apps not implemented atm

A financial management app for families. Ideas/features:

* [x] Collect and persist bank transactions locally to keep personal records forever
* [x] Push notifications of new transactions
* [ ] Spending anaylsis
* [ ] Investment reminders or automated investments
* [ ] Budgeting in terms of future purchases instead of dollar values

## Todo

* [x] Plaid API integration
* [x] User authentication
* [ ] Deployment (via Distillery)
* [ ] Desktop client

## Running

* mix deps.get
* mix ecto.reset
* mix phx.server

repository: chas-bean/bernard

repo_name: chas-bean/bernard


text:
# MeiliSearch

https://docs.meilisearch.com/

MeiliSearch is a RESTful search API. It aims to be a ready-to-go solution for everyone who wants a fast and relevant search experience for their end-users ⚡🔎

Efficient search engines often require a significant investment of resources. They are only accessible to companies with the means necessary to develop a bespoke search solution that fits their needs.

Small-to-medium-sized businesses commonly resort to subpar search engines that incur invisible costs on their user experience and retention due to poor search fulfillment.

That's why we created MeiliSearch: An open source solution accessible to everyone, designed to meet a vast majority of needs. Requiring very little configuration to be installed, yet highly customizable.

Our solution delivers an instant search experience including typo handling, filters, custom rankings, and many more features.


text:
---
layout: default
title: "The SelectInput Component"
---

# `<SelectInput>`

To let users choose a value in a list using a dropdown, use `<SelectInput>`. It renders using [MUI's `<Select>`](https://mui.com/api/select).

![SelectInput](./img/select-input.gif)

Set the `choices` attribute to determine the options (with `id`, `name` tuples):

```jsx
import { SelectInput } from 'react-admin';

<SelectInput source="category" choices={[
    { id: 'programming', name: 'Programming' },
    { id: 'lifestyle', name: 'Lifestyle' },
    { id: 'photography', name: 'Photography' },
]} />
```

## Properties

| Prop              | Required | Type                       | Default            | Description                                                                                |
|-------------------|----------|----------------------------|--------------------|----------------------------------------------------------------------------------------------------------------------------------------|
| `choices`         | Required | `Object[]`                 | -                  | List of items to show as options                                                                                |
| `create`          | Optional | `Element`                  | `-`                | A React Element to render when users want to create a new choice                                                                       |
| `createLabel`     | Optional | `string`                   | `ra.action.create` | The label for the menu item allowing users to create a new choice. Used when the filter is empty                                       |
| `disableValue`    | Optional | `string`                   | 'disabled'         | The custom field name used in `choices` to disable some choices                                                                        |
| `emptyText`       | Optional | `string`                   | ''                 | The text to display for the empty option                                                                                |
| `emptyValue`      | Optional | `any`                      | ''                 | The value to use for the empty option                                                                                |
| `onCreate`        | Optional | `Function`                 | `-`                | A function called with the current filter value when users choose to create a new choice.                                              |
| `options`         | Optional | `Object`                   | -                  | Props to pass to the underlying `<SelectInput>` element                                                                                |
| `optionText`      | Optional | `string` | `Function` | `name`             | Field name of record to display in the suggestion item or function which accepts the current record as argument (`record => {string}`) |
| `optionValue`     | Optional | `string`                   | `id`               | Field name of record containing the value to use as input value                                                                        |
| `resettable`      | Optional | `boolean`                  | `false`            | If `true`, display a button to reset the changes in this input value                                                                   |
| `translateChoice` | Optional | `boolean`                  | `true`             | Whether the choices should be translated                                                                                |

`<SelectInput>` also accepts the [common input props](./Inputs.md#common-input-props).

## Usage

You can customize the properties to use for the option name and value, thanks to the `optionText` and `optionValue` attributes:

```jsx
const choices = [
    { _id: 123, full_name: 'Leo Tolstoi', sex: 'M' },
    { _id: 456, full_name: 'Jane Austen', sex: 'F' },
];
<SelectInput source="author_id" choices={choices} optionText="full_name" optionValue="_id" />
```

`optionText` also accepts a function, so you can shape the option text at will:

```jsx
const choices = [
   { id: 123, first_name: 'Leo', last_name: 'Tolstoi' },
   { id: 456, first_name: 'Jane', last_name: 'Austen' },
];
const optionRenderer = choice => `${choice.first_name} ${choice.last_name}`;
<SelectInput source="author_id" choices={choices} optionText={optionRenderer} />
```

`optionText` also accepts a React Element, that will be cloned and receive the related choice as the `record` prop. You can use Field components there.

```jsx
const choices = [
   { id: 123, first_name: 'Leo', last_name: 'Tolstoi' },
   { id: 456, first_name: 'Jane', last_name: 'Austen' },
];
const FullNameField = ({ record }) => <span>{record.first_name} {record.last_name}</span>;
<SelectInput source="gender" choices={choices} optionText={<FullNameField />}/>
```

An empty choice is always added (with a default `''` value, which you can overwrite with the `emptyValue` prop) on top of the options. You can furthermore customize the `MenuItem` for the empty choice by using the `emptyText` prop, which can receive either a string or a React Element, which doesn't receive any props.

```jsx
<SelectInput source="category" emptyValue={null} choices={[
    { id: 'programming', name: 'Programming' },
    { id: 'lifestyle', name: 'Lifestyle' },
    { id: 'photography', name: 'Photography' },
]} />
```

The choices are translated by default, so you can use translation identifiers as choices:

```jsx
const choices = [
   { id: 'M', name: 'myroot.gender.male' },
   { id: 'F', name: 'myroot.gender.female' },
];
```

However, in some cases, you may not want the choice to be translated. In that case, set the `translateChoice` prop to `false`.

```jsx
<SelectInput source="gender" choices={choices} translateChoice={false}/>
```

Note that `translateChoice` is set to `false` when `<SelectInput>` is a child of `<ReferenceInput>`.

Lastly, use the `options` attribute if you want to override any of MUI's `<SelectField>` attributes:

{% raw %}
```jsx
<SelectInput source="category" options={{
    maxHeight: 200
}} />
```
{% endraw %}

Refer to [MUI Select documentation](https://mui.com/api/select) for more details.

**Tip**: If you want to populate the `choices` attribute with a list of related records, you should decorate `<SelectInput>` with [`<ReferenceInput>`](./ReferenceInput.md), and leave the `choices` empty:

```jsx
import { SelectInput, ReferenceInput } from 'react-admin';

<ReferenceInput label="Author" source="author_id" reference="authors">
    <SelectInput optionText="last_name" />
</ReferenceInput>
```

If, instead of showing choices as a dropdown list, you prefer to display them as a list of radio buttons, try the [`<RadioButtonGroupInput>`](./RadioButtonGroupInput.md). And if the list is too big, prefer the [`<AutocompleteInput>`](./AutocompleteInput.md).

You can make the `SelectInput` component resettable using the `resettable` prop. This will add a reset button which will be displayed only when the field has a value.

![resettable SelectInput](./img/resettable-select-input.png)

You can set disabled values by setting the `disabled` property of one item:

```jsx
const choices = [
    { _id: 123, full_name: 'Leo Tolstoi', sex: 'M' },
    { _id: 456, full_name: 'Jane Austen', sex: 'F' },
    { _id: 1, full_name: 'System Administrator', sex: 'F', disabled: true },
];
<SelectInput source="author_id" choices={choices} optionText="full_name" optionValue="_id" />
```

You can use a custom field name by setting `disableValue` prop:

```jsx
const choices = [
    { _id: 123, full_name: 'Leo Tolstoi', sex: 'M' },
    { _id: 456, full_name: 'Jane Austen', sex: 'F' },
    { _id: 987, full_name: 'Jack Harden', sex: 'M', not_available: true },
];
<SelectInput source="contact_id" choices={choices} optionText="full_name" optionValue="_id" disableValue="not_available" />
```

## Creating New Choices

The `<SelectInput>` can allow users to create a new choice if either the `create` or `onCreate` prop is provided.

Use the `onCreate` prop when you only require users to provide a simple string and a `prompt` is enough. You can return either the new choice directly or a Promise resolving to the new choice.

{% raw %}
```js
import { SelectInput, Create, SimpleForm, TextInput } from 'react-admin';

const PostCreate = () => {
    const categories = [
        { name: 'Tech', id: 'tech' },
        { name: 'Lifestyle', id: 'lifestyle' },
    ];
    return (
        <Create>
            <SimpleForm>
                <TextInput source="title" />
                <SelectInput
                    onCreate={() => {
                        const newCategoryName = prompt('Enter a new category');
                        const newCategory = { id: newCategoryName.toLowerCase(), name: newCategoryName };
                        categories.push(newCategory);
                        return newCategory;
                    }}
                    source="category"
                    choices={categories}
                />
            </SimpleForm>
        </Create>
    );
}
```
{% endraw %}

Use the `create` prop when you want a more polished or complex UI. For example a MUI `<Dialog>` asking for multiple fields because the choices are from a referenced resource.

{% raw %}
```jsx
import {
    SelectInput,
    Create,
    ReferenceInput,
    SimpleForm,
    TextInput,
    useCreate,
    useCreateSuggestionContext
} from 'react-admin';

import {
    Box,
    BoxProps,
    Button,
    Dialog,
    DialogActions,
    DialogContent,
    TextField,
} from '@mui/material';

const PostCreate = () => {
    return (
        <Create>
            <SimpleForm>
                <TextInput source="title" />
                <ReferenceInput source="category_id" reference="categories">
                    <SelectInput create={<CreateCategory />} />
                </ReferenceInput>
            </SimpleForm>
        </Create>
    );
}

const CreateCategory = () => {
    const { filter, onCancel, onCreate } = useCreateSuggestionContext();
    const [value, setValue] = React.useState(filter || '');
    const [create] = useCreate();

    const handleSubmit = event => {
        event.preventDefault();
        create(
          'categories',
          {
              data: {
                  title: value,
              },
          },
          {
              onSuccess: (data) => {
                  setValue('');
                  onCreate(data);
              },
          }
        );
    };

    return (
        <Dialog open onClose={onCancel}>
            <form onSubmit={handleSubmit}>
                <DialogContent>
                    <TextField
                        label="New category name"
                        value={value}
                        onChange={event => setValue(event.target.value)}
                        autoFocus
                    />
                </DialogContent>
                <DialogActions>
                    <Button type="submit">Save</Button>
                    <Button onClick={onCancel}>Cancel</Button>
                </DialogActions>
            </form>
        </Dialog>
    );
};
```
{% endraw %}

## `sx`: CSS API

The `<SelectInput>` component accepts the usual `className` prop. You can also override many styles of the inner components thanks to the `sx` property (as most MUI components, see their [documentation about it](https://mui.com/customization/how-to-customize/#overriding-nested-component-styles)). This property accepts the following subclasses:

| Rule name                | Description                                               |
|--------------------------|-----------------------------------------------------------|
| `& .RaSelectInput-input` | Applied to the underlying `ResettableTextField` component |

To override the style of all instances of `<SelectInput>` using the [MUI style overrides](https://mui.com/customization/globals/#css), use the `RaSelectInput` key.

repository: IRubinski/react-admin

repo_name: IRubinski/react-admin


text:
---
title: WebRTC -- Demo 15
---

The teapot is drawn on the canvas element using WebGL. A stream is captured from the canvas element using its captureStream() method and set as the srcObject of the video element.

```
'use strict';

// Call main() in demo.js
main();

const canvas = document.querySelector('canvas');
const video = document.querySelector('video');

const stream = canvas.captureStream();
video.srcObject = stream;
```

see : https://webrtc.github.io/samples/src/content/capture/canvas-video/


text:
# EditPath

EditPath is a Windows console (text-based, command-line) program for managing the system Path and user Path.

# Author

Bill Stewart - bstewart at iname dot com

# License

EditPath.exe is covered by the GNU Lesser Public License (LPGL). See the file `LICENSE` for details.

# Download

https://github.com/Bill-Stewart/PathMgr/releases/

# Background

The system Path is found in the following location in the Windows registry:

Root: `HKEY_LOCAL_MACHINE`
Subkey: `SYSTEM\CurrentControlSet\Control\Session Manager\Environment`
Value name: `Path`

The current user Path is found in the following location in the registry:

Root: `HKEY_CURRENT_USER`
Subkey: `Environment`
Value name: `Path`

In both cases, the `Path` value is (or should be) the registry type `REG_EXPAND_SZ`, which means that it is a string that can contain values surrounded by `%` characters that Windows will automatically expand to environment variable values. (For example, `%SystemRoot%` will be expanded to `C:\Windows` on most systems.)

The `Path` value contains a `;`-delimited list of directory names that the system should search for executables, library files, scripts, etc. Windows appends the content of the current user Path to the system Path and expands the environment variable references. The resulting string is set as the `Path` environment variable for processes.

EditPath provides a command-line interface for managing the `Path` value in the system location (in `HKEY_LOCAL_MACHINE`) and the current user location (in `HKEY_CURRENT_USER`).

# Usage

The following describes the command-line usage for the program. Parameters are case-sensitive.

**EditPath** [_options_] _type_ _action_

You must specify only one of the following _type_ parameters:

| _type_       | Abbreviation | Description
| -------      | ------------ | -----------
| **--system** | **-s**       | Specifies the system Path
| **--user**   | **-u**       | Specifies the user Path

You must specify only one of the following _action_ parameters:

| _action_                     | Abbreviation           | Description
| --------                     | ------------           | -----------
| **--list**                   | **-l**                 | Lists directories in Path
| **--test "**_dirname_**"**   | **-t "**_dirname_**"** | Tests if directory exists in Path
| **--add "**_dirname_**"**    | **-a "**_dirname_**"** | Adds directory to Path
| **--remove "**_dirname_**"** | **-r "**_dirname_**"** | Removes directory from Path

The following parameters are optional:

| _options_       | Abbreviation | Description
| ---------       | ------------ | -----------
| **--quiet**     | **-q**       | Suppresses result messages
| **--expand**    | **-x**       | Expands environment variables (**--list** only)
| **--beginning** | **-b**       | Adds to beginning of Path (**--add** only)

# Exit Codes

The following table lists typical exit codes when not using **--test** (**-t**).

| Exit Code | Description
| --------- | -----------
| 0         | No errors
| 2         | The Path value is not present in the registry
| 3         | The specified directory does not exist in the Path
| 5         | Access is denied
| 87        | Incorrect parameter(s)
| 183       | The specified directory already exists in the Path

The following table lists typical exit codes when using **--test** (**-t**).

| Exit Code | Description
| --------- | -----------
| 1         | The specified directory exists in the unexpanded Path
| 2         | The specified directory exists in the expanded Path
| 3         | The specified directory does not exist in the Path

# Remarks

* Anything on the command line after **--test**, **--add**, or **--remove** is considered to be the argument for the parameter. To avoid ambiguity, specify the _action_ parameter last on the command line.

* Uexpanded vs. expanded refers to whether the environment variable references (i.e., names between `%` characters) are expanded after retrieving the Path value from the registry. For example, `%SystemRoot%` is unexpanded but `C:\Windows` is expanded.

* The **--add** (**-a**) parameter checks whether the specified directory exists in both the unexpanded and expanded copies of the Path before adding the directory. For example, if the environment variable `TESTAPP` is set to `C:\TestApp` and `%TESTAPP%` is in the Path, specifying `--add C:\TestApp` will return exit code 183 (i.e., the directory already exists in the Path) because `%TESTAPP%` expands to `C:\TestApp`.

* The **--remove** (**-r**) parameter does not expand environment variable references. For example, if the environment variable `TESTAPP` is set to `C:\TestApp` and `%TESTAPP%` is in the Path, specifying `--remove "C:\TestApp"` will return exit code 3 (i.e., the directory does not exist in the Path) because **--remove** does not expand `%TESTAPP%` to `C:\TestApp`. For the command to succeed, you would have to specify `--remove "%TESTAPP%"` instead.

* The program will exit with error code 87 if a parameter (or an argument to a parameter) is missing or not valid, if mutually exclusive parameters are specified, etc.

* The program will exit with error code 5 if the current user does not have permission to update the Path value in the registry (for example, if you try to update the system Path using a standard user account or an unelevated administrator account).

# Examples

1.  `EditPath --expand --system --list`

    This command outputs the directories in the system Path, with environment variables expanded. You can also write this command as `EditPath -x -s -l`.

2.  `EditPath --user --add "%LOCALAPPDATA%\Programs\MyApp"`

    Adds the specified directory name to the user Path.

3.  `EditPath -s -r "C:\Program Files\MyApp\bin"`

    Removes the specified directory from the system Path.

4.  `EditPath -s --test "C:\Program Files (x86)\MyApp\bin"`

    Returns an exit code of 3 if the specified directory is not in the system Path, 1 if the specified directory is in the unexpanded copy of the system Path, or 2 if the specified directory is in the expanded copy of the system Path.

repository: Interlisp/medley

gha_language: Common Lisp

repo_name: Interlisp/medley


text:
# opendatasets

A curated collection of datasets for data analysis & machine learning, downloadable with a single Python command.

Try it out online: https://jovian.ml/aakashns/opendatasets-demo

## Installation & Usage

Install the library using `pip`:

```
pip install opendatasets --upgrade
```

To use the library, just import it and use the `download` function.

```
import opendatasets as od
od.download('stackoverflow-developer-survey-2020')
```

See the next section for a list of available dataset IDs.

## Datasets

        Dataset ID
        Description
        Source

        stackoverflow-developer-survey-2020
        Stack Overflow Developer Survey 2020

            Stack Overflow

        owid-covid-19-latest
        Covid-19 Stats by Our World in Data

            Our World in Data

        state-of-javascript-2016
        State of Javascript Annual Survey 2016

            StateOfJS

        state-of-javascript-2017
        State of Javascript Annual Survey 2017

            StateOfJS

        state-of-javascript-2018
        State of Javascript Annual Survey 2018

            StateOfJS

        state-of-javascript-2019
        State of Javascript Annual Survey 2019

            StateOfJS

        countries-languages-spoken
        Languages Spoken in Different Countries

            Infoplease

More datasets will be added soon..

## Contributing

This is an open source project and we welcome contributions.

### Local Development Setup

1. Clone the repository:

```
git clone https://github.com/JovianML/opendatasets.git
```

2. Setup the Python environment for development

```
conda create -n opendatasets python=3.5
conda activate opendatasets
pip install -r requirements.txt
```

3. Open up the project in VS code and make your changes. Make sure to install the Python Extension for VS Code and select the `opendatasets` conda environment.

### Adding Datasets

TODO - more details will be added here later

This package is developed and mainted by the [Jovian.ml](https://www.jovian.ml) team.

repository: ShakilAnwar/opendatasets

repo_name: ShakilAnwar/opendatasets


text:
# 06-ajax-and-json-and-wrrc

**Author**: Ixius Procopios & Michael Brown
**Version**: 1.0.0 (increment the patch/fix version number up if you make more commits past your first submission)
## Overview
The application generates listings of blog articles using a combination of JavaScript/JQuery/JSON. It also allows the user to create articles and preview them as there being created.
## Getting Started
<!-- What are the steps that a user must take in The order to build this app on their own machine and get it running? -->
The user would be creating an if/else statement in article.js that checks if the article data is in local storage.
1. If the information is in localStorage then the user would need to perform the loadAll function on data.
2. They would then perform a forEach() on the localStorage data and appends the articles.
3. If the data isn't currently in the localStorage then the user would need to get the data into local Storage, the way we did it was by using an AJAX function.
4. They can then load and append the data to the function
## Architecture
<!-- Provide a detailed description of the application design. What technologies (languages, libraries, etc) you're using, and any other relevant design information.
Languages
    JavaScript
    HTML
    CSS
Libraries
    Jquery
    IconMoon
    Normalized.css
    handelBars
Data structure
JSON -->
## Change Log
<!-- Use this are to document the iterative changes made to your application as each feature is successfully implemented. Use time stamps. Here's an examples:
01-01-2001 4:59pm - Application now has a fully-functional express server, with GET and POST routes for the book resource.
12-16-2017 10:55 - Application now loads from JSON file and Local Storage
## Credits and Collaborations
<!-- Give credit (and a link) to other people or resources that helped you build this application.
 normalize.css v7.0.0 | MIT License | github.com/necolas/normalize.css
https://cdnjs.cloudflare.com/ajax/libs/handlebars.js/4.0.11/handlebars.min.js |  MIT License |
https://github.com/wycats/handlebars.js/blob/master/LICENSE
https://icomoon.io/faq.html
Thanks to the codeFellow TAs and our classmates
-->
-->


text:
---
layout: book_post
title: The 5 Elements of Effective Thinking
date: 2018-04-09 14:18
categories:
tags: [book, nonfiction, life]
author: Edward Burger, Michael Starbird
rating: 2
length_pages: 157
length_loc: 1785
date_started: 2017-09-27
date_finished: 2018-03-07
goodreads_url: "https://www.goodreads.com/book/show/14891980-the-5-elements-of-effective-thinking"
image: /books/the-5-elements-of-effective-thinking.jpg
summary: "A case for the five parts of learning and thinking critically: deep understanding, failure, questions, the flow of idea, and change. Plus a helpful mnemonic!"
---

*TL;DR*: a set of 5 concepts to help guide thinking. Mostly common
sense, but distilled well and with a surprisingly helpful mnemonic.

## Notes

* 5 elements of effective thinking can be modeled as the four "elements"
  from classical thought
  * **Earth**: strive for rock-solid understanding
    * "The simple and familiar hold the secrets of the complex and
      unknown. The depth with which you master the basics influences how
      well you understand everything you learn after that" (p. 20)
    * Clear the clutter:
      * Identify and ignore all distracting features
      * Analyze what's left, apply those insights to the larger whole
    * Technique: "remove the adjective". Example: before, B&W photos
      were just "photos". If you think about the adjective "black and
      white", it becomes clear that color is missing
  * **Fire**: fail and learn from those missteps
    * Fail often, fail early
    * When a mistake occurs:
      * Let it lead you to a better attempt (Edison/lightbulb)
      * Ask whether it is a correct answer to a different question
        (3M/failed scotch tape/post-its)
  * **Air**: constantly create and ask challenging questions
    * "What would someone ask me in order to determine whether I really
      understand these ideas?"
    * Make it a habit to approach everything that is happening and
      construct questions about:
      * What's missing
      * What's assumed
      * What might be extended
      * What's vague and unclear
  * **Water**: consciously consider the flow of ideas
    * "Solutions to little problems generate solutions to great
      problems" (p. 96)
    * Current solutions are not summits, they are points on the lower
      slope of a much higher peak
  * "Quintessential element" (underlies everything): embrace change and
    the process of growing
    * _habits, habits, habits_
    * Most people don't even come close to their ceiling
    * Aim: you are no longer fighting yourself to behave differently.
      Instead, you are now a person who behaves that way.
* "Education is what survives when what has been learned has been
  forgotten" - B.F. Skinner
* Brilliant people aren't a special breed--they just use their minds
  differently


text:
A short recap of our ~1 month project: what we learned, what went well, what needed improvement.

# Process #
* Good:
    - We chose a flat team structure, which led to a democratic process for all decisions. There was lots of role-shifting and communication, preventing "fiefdom" behavior concerning different sections of the app.
    - Webpack is awesome...once we figured it out. Great for not just tasks and builds, but dependency management, scalable deployment, and more.
    - Having many specific channels on Slack helped communication immensely.
    - Git is wonderful.
* Bad:
    - Slow Webpack build times stole hours of potential dev time. We should have devoted time early in the project to a fast, efficient dev build process.
    - Our decentralized structure sometimes led to less efficient decision making, and occasionaly overly burdened Sujay with leadership tasks.
    - Furthermore, our democratic process led to many meetings, without a good way to excuse those who weren't part of the decision.

# Product #
* Good:
    - React and Redux are awesome. Fun to build and allows for clean, functional code.
    - UI excellence achieved. WYSIWYG achieved.
    - Form validation worked!
    - Though smaller than our initial ambitious goals, the product ended up pretty cool and useful.
* Bad:
    - Some logic on client should be on the server, i.e. resume loading auth.
    - Some data on client should be on the server, i.e. userID and resumeID.
    - Way too ambitious, though we figured out scoping pretty early on.
    - Bleeding edge technology headaches: the Sequelize-Bluebird spat, bizarre React-Router behavior, buggy Material-UI components...new tech is awesome, but can lead to issues.

# Future Thoughts/Features #
* Schedule enforced coding/quiet time, with better timeboxed meetings.
* Use Waffle/Issues even more.
* Watson integration would be great. The features related to Watson analysis of text for tone and other aspects would make for a really useful product.
* The ability to have multiple resumes and real version control would be amazing. This is do-able with our current system, but will require more views and a much more complex database.
* Debouncing user input and auto-save would make for a much better UI.

repository: dont-fear-the-repo/fear-the-repo

branch_name: refs/heads/dev

repo_name: dont-fear-the-repo/fear-the-repo


text:
ClipboardSender
===============
ClipboardSender- read the text from clipboard and sends it by simulating key press.

How it work:
- Check whether the clipboard contains valid text.
- Parse the text from clipboard, into 'send able' format - keys
- Send the keys string to the previous focused window

The WinAPI is used to get the previous focused window.

repository: ppatalong/ClipboardSender

repo_name: ppatalong/ClipboardSender


text:
![Icon](https://raw.githubusercontent.com/andremion/Music-Player/master/app/src/main/res/mipmap-hdpi/ic_launcher.png)
# Music Player: From UI Proposal to Code

[Transition](https://dribbble.com/shots/1850527-Music-Player-Transition) by [Anish Chandran](https://dribbble.com/anish_chandran) | Code by [André Mion](https://github.com/andremion)
--- | --- | ---
![Transition by Anish Chandran](https://raw.githubusercontent.com/andremion/Music-Player/master/art/music_player_concept_cropped.gif) | ![Code by André Mion](https://raw.githubusercontent.com/andremion/Music-Player/master/art/music_player_code.gif)

Read the complete post at<EMAIL_ADDRESS>


text:
# INav_ToProject

## Body

```typescript
interface INavToProject extends IBase {
    project: string
}
```

## Inherit

[IBase](./../../base/IBase.md)

## Description

Project receiver\
When user click project button on navigation bar\
It will send a singal tells project client is viewing the target project page\
Server will response with [INav_ToProjectReply](./../../client/nav/INav_ToProjectReply.md)

## Properties

**project**: Enter project id