text:
# Trained image classification models for Keras

This repository contains code and weights files for the following Keras models:

- VGG16
- VGG19
- ResNet50

We plan on adding Inception v3 soon.

All architectures are compatible with both TensorFlow and Theano, and upon instantiation the models will be built according to the image dimension ordering set in your Keras configuration file at `~/.keras/keras.json`. For instance, if you have set `image_dim_ordering=tf`, then any model loaded from this repository will get built according to the TensorFlow dimension ordering convention, "Width-Height-Depth".

Weights can be automatically loaded upon instantiation (`weights='imagenet'` argument in model constructor). Weights are automatically downloaded if necessary, and cached locally in `~/.keras/models/`.

## Examples

### Classify images

```python
from resnet50 import ResNet50
from keras.preprocessing import image
from imagenet_utils import preprocess_input, decode_predictions

model = ResNet50(weights='imagenet')

img_path = 'elephant.jpg'
img = image.load_img(img_path, target_size=(224, 224))
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)

preds = model.predict(x)
print('Predicted:', decode_predictions(preds))
# print: [[u'n02504458', u'African_elephant']]
```

### Extract features from images

```python
from vgg16 import VGG16
from keras.preprocessing import image
from imagenet_utils import preprocess_input

model = VGG16(weights='imagenet', include_top=False)

img_path = 'elephant.jpg'
img = image.load_img(img_path, target_size=(224, 224))
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)

features = model.predict(x)
```

### Extract features from an arbitrary intermediate layer

```python
from vgg19 import VGG19
from keras.preprocessing import image
from imagenet_utils import preprocess_input
from keras.models import Model

base_model = VGG19(weights='imagenet')
model = Model(input=base_model.input, output=base_model.get_layer('block4_pool').output)

img_path = 'elephant.jpg'
img = image.load_img(img_path, target_size=(224, 224))
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)

block4_pool_features = model.predict(x)
```

## References

- [Very Deep Convolutional Networks for Large-Scale Image Recognition](https://arxiv.org/abs/1409.1556)
- [Deep Residual Learning for Image Recognition](https://arxiv.org/abs/1512.03385)


text:
# Superstatic   [![NPM Module](http://img.shields.io/npm/v/superstatic.svg?style=flat-square)](https://npmjs.org/package/superstatic) [![NPM download count](https://img.shields.io/npm/dm/superstatic.svg?style=flat-square)](https://npmjs.org/package/superstatic) [![Build Status](http://img.shields.io/travis/firebase/superstatic.svg?style=flat-square)](https://travis-ci.org/firebase/superstatic) [![Code Climate](https://codeclimate.com/github/firebase/superstatic/badges/gpa.svg)](https://codeclimate.com/github/firebase/superstatic)

Superstatic is an enhanced static web server that was built to power.
It has fantastic support for HTML5 pushState applications, clean URLs,
caching, and many other goodies.

## Documentation

* [Installation](#installation)
* [Usage](#usage)
* [Configuration](#configuration)
* [API](#api)
  * [Middleware](#middleware)
  * [Server](#server)
* [Providers](#providers)
  * [Authoring Providers](#authoring-providers)
* [Run Tests](#run-tests)
* [Changelog](https://github.com/firebase/superstatic/blob/master/CHANGELOG.md)
* [Contributing](#contributing)

## Installation

Superstatic should be installed globally using npm:

For use via CLI

```
$ npm install -g superstatic
```

For use via API

```
npm install superstatic --save
```

## Usage

By default, Superstatic will simply serve the current directory on port
`3474`. This works just like any other static server:

```
$ superstatic
```

You can optionally specify the directory, port and hostname of the server:

```
$ superstatic public --port 8080 --host <IP_ADDRESS>
```

## Configuration

Superstatic reads special configuration from a JSON file (either `superstatic.json`
or `firebase.json` by default, configurable with `-c`). This JSON file enables
enhanced static server functionality beyond simply serving files.

**public:** by default, Superstatic will serve the current working directory (or the
ancestor of the current directory that contains the configuration json being used).
This configuration key specifies a directory *relative to the configuration file* that
should be served. For example, if serving a Jekyll app, this might be set to `"_site"`.
A directory passed as an argument into the command line app supercedes this configuration
directive.

**cleanUrls:** if `true`, all `.html` files will automatically have their extensions
dropped. If `.html` is used at the end of a filename, it will perform a 301 redirect
to the same path with `.html` dropped.

All paths have clean urls

```json
{
  "cleanUrls": true
}
```

**rewrites:** you can specify custom route recognition for your application by supplying
an object to the routes key. Use a single star `*` to replace one URL segment or a
double star to replace an arbitrary piece of URLs. This works great for single page
apps. An example:

```json
{
  "rewrites": [
    {"source":"app/**","destination":"/application.html"},
    {"source":"projects/*/edit","destination":"/projects.html"}
  ]
}
```

**redirects:** you can specify certain url paths to be redirected to another url by supplying configuration to the `redirects` key. Path matching is similar to using custom routes. `redirects` use the `301` HTTP status code by default, but this can be overridden by configuration.

```json
{
  "redirects": [
    {"source":"/some/old/path", "destination":"/some/new/path"},
    {"source":"/firebase/*", "destination":"https://www.firebase.com", "type": 302}
  ]
}
```

Route segments are also supported in the `redirects` configuration. Segmented `redirects` also support custom status codes (see above):

```json
{
  "redirects": [
    {"source":"/old/:segment/path", "destination":"/new/path/:segment"}
  ]
}
```

In this example, `/old/custom-segment/path` redirects to `/new/path/custom-segment`

**headers:** Superstatic allows you to set the response headers for certain paths as well:

```json
{
  "headers": [
    {
      "source" : "**/*.@(eot|otf|ttf|ttc|woff|font.css)",
      "headers" : [{
        "key" : "Access-Control-Allow-Origin",
        "value" : "*"
      }]
    }, {
      "source" : "**/*.@(jpg|jpeg|gif|png)",
      "headers" : [{
        "key" : "Cache-Control",
        "value" : "max-age=7200"
      }]
    }, {
      "source" : "404.html",
      "headers" : [{
        "key" : "Cache-Control",
        "value" : "max-age=300"
      }]
    }]
  }
}
```

**trailingSlash:** Have full control over whether or not your app has or doesn't have trailing slashes. By default, Superstatic will make assumptions for on the best times to add or remove the trailing slash. Other options include `true`, which always adds a trailing slash, and `false`, which always removes the trailing slash.

```json
{
  "trailingSlash": true
}
```

**i18n:** Internationalized content can be served based on `accept-language` or `x-country-code` headers.

Imagine a setup with the following files:

```
- public/
  - index.html
  - i18n/
    - fr_ca/
      - index.html
    - ALL_ca/
      - index.html
    - fr/
      - index.html
```

With `i18n` enabled, when a request is received for `/index.html` with the `accept-language` header set to `fr` (and no `x-country-code`), the content at `public/i18n/fr/index.html` will be returned as a response.

If `accept-language: fr` and `x-country-code: ca` are passed, the content at `public/i18n/fr_ca/index.html` will be returned for `/index.html`.

For more information about how content is resolved when using `i18n`, see [the Firebase Hosting documentation of the feature](https://firebase.google.com/docs/hosting/i18n-rewrites).

```json
{
  "i18n": {
    "root": "/intl"
  }
}
```

## API

Superstatic is available as a middleware and a standalone [Connect](http://www.npmjs.org/package/connect) server. This means you can plug this into your current server or run your own static server using Superstatic's server.

### Middleware

```js
var superstatic = require('superstatic')
var connect = require('connect');

var app = connect()
	.use(superstatic(/* options */));

app.listen(3000, function() {

});

```

### `superstatic([options])`

Instantiates middleware. See an [example](https://github.com/firebase/superstatic/tree/master/examples) for detail on real world use.

* `options` - Optional configuration:
  * `fallthrough` - When `false`, render a 404 page from within Superstatic rather than calling through to the next middleware. Defaults to `true`.
  * `config` - A file path to your application's configuration file (see [Configuration](#configuration)) or an object containing your application's configuration. If an object is provided, it will be merged into existing config in a `superstatic.json`.
  * `protect` - Adds HTTP basic auth. Example:  `username:password`
  * `env`- A file path your application's environment variables file or an object containing values that are made available at the urls `/__/env.json` and `/__/env.js`. See the documentation detail on [environment variables](http://docs.firebase.com/guides/environment-variables).
  * `cwd` - The current working directory to set as the root. Your application's `public` configuration option will be used relative to this.
  * `compression` - An option which controls superstatic's response compression. Pass in a standard `compression(req, res, next)` Express middleware function to override the default compression behavior (for example, require [shrink-ray](https://www.npmjs.com/package/shrink-ray) to enable advanced compression schemes such as brotli, or require node.js' stock [compression](https://www.npmjs.com/package/compression) middleware yourself to change the compression quality and caching behavior). Any other truthy value will default to the stock node.js middleware.

### Server

```js
var superstatic = require('superstatic').server;

var app = superstatic(/* options */);

var server = app.listen(function() {

});
```

Since Superstatic's server is a barebones Connect server using the Superstatic middleware, see the [Connect documentation](https://github.com/senchalabs/connect) on how to correctly instantiate, start, and stop the server.

### `superstatic([options])`

Instantiates a Connect server, setting up Superstatic middleware, port, host, debugging, compression, etc.

* `options` - Optional configuration. Uses the same options as the middleware, plus a few more options:
  * `port` - The port of the server. Defaults to `3474`.
  * `host` or `hostname` - The hostname of the server. Defaults to `localhost`.
  * `errorPage` - A file path to a custom error page. Defaults to [Superstatic's error page](https://github.com/firebase/superstatic/blob/master/templates/not_found.html).
  * `debug` - A boolean value that tells Superstatic to show or hide network logging in the console. Defaults to `false`.
  * `compression` - A boolean value that tells Superstatic to serve gzip/deflate compressed responses based on the request Accept-Encoding header and the response Content-Type header. Defaults to `false`.
  * `gzip` **[DEPRECATED]** - A boolean value which is now equivalent in behavior to `compression`. Defaults to `false`.

## Providers

Superstatic reads content from **providers**. The default provider for Superstatic
reads from the local filesystem. Other providers can be substituted when initializing
Superstatic:

```js
superstatic({
  provider: require('superstatic-someprovider')({
    provider: 'options'
  })
});
```

### Authoring Providers

Implementing a new provider is quite simple. You simply need to create a function
that takes a request and pathname and returns a Promise. The Promise should:

1. Resolve `null` when content isn't found (i.e. a 404 response).
2. Resolve with a metadata object as described below when content is found.
3. Reject when an error occurs in the content-fetching process.

The metadata object returned by a provider needs the following properties:

* **stream:** A readable stream for the content.
* **size:** The length of the content.
* **etag:** (optional) a content-unique string such as an MD5 hash computed from the content
* **modified:** (optional) a Date object for when the content was last modified

A simple in-memory store provider can be found at `lib/providers/memory.js` in
this repo as a simple reference example of a provider.

**Note:** The pathname will be URL-encoded. You should make sure your provider
properly handles files with non-standard characters (spaces, unicode, etc).

## Run Tests

In superstatic module directory:

```
npm install
npm test
```

## Contributing

We LOVE open source and open source contributors. If you would like to contribute to Superstatic, please review our [contributing guidelines](https://github.com/firebase/superstatic/blob/master/CONTRIBUTING.md) before you jump in and get your hands dirty.

license: MIT

repository: firebase/superstatic

branch_name: refs/heads/master

extension: md

gha_language: JavaScript

gha_license_id: MIT

license_type: permissive

repo_name: firebase/superstatic


text:
---
layout: post
title: Don't murder - don't drink and drive
#excerpt: ""
author: shikhi
tags: [Shikhi]
comments: true
---
Shikhi felt very strongly about the recent drink and drive case and wrote about it in this post.
{: .notice}

Do educated people know how to behave in a society? I should say yes. But what
is education anyway? Does getting a degree, earning a good salary, eating and drinking in plush
hotels make you a well educated and responsible citizen? We mistake people with
college degrees as educated. Recently, there was a case where a heavily drunk
successful lawyer jammed her speeding Audi in a taxi killing 2 people and
destroying 2 families.

When she gifted herself an Audi a year back, how proud her parents and family
would have felt, how much envy her friends would have been for her success. She
would have become an example for her cousins, an epitome of success, they would
have aspired to become like her. Today they must be ashamed of her.

The family who went to celebrate their son's result got ruined because of the
partying that she did to celebrate her achievement in office. I am not against
drinking - if it is done in limits. People drink to celebrate, to get happy
high, but why do they put other people's life at risk by driving in that so
called happy high state? In any case, how hard it is to get a driver or take a cab when you can afford an
Audi and have dinner and drinks in upscale restaurants?

My question here is - will you call it an accident or a murder? To my
understanding - accident is something which happens unknowingly by mistake but
driving at a speed of 120 km/hr, wrong side, with 6 times more than permissible
limit of alcohol in your blood doesn’t look like a mistake to me. It is a crime
committed by a person who deals with law in her day-to-day life. It is a murder
of two families.


text:
# Simplified User Roles for WP
Simple plugin which simplifies basic roles of WordPress.

## Features
* Removes authors and contributors
* Gives Editors capability to add new editors and subcsribers
* Hides Administrators from editors

repository: KeksiLabs/simplified-user-roles

repo_name: KeksiLabs/simplified-user-roles


text:
# Emeritus Approvers

These are the people who have been approvers in the past, and have since retired from the role.

We thank them for their service to the project.

| Emeritus | GitHub ID |
| -------- | --------- |
| Oliver Bähler | [oliverbaehler](https://github.com/oliverbaehler) |
| Stefan Sedich | [stefansedich](https://github.com/stefansedich) |
| Pablo Osinaga | [paguos](https://github.com/paguos) |
| Yann Soubeyrand | [yann-soubeyrand](https://github.com/yann-soubeyrand) |
| David J. M. Karlsen | [davidkarlsen](https://github.com/davidkarlsen) |
| John Behling | [jbehling](https://github.com/jbehling) |

repository: argoproj/argo-helm

branch_name: refs/heads/main

gha_language: Mustache

repo_name: argoproj/argo-helm


text:
# About
A cooperative scheduler pattern for Time-Triggered Embedded Systems. It's implemented on different embedded targets. There's also a version based on POSIX APIs.

# Acknowledgment
The pattern is taken from the book Patterns for Time-Triggered Embedded Systems by Michael J. Pont

# Implemented for
  - `ATmega32A`

# To use the POSIX compatible example
- You should have a linux distibution that's compatible with POSIX.1 and POSIX.4. The program is tested on raspbian OS with kernel version `5.4.51`.
- Head to the repo and run `make` .
- run `./main.out` and the scheduler works.

repository: mhomran/Co-Scheduler

gha_language: C

repo_name: mhomran/Co-Scheduler


text:
# Poker REST API

## Introduction

The idea was to reach multiple targets:

* Show algorithm capabilities as requested
* Also illustrate interesting solutions shared during the first meeting with Maxime: docker, typescript...

As a consequence, the project is:

* Based on Node.js
* Use restify to expose a REST WS (easier to test)
* Written in typescript to ensure code quality and lisiblity
* Build in docker to enable a quick and easy launch

Side observations:

* The project has been made with VSCode, and easier to test / debug with it
* As the cyclomatic complexity is not important, algorithm optimisation has not been my main target. Instead, I focused on code lisibility.

## Prerequisits

You need to have last versions of :

* NPM
* yarn (```npm install -g yarn```)
* newman (postman runner) (```npm install -g newman```)
* Python
* Docker (works well with Docker for windows if you are under windows)

## Installation

```bash
npm run restore-all
```

## Run

```bash
npm run build
docker-compose up
```

## Test

Play with this postman collection:

```bash
newman run .\tests\Poker.postman_collection.json
```

```raw
┌─────────────────────────┬──────────┬──────────┐
│                         │ executed │   failed │
├─────────────────────────┼──────────┼──────────┤
│              iterations │        1 │        0 │
├─────────────────────────┼──────────┼──────────┤
│                requests │       12 │        0 │
├─────────────────────────┼──────────┼──────────┤
│            test-scripts │       12 │        0 │
├─────────────────────────┼──────────┼──────────┤
│      prerequest-scripts │        0 │        0 │
├─────────────────────────┼──────────┼──────────┤
│              assertions │       45 │        0 │
├─────────────────────────┴──────────┴──────────┤
│ total run duration: 913ms                     │
├───────────────────────────────────────────────┤
│ total data received: 972B (approx)            │
├───────────────────────────────────────────────┤
│ average response time: 21ms                   │
└───────────────────────────────────────────────┘
```

repository: quentin-decre/poker

repo_name: quentin-decre/poker


text:
# diasepfl/jupyterhub

Built from the `jupyter/jupyterhub` base image.

This image contains a single user notebook server for use with
[JupyterHub](https://github.com/jupyter/jupyterhub). In particular, it is meant
to be used with the
[TextAuthenticator](https://github.com/torcato/JupyterTextAuthenticator/blob/master/textauthenticator/textauthenticator.py)
class to perform a simple authorization, reading username passwords from a file (/data/users.txt)
and the
[DockerSpawner](https://github.com/jupyter/dockerspawner/blob/master/dockerspawner/dockerspawner.py)
class to launch user notebook servers within docker containers.

if you do not pass the volume /data with the users.txt file, to the container
feel free to edit the users.txt file in this folder,one user per line with the basic syntax
username    passwd  \[admin\]

repository: torcato/JupyterTextAuthenticator

repo_name: torcato/JupyterTextAuthenticator


text:
# MinceCraft2D
This is my first Java Game. This code Open Sourced and you all are free to use and develop it. I tried to create 2D version of MineCraft PC Game, since this game still misses some of its features.

This Is progammer friendly Java Game For Beginners. It covers following concepts of Java and OOP.

- Multi Threading
- Graphics
- BufferStrategy
- BufferedImages
- SpriteSheets
- Assets
- Animations
- Templates
- Listener Classes
- Swing Class
- And Many More.

The features this game consist are listed below.

- World Generator
- Entities
- GFX
- Animations
- Menu Screen
- Inventory System
- Attack Modules

**HOW TO PLAY?**
Playing is really simple, it is same as any other open world game where your player would be lost in the wilds or any place of the world and you have to survie for your existence.

#Controls
These controls can be easily changed within the code.

**Movement**

- W : Move Forword
- A : Move Left
- S : Move Right
- D : Move Down

**Attack**

- UP ARROW: Attact Up
- LEFT ARROW: Attact Left
- RIGHT ARROW: Attact Right
- DOWN ARROW: Attact Down

E Key: To Open and Close Inventory

> Many things could be added to this game and many could be altered, all it just depends on your imagination.

**Here are some clips from the game.**

![test_image_1](https://user-images.githubusercontent.com/24351821/39574431-d0f44450-4ef4-11e8-9d2a-11b0b244994d.PNG)

![test_image_2](https://user-images.githubusercontent.com/24351821/39574432-d12ec44a-4ef4-11e8-9ab5-394bdff40c62.PNG)

![test_image_3](https://user-images.githubusercontent.com/24351821/39574433-d1676ab6-4ef4-11e8-9a4a-9553dbb7b0a4.PNG)

![test_image_4](https://user-images.githubusercontent.com/24351821/39574434-d1a6bde2-4ef4-11e8-8b50-b48d2b526f82.PNG)

![test_image_5](https://user-images.githubusercontent.com/24351821/39574446-e2f79db4-4ef4-11e8-896b-5180a5528e4d.PNG)

![test_image_6](https://user-images.githubusercontent.com/24351821/39574435-d216588c-4ef4-11e8-9e13-c0c70b234a51.PNG)


text:
#roomba

Control your Roomba robot using it's onboard serial interface

##Usage:

You must have a serial connection to Roomba's serial interface (exposed via
the mini-din connector at 5v TTL signal levels).  The Roomba speaks a protocol
called Create Open Interface (formerly ROI) described
[here](https://www.irobot.com/filelibrary/pdfs/hrd/create/Create%20Open%20Interface_v2.pdf).

##Example:

	var Roomba = require('../roomba.js').Roomba

	var bot = new Roomba({
	    sp: { path: '/dev/ttyAMA0', options: { baudrate: 57600 }},
	    update_freq: 200
	});

	bot.once('ready', function () {
		console.log('spinning up');
		bot.send({ cmd: 'DRIVE', data: [500, -1] });
	});

	bot.on('sense', function (sensors) {
		if (sensors.bump.right || sensors.bump.left) {
			console.log('bump detected');
			// stop spinning
			bot.send({ cmd: 'DRIVE', data: [0, -1] });
		}
	});

##TODO:

see issues.

##License:

MIT.

repository: mharsch/node-roomba

repo_name: mharsch/node-roomba


text:
# Spawner API

The new API allows gathering data which is shown in the UI.
The capabilities of the API are:
  - User ConfigMaps (`GET`, `POST`), It is possible to request the json of the User `ConfigMap`, and send a body of data to add (or replace). This includes selections, enviroment variables and gpu number.
  - UI Configuration (`GET`), If UI Configuration is set in a `ConfigMap`, the API is able to return information neccessary to configure the visual style and various elements of the UI. More information about this section can be found [here](./ui_configuration.md)
  - Sizes (`GET`), Sizes can be requested, either as an array of names (used in the UI) or as a pure json body (using the `pure_json=true` query).
  It is also possible to request a single size by name, which returns all information about the specific size.
  - Images (`GET`), Returns a dictionary of all images available to the spawner with all information about each of them. This information includes the description, its human readable name, its URL and optionally its tag specific information, such as dependencies and included software.
  Similar to sizes, it is also possible to request information about a single image as well.

To test the API follow the instructions in the [testing](./testing.md) section of the documentation.

This API is made with [Swagger](https://swagger.io/), and you can find its configuration YAML file [here](../jupyterhub_singleuser_profiles/api/swagger.yaml)

## User Interface

For detailed information about the User Interface component of the JupyterHub Singleuser Profiles please read the [User interface README](../jupyterhub_singleuser_profiles/ui/README.md)

repository: vpavlin/jupyterhub-singleuser-profiles

repo_name: vpavlin/jupyterhub-singleuser-profiles


text:
# Williams-Sonoma-Challenge
Responsive product page, with native javascript (es5) modules, and custom sass grid.

## Steps to Reproduce Project:
1. npm install -g
2. npm install --save-dev
3. gulp
4. 2-way data-binding version can be found in separate branch.
5. git checkout data-binding-engine

## Features:
1. gulp-sass config
2. custom responsive css grid system
3. native javascript modules
4. revealing module pattern architecture
5. css3 animations

## Features ToDo:
1. sub/pub observer pattern architecture
2. 2-way data-binding
3. custom html/javascript templates
4. native javascript router/hash based system
5. history api

## Lessons Learned:
I learned how to approach and write 2-way data binding from scratch. And I learned
how to javascript frameworks such as React and Angular either simplify data-binding, or
add complexity.

## [My current portfolio](http://www.robert-yarborough.com "current portfolio")


text:
PlayDrone Kitchen
===========================

VM production setup
----------------

Dependencies:

* [VirtualBox](https://www.virtualbox.org/wiki/Downloads)
* [Vagrant](https://docs.vagrantup.com/v2/installation/index.html)
* [ChefDK](https://github.com/opscode/chef-dk)
* [RVM-ed Ruby](https://rvm.io/): `\curl -L https://get.rvm.io | bash -s stable --ruby`

Install:
* `./00install-prepare.sh`: only need to run once.
* `./00install.sh`
* Encounter an error? Try `vagrant reload --provision` or, if that fails, `vagrant destroy; ./00install.sh`.

Go:
* `./01go.sh` or, more explicitly, `vagrant up`

Now we shall have a VirtualBox VM that can host [the forked Playdrone](https://github.com/pw4ever/playdrone); `/srv` in the guest is mapped to `./srv` in this directory.

Production setup
----------------

Edit `definitions/metal/ubuntu-12.04.sh` and put your own SSH keys. Then launch
it on the machine to be included in the cluser with: `definitions/metal/ubuntu-12.04.sh SERVER_IP`

Then install the playdrone environment. See the files in the `nodes-example` directory. Tweak
them as needed, then run `./deploy.sh`.

This will:

* Download the ubuntu 12.04 ISO and create the base VM image (only for dev)
* Install vim-config, zsh-config, tmux-config (and keep them updated)
* Install the basic sys admin tools (htop, sysstat, iftop, ...)
* Setup the SSDs in RAID0 and mount on /srv (only in production)
* Install graphite (with apache, django, memcached, rabbitmq) and Etsy StatsD
* Install collectd configured to send data to graphite every 1s
* Install elasticsearch 0.90.0.RC2 with Oracle JDK 7 in a cluster configuration
  with the plugins head, paramedic and inquisitor
* Install nginx in front of elasticsearch for access control
* Install RVM + Ruby 1.9.3-p327 with falcon patch + aggressive GC/heap tuning
* Install irb-config

Once done, you can deploy playdrone with capistrano, from the playdrone
repository.

Development setup
-----------------

1. Install [VirtualBox](https://www.virtualbox.org/wiki/Downloads).

2. Make sure you have the latest RVM:

        curl -L https://get.rvm.io | bash -s stable

3. Install Ruby:

        rvm install ruby-1.9.3-p392

4. Reload your shell (exit and come back).

5. Run the bootstrap script:

        ./bootstrap.sh

  Note: Do not type anything in the VM window during the creation of the base VM
  image, it may break the installation procedure.

---

PlayDrone Kitchen is released under the MIT license.


text:
---
path: "/rakuen"
date: "2018-08-17T13:00:00.962Z"
title: "Rakuen"
tags: ["Review", "Video Games"]
------

Hello there!

![alt text](https://s3.amazonaws.com/a-nerds-word/rakuen.jpg "Rakuen")

Today's topic of discussion is a fantastic video game I recently played, [*Rakuen*](https://store.steampowered.com/app/559210/Rakuen/). Rakuen is an RPG built in RPGMaker, the video game creation tool that was used to build *To the Moon* and *Finding Paradise*, which I've written about before.

Unlike *To the Moon*, which is almost entirely story based, with very few gamelike elements, Rakuen involves various puzzles and quests throughout the game, making it more like an RPG, following the namesake of the platform it was built with.

That said, *Rakuen* has a rich story, just like *To the Moon*.  She says the world is real, and that you can get to it through doors hidden inside the hospital. After meeting a few of the doctors, patients, and volunteers in the hospital, you gain access to hidden hallways that lead you to the world of Morizora’s Forest.

You spend a decent chunk of the game in both the hospital and the forest, trying to complete the five main story quests. These quests consist of resolving the conflicts or emotional trauma of the people you meet in the hospital, who each have parallels in Morizora's Forest. In resolving these quests, you not only play as the boy, but also as each of the characters themselves, reliving their memories and helping them find closure.

There are also darker events that are hinted at throughout the game, if you read various newspaper clippings or journal entries that are hidden in lockers or on the floor and walls of hallways. The game references the 2011 earthquake and tsunami in Japan, and several in-game events are directly influenced by it.

The game also makes references to other games, including a green mushroom who complains about a mustachioed man trying to eat it for an 'extra life', referencing the Mario franchise, and a painting of an man and a woman dancing next to a lighthouse, referencing *To the Moon*.

Although most of the game has a whimsical, childlike feel, there are emotional events and deep, meaningful messages as well. The game deals with death, guilt, depression, loneliness, alchoholism, and the incredible grief of losing loved ones before their time. I personally was almost moved to tears twice near the end of the game, which I consider a hallmark of a well-written story. If you can make the observer of a story so enamored with your characters that when something ill befalls them, the observer is moved to tears, you've probably done a good job.

One more note: The music in the game is also very, very good, although personally I preferred the music in *To the Moon* a bit better.

Anyway, if you want an RPG with a moving story and impactful characters, I would highly recommend *Rakuen*. It's also only $6 on Steam right now, so it's a pretty good deal too :)

That's all for today!

-- Bradley

gha_language: HTML


text:
# Metric Card for CIDer

## Metric Description
Recent advances in object recognition, attribute classification, action classification and crowd- sourcing have increased the interest in solving higher level scene understanding problems. One such problem is generating human-like descriptions of an image. In spite of the growing interest in this area, the evaluation of novel sentences generated by automatic approaches remains chal- lenging. Evaluation is critical for measuring progress and spurring improvements in the state of the art. This has already been shown in various problems in computer vi- sion, such as detection, segmentation, and stereo.

The goal is to automatically evaluate for image $I_i$ how well a candidate sentence $c_i$ matches the consensus of a set of image descriptions $S_i = \{s_{i1} , . . . , s_{im}\}$. All words in the sentences (both candidate and references) are first mapped to their stem or root forms. That is, “fishes”, “fish- ing” and “fished” all get reduced to “fish.”

$CIDEr_n$ score for n-grams of length $n$ is computed using the average cosine similarity between the candidate sentence $c_i$ and the reference sentences $s_{ij}$, which accounts for both precision and recall:

$CIDer_n(c_i, S_i) = \frac{1}{m} \sum_j{\frac{
    g^n(c_i) \cdot g^n(s_{ij})
}{
    ||G^n(c_i)||\cdot||g^n(s_{ij})||
}}$

where $g^n(c_i)$ is a vector formed by $g_k(c_i)$ (the TF-IDF weighting) corresponding to all n-grams of length $n$ and $||g^n(c_i)||$ is the magnitude of the vector $g^n(c_i)$. Similarity for $g^n(s_{ij})$.

### Inputs
-  **predictions** (`list`): A EvaluationInstance containing a single text sample for prediction.
-  **references** (`list`): A EvaluationInstance containing a single text sample for reference.

### Outputs
-  **score** (`float`): The CIDEr score.
-  **scores** (`list`): The CIDEr score for each individual prediction-reference pair.

### Results from popular papers

## Bounds
The CIDEr score can be any value in <img src="https://render.githubusercontent.com/render/math?math={[0,10]}##gh-light-mode-only">.

## Examples
```python
from nlgmetricverse import NLGMetricverse, load_metric
predictions = ["There is a cat on the mat.", "Look! a wonderful day."]
references = ["The cat is playing on the mat.", "Today is a wonderful day"]
scorer = NLGMetricverse(metrics=load_metric("cider"))
scores = scorer(predictions=predictions, references=references)
print(scores)
{
  "cider": {
    "score": 2.2006311045157565
  }
}
```

## Limitations and bias

## Citation
```bibtex
@inproceedings{DBLP:conf/cvpr/VedantamZP15,
  author    = {Ramakrishna Vedantam and
               C. Lawrence Zitnick and
               Devi Parikh},
  title     = {CIDEr: Consensus-based image description evaluation},
  booktitle = {{CVPR}},
  pages     = {4566--4575},
  publisher = {{IEEE} Computer Society},
  year      = {2015}
}
```

## Further References

repository: disi-unibo-nlp/nlg-metricverse

repo_name: disi-unibo-nlp/nlg-metricverse


text:
# openfusion.scad
A small library of openSCAD modules to mimc some fusion360 features. Simply copy+paste openfusion.scad into your openSCAD libraries folder.

### Modules

- circular_mirror(x, y, d, steps)
  - This module will repeat children elements in a circular pattern along a given <x,y> center point.
  - Arguments:
    - x = initial x offset
    - y = initial y offset
    - d = distance from <x, y> center point
    - steps = how many times to duplicate the content
- hexagon(r)
  - This module will create a hexagon, but radius is the distance from the center point to the middle of a side. (rather than to a pointy end).
  - Arguments
    - r = radius of the hexagon
- quadruple_mirror()
  - Mirror children elements upper right, upper left, lower right, lower left. (4 corners).
  - Arguments
    - None
- splat(d, count, x, y, z)
  - This module will repeat children elements equidistance "count" times along one or more vectors (x, y, and/or z) over some distance "d".
  - Arguments
    - d = maximum distance the children elemnets will travel
    - count = how many times to repeat the children elements over that distance
    - x = (true / false) should repeat along x-axis
    - y = (true / false) should repeat along y-axis
    - z = (true / false) should repeat along z-axis


text:
#Report:
- Introduction.
- Requirements.
- Software design.
    - Description of the software architecture of your system.
    - Any design patterns used.
    - Justification for the selected architecture and patterns.
    - UML diagrams should be included.
    - In the main body of the report place an overall UML diagram for the system.
        - Subsystem UML diagrams should be included as an appendix.
- Interface design.
    - Discuss the HCI (Human-computer interaction) design used.
    - Any principles behind the HCI design.
    - Any HCI considerations.
- Software engineering.
    - Any software engineering processes and principles used and adopted.
    - Development methodology used.
- Risk analysis.
    - Analysis of the risks associated with the chosen:
        - Development methodology.
        - Software engineering practices
        - Software design.
        - etc.
- Evaluation
    - Evaluation of the project
        - Strengths and weaknesses.
        - What has been learned, what could have been done better.
- Summary
- Teamwork
    - An evaluation of how well the team worked together must be provided.
- Individual contributions.
    - Each team member must submit an quantified evaluation of the contributions of all team members (including themselves).
    - This will be a global percentage (not a percentage for individual components). e.g. 16.667% each would be equal contribution.
    - If we decide on a single document, only one needs to be submitted- else you can do your own.
        - You can submit this as part of the appendix or separately.
- Individual reflections.
    - Each team member must write one side of A4 with their own reflections on the team and on their own contribution. These must all be included in the report.
- Compulsory appendix.
    - The coding standards adopted by the team.

##Test Report:
- Test plan.
- Test results.

- Main body of this document should outline:
    - The testing strategy.
    - The principles used.
    - The test results.
    - Any other relevant discussion about the testing.
    - Details of user testing undertaken.
- Appendix:
    - Test report.
    - Name of each JUnit test class.
    - Results of user testing.
- Must contain evidence of the coverage achieved by the tests.
## Note:
    - You do not need to produce a formal requirements document.
        - You still need to understand all the behaviour, being as specific as possible.
        - Essensially you still need requirements, but not to the extent of a full formal document.

repository: Avatarchik/dragonskulle

repo_name: Avatarchik/dragonskulle


text:
# Python Blog Website
This website contains more than 500 topics and 1000 examples about Python for Turkish and English, its modules and packages...

## Overview

![Alt Text](pythonakademi.gif)

[Live Link from Pythonanywhere](https://erdogan.pythonanywhere.com/en/python/)

## Contact

[Linkedin](https://www.linkedin.com/in/erdogan-sahin/)

[Github](https://github.com/kopuskopecik)

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

repository: kopuskopecik/projem

repo_name: kopuskopecik/projem


text:
# OpenDMXManager
OpenDMXManager is a singleton class designed to allow communication with the [EntTec Open DMX](www.enttec.com/open_dmx_usb) interface.

##Installation
Be sure to add the FTDI folder (containing the `ftd2xx.cfg`, `ftd2xx.h`, `libftd2xx.1.2.2.dylib`, and `WinTypes.h` files) to your Xcode project.

You may also need to add a Copy Files phase to your Build Phases to copy the .dylib framework as shown below:
![](http://i65.tinypic.com/esvocl.png)

##Usage
###Objective-C
- OpenDMXManager acts a singleton class. Begin by opening the port:
`[[DMXManager sharedManager] openDMXDevice];`

- Then, send a DMX packet (represented as an array of 512 or fewer `unsigned chars`, with the first byte in the array representing address 1, the second representing address 2, etc.):
`[[DMXManager sharedManager] sendDMXPacket:packet ofLength:512];`

- Close the port by calling `[[DMXManager sharedManager] closeDMXDevice];`
- All functions return a `BOOL` indicating success or failure.

###Swift
- OpenDMXManager acts a singleton class. Begin by opening the port:
`DMXManager.sharedManager().openDMXDevice()`

- Then, send a DMX packet (represented as an array of 512 or fewer `UInt8`s, with the first byte in the array representing address 1, the second representing address 2, etc.):
`DMXManager.sharedManager().sendDMXPacket(&dmxArray, ofLength: 512)`

- Close the port by calling `DMXManager.sharedManager().closeDMXDevice()`
- All functions return a `Bool` indicating success or failure.

##Mavericks and El Capitan
You may need to install an additional FTDI driver that prevents OS X from claiming the device as a serial port. [More information can be found here](http://www.ftdichip.com/Drivers/D2XX/MacOSX/ReadMe-mac.rtf). [The D2xxHelper driver can be found here](http://www.ftdichip.com/Drivers/D2XX/MacOSX/D2xxHelper_v2.0.0.pkg).

##Acknowledgements
OpenDMXManager was written following a helpful answer [found here](http://stackoverflow.com/questions/14035084/ftdi-communication-with-usb-device-objective-c) about communication with an FTDI device using Objective-C.

repository: shamanskyh/OpenDMXManager

repo_name: shamanskyh/OpenDMXManager


text:
shiny-octo-spoon
================

This project will provide a link between [Activiti](http://activiti.org/) and several chat clients. It will allow users to participate in Activiti BPM processes through chats. The forms of user tasks will be translated into chat conversations. In addition to that, control commands will be implemented to allow task selection, etc.

repository: zulusierra/shiny-octo-spoon

repo_name: zulusierra/shiny-octo-spoon


text:
# Platform Operations on Kubernetes (POOK)

This project demonstrates how to set up and Platform Operations infrastructure on Kubernetes by providing a Reference Implementation of many platform level components such as CI, CD, Metrics, Logging, Policy Enforcement and security.

It was designed using Pivotal Container Service (PKS) as the Kubernetes provider with RBAC being provided by UAA, but the default environment should work on any Kubernetes cluster with advanced features like Oauth2/openid integration and DNS/Cert management requiring certain platform pieces provided by the underlying cloud.

We take advantage of a few tools to streamline things, firstly [Helm](https://helm.sh) as all of the infrastructure tooling is available in public Helm charts (although some charts may be vendored in here for custom changes). We use Helmfile to provide a wrapper over helm to allow for more complex installation workflows.

With the goal of doing a gitops style workflow for deploying this, it is expected that you'll have seperate `env` directory(s) containing the customizations for a particular environment or cluster.

For the most part you should just need to edit `envs/default/envs.sh` and fill it in with your details. This is a shell script that will export environment variables to be used by Helmfile. The reason for this is that if you have passwords/secrets you can store them outside of git and have the script extract them from wherever you keep them.

## Prerequisites

> Note: helmfile can use helm2 in tillerless mode, or helm3. Either way, there is no need to run tiller in your cluster.

It's expected that you already have the basic Kubernetes client tools like `kubectl` installed.

* [kubectl](https://kubernetes.io)
* [helm](https://helm.sh/docs/using_helm/#quickstart-guide)
* [helmfile](https://github.com/roboll/helmfile#installation)
* [helmdiff](https://github.com/databus23/helm-diff#install)
* [helm tillerless](https://github.com/rimusz/helm-tiller#installation)

A happy script:

```bash
#!/bin/bash
helm init --client-only || echo "probably helm3"
helm plugin install https://github.com/databus23/helm-diff
helm plugin install https://github.com/rimusz/helm-tiller
wget -O ~/bin/helmfile https://github.com/roboll/helmfile/releases/download/v0.102.0/helmfile_linux_amd64
chmod +x ~/bin/helmfile
```

## Included Software

### Metrics and Observability

* Grafana
* Prometheus
* EFK (Elasticsearch, Fluentd, Kibana) or Loki + PromTail

### CI / CD

* Concourse
* Harbor
* Spinnaker

### Other

* Minio (for Spinnaker and Harbor artifacts)

## Example Deployment

### Default environment

This will deploy a default environment with no external auth or ingress set up.

See [docs/default/install.md](docs/default/install.md)

### OIDC/UAA environment

This will deploy an environment with Ingress, SSL, DNS, and UAA backed OIDC authentication for all apps.

See [docs/gcp-uaa-openid/install.md](docs/gcp-uaa-openid/install.md)

## Customizing Platform Operations on Kubernetes

Every Kubernetes cluster is different, just as every user of Kubernetes wants things installed differently. This gives us a fun challenge of needing to make it simple to deploy software, but also make the deployment flexible enough to suit most cases, and extendable for the rest.

Thankfully `helm` and `helmfile` give us the tools we need to do this. Utilizing `helmfile` allows us to build a gitops style system where we have a code repo (this one) and one or more environment repos that provides the environment specific details.

### Code Repo

In the Code Repo (this one) is a [helmfile.yaml](./helmfile.yaml) file that provides the fundamental work of installing our software by combining multiple helm charts together in an ordered and structured way.

Like Helm charts the `helmfile.yaml` can be treated as a template and values can be rendered into it. We can utilize this functionality and put most of our logic into a seperate values file.

The default set of values live in the [default environment](envs/default/values.yaml.gotmpl). This is used to specify which charts to install, their version, and the upstream Helm chart repository.

Also inside the Code Repo is a set of values files, each chart has its own directory with at least a default `values.yaml.tmpl` file. This file is the equivalent of an individual Chart's values file except it also can be rendered as a template. This allows us to amongst other things load in environment variables for passwords and secrets so that they are not stored in source control.

Each chart's values file can be overridden inside the primary values file by specifying an alternative location.

### Environment Repo

The default (and other generic examples) environment is found inside this repo under `envs/default`. This contains the default `values.yaml.tmpl` file as described above. It can be modified to enable/disable specific Charts or to change the upstream repository or version.

Also in the environment repo is an `envs.sh` file. This is a source file written in bash that contains exportable environment variables to further configure the environment. Values can be stored directly in this file, or they can be programmatically loaded from external sources.

If you need to even further customize a chart you could copy that chart's `values.yaml.tmpl` file from the code repo into the environment repository and then modify it to suit. This gives you complete configurability of the Chart if you need it.


text:
# SSLEchoReply
SSL echo reply client and server.  Can be used to verify a server side Java keystore file.

##How to build:
```
./gradlew clean build
```

##Example server invocation:

With SSL
```
java -Djavax.net.ssl.keyStore=YOUR_KEYSTORE_FILE \
     -Djavax.net.ssl.keyStorePassword=YOUR_KEYSTORE_PASS \
     -jar EchoServer.jar 8888
```

Without SSL (but still port 8888)
```
java -jar EchoServer.jar -8888
```
##Example client invocation:

With SSL
```
java -jar EchoClient.jar your.server.com 8888
```

Without SSL (but still to server port 8888)
```
java -jar EchoClient.jar your.server.com -8888
```

license: Unlicense

repository: dimalinux/SSLEchoReply

repo_name: dimalinux/SSLEchoReply


text:
# Example Package
This is a simple example package following the tutorial in https://packaging.python.org/tutorials/packaging-projects. You can use
[Github-flavored Markdown](https://guides.github.com/features/mastering-markdown/)
to write your content.

## Creating an Environment with Commands
https://conda.io/projects/conda/en/latest/user-guide/tasks/manage-environments.html#creating-an-environment-with-commands

```python
conda create -n packaging_tutorial python
```

You can verify that the python executable points to the conda environment via (Windows):
```bash
where python
```
> ```bash
> C:\Users\sterg\anaconda3\envs\packaging_tutorial\python.exe
> C:\Users\sterg\AppData\Local\Programs\Python\Python39\python.exe
> C:\Users\sterg\AppData\Local\Microsoft\WindowsApps\python.exe
> ```

Notice the anaconda3 path at the top of the list (i.e. first one to be used).

```python
python -m pip install --upgrade build
```


text:
---
title: "Grace's Experience as a Team Member of the Norman Sicily Project"
date: 2020-03-13T14:07:58-05:00
draft: false
tags: ["Grace", "skills", "history"]
---

When I heard about the opportunity to be part of The Norman Sicily Project, I was
immediately interested in learning more. After reading the job description, I was even more
eager to apply and I was beyond thrilled when I was offered a position on the team. Being a
history major, with a particular interest in medieval Italian history, I was captivated by the
pictures of the ornate details of the monasteries and churches. Prior to beginning my work on the
project, I had some knowledge of what historical research entails. However, participating in this
project has taught me more than I had ever expected. Not only have I been able to utilize and
improve my research skills, I have also learned what it means to be part of a scholarly research
team. Along with three other undergrads at Montclair State University, I have been contributing
to the project. Initially, my first tasks were to catalogue images of the extraordinary Norman
medieval monasteries found across Sicily, which included identifying the contents of each
photograph, date visited, and more. Before beginning, the other students and I underwent a
weekend of training so that we understood the complexities of working with and cataloging the
historical data that we were about to encounter. The highlight of this stage in the project, for me,
was to view photographs of the variety of monasteries found throughout different regions of
Sicily and the ability to see the magnitude and cultural richness of the sites and their remains.

My interest in Sicily and Sicilian history dates back to my high school years when I took
an Advanced Placement European History class. I found it fascinating that so many different
civilizations had left their cultural marks on the island and on southern Italy in general. From the
Greeks to the Arabs and, of course, the Normans, the cultural diversity is apparent in the
architecture of the island with religious buildings that have Greek elements while having Arab
influences as well. Being a history buff, Italy was on the top of my travel bucket list ever since I
was a young child and I was lucky enough to have the opportunity to travel there in summer of
2014. Now, after having been fortunate enough to be a member of The Norman Sicily Project, I
am inspired to return to Italy and travel around Sicily.

Personally, the thing that I have taken away the most from being part of this project is the
importance of preserving historical sites. Nowadays, history and other humanities are often
brushed aside as not being as important as math and the sciences. However, I very much disagree
with this sentiment. I argue that history is one of the most important, if not the most important,
humanities disciplines because by studying it we can learn so much from the past. We can also
gain insights into how to approach current issues in the present and what may arise in the future.
Historical monuments like the monasteries, churches, fortresses, etc., of Sicily are paramount to
learning and understanding about the medieval period in Europe. By uncovering the past, we can
be better prepared for the future and teach future generations about what has molded the present.

repository: the-norman-sicily-project/website

repo_name: the-norman-sicily-project/website


text:
# Air Europa: Pilot at Schiphol airport accidentally caused alarm

Published at: **2019-11-06T20:13:19+00:00**

Author: ****

Original: [Reuters](https://www.reuters.com/article/us-netherlands-schiphol-air-europa-idUSKBN1XG2T2)

AMSTERDAM (Reuters) - A pilot onboard an Air Europa airplane accidentally set off an alarm, prompting a major security lockdown at Amsterdam’s Schiphol airport on Wednesday, the airline said in a statement.
“In a plane from Amsterdam to Madrid tonight an alarm was accidentally activated which set off safety protocols at the airport,” it said. “There was no cause for alarm, all passengers were fine and waiting for the flight to take off.”
“We are sorry, there was no cause for alarm,” the Spanish airline said.

repository: dsadlollioygjmzvcxv/tdc-exported

repo_name: dsadlollioygjmzvcxv/tdc-exported


text:
# Advanced configuration

Congrats on getting `flow-typed` set up! There are a small number of configuration options available through the CLI, but using all those flags can be tiring. This tiny guide will walk through setting up custom scripts in `package.json`.

## Custom scripts

Before editing your `package.json`, take a look at the available [CLI commands](install.md). Create an entry for each command you'd like to customize.

```
"scripts": {
  "flow-typed-install": "flow-typed install -s -o --ignoreDef peer bundle --libdefDir custom/def_folder/"
  "flow-typed-createstub": "flow-typed create-stub -o --libdefDir custom/def_folder/"
},
```

And done! Now, instead of using `flow-typed install`, use `npm run flow-typed-install`, and your customizations will be applied every time.

### `.flowconfig`

There is currently no way to customize `flow-typed` through flow's `.flowconfig` file.

repository: flow-typed/flow-typed

repo_name: flow-typed/flow-typed


text:
# clip
Manage the clipboard from the console

## Introduction

Witht this tool you can copy and paste text from your Linux virtual terminal, not with a combination of keys but with a command.

Do you think it is useless? See some examples:

To download a web page, copy the url and then run:

    $ wget "$(clip)"

To copy the current date to the clipboard:

    $ clip -s "$(date)"

If you want to send someone a file, you run:

    $ clip -f myfile.txt

and then paste into an email message.

There are endless uses!

## Compilation

This program uses Gtk to handle the clipboard, either Gtk-2.0 or Gtk-3.0, to be chosen at compilation time.

To compile for Gtk-2:

    $ gcc `pkg-config gtk+-2.0 --cflags --libs` -O2 clip.c -o clip

Or for Gtk-3:

    $ gcc `pkg-config gtk+-3.0 --cflags --libs` -O2 clip.c -o clip

## Clipboards

Before going on, a couple of clarifications about the clipboard in X systems:

1. There are two clipboards:
 * The *default* clipboard is the usual copy-paste one.
 * The *primary* clipboard is the current selection, that needs no copy and usually is pasted with the middle mouse button.

2. The clipboard is a client-to-client protocol, the X server does not store the copied data. So when the *copier* program finishes, the data can no longer be pasted. Many (most) desktop systems include a clipboard server, that is a process that holds the copied text whenever the *copier* process ends so that the clipboard data will not be lost. That will work for the *default* clipboard but not for the *primary* one.

## Options

If run without options it will print to the standard output the contents of the default clipboard.

You can use option `-p` to use the primary clipboard instead. For example, just select the URL you want to download and run:

    $ wget $(clip -p)

If you want to set the clipboard use the `-s <text>` option. If the clipboard server is not working, for any reason, you can use the `-w` option to prevent the program from finishing.

If you set the primary clipboard you will probably need the `-w` option too, or else the program will end immediately and the text will be lost. For example, to copy the current directory to the primary clipboard:

    $ clip -pws "$(pwd)"

You can also copy the contents of a file using the option `-f <file>`. You can use `-f -` to specify standard input. For example to copy the contents of a web page:

    $ wget https://en.wikipedia.org/ -O - | clip -f -

repository: rodrigorc/clip

repo_name: rodrigorc/clip


text:
# Olympic chief urges focus on cheating athletes’ ‘entourage’

Published at: **2019-11-05T10:48:16+00:00**

Author: **AGENCE FRANCE PRESSE**

Original: [Capital Sports](https://www.capitalfm.co.ke/sports/2019/11/05/olympic-chief-urges-focus-on-cheating-athletes-entourage/)

        KATOWICE, Poland, Nov 5 – Olympic chief Thomas Bach on Tuesday urged governments to do more to help “drain the doping swamp” by going after the entourage of a cheating athlete.

“The athlete is not the only culprit,” the President of the International Olympic Committee (IOC) told the World Anti-Doping Agency (WADA) conference in Katowice.
“The athlete is supported and sometimes even driven to or forced into doping by a secretive network which may include coaches, agents, dealers, managers, officials from government or sport organisations, doctors, physiotherapists or others,” he said.
But while sports organisations can punish competitors who test positive they are powerless “to identify and sanction in a deterrent way the athletes’ entourage”.
As an example he said if the IOC identified a doctor guilty of doping it will banish him from the Games.
“But after the doctor goes back home, in most cases he can just continue with his nefarious business without any consequences.
“This is not acceptable. This is the wrong signal. This needs to be changed,” he told WADA delegates on the opening day of their fifth world conference.
“This is where we need the full support of the government authorities. They have the necessary authority and tools to take action.”
Bach cited state-doping in Russia, the Aderlass blood-doping Operation and the scandal-hit Nike Oregon Project as all highlighting the “urgent need to focus much more on the athletes’ entourage”.
By holding everybody implicated in a doping case accountable “we can take a major step forward to strengthen justice and credibility for the protection of the clean athletes and to drain the doping swamp.”
(Visited 11 times, 1 visits today)


text:
# BuildIf - Simple build preprocessor with real JS for logic

Builds different version of source depending on values in JSON/JS config.
Could be used as a standalone CLI utility or as a library.

Useful for making separate builds for on-premise customers with different features or customizations. Allows to keep single codebase without per-customer branches with the tradeoff of build comments and additional build step.

Source files could be any type, but it's primarily build for JS files.

Install:

	npm install buildif

## Syntax

In code:

```javascript
// BUILD: if (features.billing) {
	console.log("Billing Enabled");
// BUILD: }

// BUILD: if(version.startsWith("1")) {
	console.log("Version 1.x");
// BUILD: } else if (version.startsWith("2")) {
	console.log("Version 2.x");
// BUILD: }
```

Config file:

```json
{
	"features": {
		"billing": false
	},
	"version": "2.1.1"
}
```

Any line prefixed with `// BUILD:` will be executed at the build-time.
Any valid JS statements could be used after prefix: if/else, variable declarations, function calls, require. Ifs could be nested.

## Use as CLI

Use JSON config and output to stdout:

```bash
buildif --config ./examples/config.json --input ./examples/example.js > output.js
```

Use JS config and output to file:

```bash
buildif --config ./examples/config.js --input ./examples/example.js --output output.js
```

Use pipes for both input and output:

```bash
cat ./examples/example.js | bin/buildif --config ./examples/config.json > output.js
```

Overwrite values from config with command line options:

```bash
buildif --config ./examples/config.json --features.billing=true --input ./examples/example.js
```

Use only command line options without config file:

```bash
buildif --features.billing=true --version="2.1.0" --input ./examples/example.js
```

Command line overwrites could have multi-level names separated by dot, like "features.billing". For array indices also use dot, like "customers.1.name".

It outputs sane error at the build time. It prints the line of code that triggered error, file name and line number. Execution error in BUILD comments:

	// BUILD: nonExistingVar; // This will trigger error
	ReferenceError: nonExistingVar is not defined
		at <instrumented code> (./examples/example-error.js:7)

### CLI options

`--input` - Input file path, if not specified read from stdin.

`--output` - Output file path, if not specified print to stdout.

`--config` - Config file path, if not specified config = {}.

All other options are treated as config overwrites.
When using CLI buildif will try to coerse types for options:

```bash
buildif --version=2.1 ...
```

will result in config object `{ version: 2.1 }`, but

```bash
buildif --version=2.1.0 ...
```

will result in config object `{ version: "2.1.0" }`.

## Use as library

`buildif(inputText, configObject)`

Example:

```javascript
var buildif = require("buildif");
var text = require("fs").readFileSync("./examples/example.js");
var config = {
	features: {
		billing: false
	},
	version: "2.1.1"
};

console.log(buildif(text, config));
```

repository: wlodzislav/buildif

repo_name: wlodzislav/buildif


text:
github.com/tetratom/qb

    qb is a simple SQL query builder for Go

# highlights

- `go get -u github.com/tetratom/qb`
- [GoDoc](https://godoc.org/github.com/tetratom/qb)
- More examples can be found in [qb_test.go](./qb_test.go).
- All methods take value receivers and return values.
- Select the placeholder dialect with the `DialectOption(Dialect)` method.

# example

```go
import "github.com/tetratom/qb"

q := qb.
    Select("*").From("my_table").
    Where(qb.
        And("id = ?", 1).
        Or("time < ?", qb.Lit("now()"))).
    OrderBy("time ASC").
    Limit(10)

// q.SQL() is "SELECT * FROM my_table WHERE id = ?".
// q.Args() is []interface{1}.
row := tx.QueryRow(q.SQL(), q.Args()...)
```

# thread-safe and reusable builders

_qb_ builders should be used the same as the `append()` built-in. The builders
take and return values, and internally keep state such that one builder value
can be re-used for different queries.  For example:

```go
qbase := qb.Select("col1", "col2")
q1 := qbase.From("t1") // q1 is: SELECT col1, col2 FROM t1
q2 := qbase.From("t2") // q2 is: SELECT col1, col2 FROM t2
// qbase is: SELECT col1, col2
```

Just like with `append()`, the return value of calling a builder method must be
assigned back into a variable to be used. For example:

```go
func Search(name string, ordered bool) qb.Query {
    q := qb.Select("*").From("members")

    if name != "" {
        q = q.Where(qb.And("name = ?", name))
    }

    if ordered {
        q = q.OrderBy("created_at DESC")
    }

    return q
}
```

repository: roberth-k/qb

repo_name: roberth-k/qb


text:
<!--
BEFORE SUBMITTING A NEW ISSUE...

Please try a different theme to make sure the problem
is not with the theme and is actually with the syntax.

If you are not reporting a bug please remove this template
and describe the issue in your own words.
-->

### Environment

- Editor and Version (VS Code, Atom, Sublime):
- Your primary theme:

### Issue Description

<!-- Describe the issue in detail -->

#### Screenshots

<!-- If possible include screenshots of the issue -->

### Expected Behavior

<!-- How would you expect it to behave -->

### Code Samples

<!--
Include any code sippets that can be used to reproduce the
described behavior.
-->

```PowerShell

```

repository: PowerShell/EditorSyntax

gha_language: PowerShell

repo_name: PowerShell/EditorSyntax


text:
# [Ranking NBA teams](https://www.codewars.com/kata/ranking-nba-teams "https://www.codewars.com/kata/5a420163b6cfd7cde5000077")

You are given a string with results of NBA teams (see the data in "Sample Tests") separated by commas e.g:

r =
`Los Angeles Clippers 104 Dallas Mavericks 88,New York Knicks 101 Atlanta Hawks 112,Indiana Pacers 103 Memphis Grizzlies 112,
 Los Angeles Clippers 100 Boston Celtics 120`.

A team name is composed of one, two or more words built with letters or digits: `Atlanta Hawks`, `Philadelphia 76ers`...

Given a string of results and the name of a team (parameter : to_find) your function `nba_cup (or nbaCup or ...) ` will return as a string

- the name of the team followed by `:` and
- the number of matches won by the team
- the number of draws
- the number of matches lost by the team
- the total number of points scored by the team
- the total number of points conceded by the team

and finally a kind of marks in our ranking system

- a team marks `3` if it is a win
- a team marks `1` if it is a draw
- a team marks `0` if it is a loss.

The return format is:

```
"Team Name:W=nb of wins;D=nb of draws;L=nb of losses;Scored=nb;Conceded=nb;Points=nb"
```

## Remarks:

The team name `""` returns `""`.

If a team name can't be found in the given string of results you will return `"Team Name:This team didn't play!"` (See examples below).

The scores must be integers. If a score is a float number (`abc.xyz...`) you will return:
"Error(float number):the concerned string"

## Examples:

```
nba_cup(r, "Los Angeles Clippers") -> "Los Angeles Clippers:W=1;D=0;L=1;Scored=204;Conceded=208;Points=3"

nba_cup(r, "Boston Celtics") -> "Boston Celtics:W=1;D=0;L=0;Scored=120;Conceded=100;Points=3"

nba_cup(r, "") -> ""

nba_cup(r, "Boston Celt") -> "Boston Celt:This team didn't play!"

r0="New York Knicks 101.12 Atlanta Hawks 112"
nba_cup(r0, "Atlanta Hawks") -> "Error(float number):New York Knicks 101.12 Atlanta Hawks 112"
```

repository: ParanoidUser/codewars-handbook

gha_language: Java

repo_name: ParanoidUser/codewars-handbook


text:
---
title: "List assigned claimsMappingPolicies"
description: "List claimsMappingPolicies that are assigned to a service principal."
ms.localizationpriority: medium
author: "paulgarn"
ms.prod: "applications"
doc_type: "apiPageType"
---

# List assigned claimsMappingPolicy

Namespace: microsoft.graph

List the [claimsMappingPolicy](../resources/claimsmappingpolicy.md) objects that are assigned to a [servicePrincipal](../resources/serviceprincipal.md).

## Permissions

One of the following permissions is required to call this API. To learn more, including how to choose permissions, see [Permissions](/graph/permissions-reference).

| Permission type                        | Permissions (from least to most privileged) |
|:---------------------------------------|:--------------------------------------------|
| Delegated (work or school account)     | Policy.Read.All and Application.ReadWrite.All, Policy.ReadWrite.ApplicationConfiguration and Application.ReadWrite.All |
| Delegated (personal Microsoft account) | Not supported. |
| Application                            | Policy.Read.All and Application.ReadWrite.OwnedBy, Policy.Read.All and Application.ReadWrite.All, Policy.ReadWrite.ApplicationConfiguration and Application.ReadWrite.OwnedBy, Policy.ReadWrite.ApplicationConfiguration and Application.ReadWrite.All |

## HTTP request

You can address the service principal using either its **id** or **appId**. **id** and **appId** are referred to as the **Object ID** and **Application (Client) ID**, respectively, in the Azure portal

<!-- { "blockType": "ignored" } -->

```http
GET /servicePrincipals/{id}/claimsMappingPolicies
GET /servicePrincipals(appId='{appId}')/claimsMappingPolicies
```

## Request headers

| Name          | Description   |
|:--------------|:--------------|
| Authorization | Bearer {token}. Required. |

## Request body

Do not supply a request body for this method.

## Response

If successful, this method returns a `200 OK` response code and a collection of [claimsMappingPolicy](../resources/claimsmappingpolicy.md) objects in the response body.

## Examples

### Request

The following is an example of the request.

# [HTTP](#tab/http)
<!-- {
  "blockType": "request",
  "name": "list_claimsmappingpolicies_on_application"
}-->

```msgraph-interactive
GET https://graph.microsoft.com/v1.0/servicePrincipals/00063ffc-54e9-405d-b8f3-56124728e051/claimsMappingPolicies
```

# [C#](#tab/csharp)

```csharp

GraphServiceClient graphClient = new GraphServiceClient( authProvider );

var claimsMappingPolicies = await graphClient.ServicePrincipals["{servicePrincipal-id}"].ClaimsMappingPolicies
	.Request()
	.GetAsync();

```

 For details about how to [add the SDK](/graph/sdks/sdk-installation) to your project and [create an authProvider](/graph/sdks/choose-authentication-providers) instance, see the [SDK documentation](/graph/sdks/sdks-overview).

### Response

The following is an example of the response.

> **Note:** The response object shown here might be shortened for readability.

<!-- {
  "blockType": "response",
  "truncated": true,
<EMAIL_ADDRESS>"microsoft.graph.claimsMappingPolicy",
  "isCollection": true
} -->

```http
HTTP/1.1 200 OK
Content-type: application/json

{
<EMAIL_ADDRESS>"https://graph.microsoft.com/v1.0/$metadata#Collection(microsoft.graph.claimsMappingPolicy)",
    "value": [
        {
<EMAIL_ADDRESS>"https://graph.microsoft.com/v2/84841066-274d-4ec0-a5c1-276be684bdd3/directoryObjects/8782712b-4368-4bc2-84d9-d47cd0146621/Microsoft.DirectoryServices.ClaimsMappingPolicy",
            "id": "8782712b-4368-4bc2-84d9-d47cd0146621",
            "deletedDateTime": null,
            "definition": [
                "{\"ClaimsMappingPolicy\":{\"Version\":1,\"IncludeBasicClaimSet\":\"true\", \"ClaimsSchema\":[{\"Source\":\"user\",\"ID\":\"extensionattribute1\"},{\"Source\":\"transformation\",\"ID\":\"DataJoin\",\"TransformationId\":\"JoinTheData\",\"JwtClaimType\":\"JoinedData\"}],\"ClaimsTransformations\":[{\"ID\":\"JoinTheData\",\"TransformationMethod\":\"Join\",\"InputClaims\":[{\"ClaimTypeReferenceId\":\"extensionattribute1\",\"TransformationClaimType\":\"string1\"}], \"InputParameters\": [{\"ID\":\"string2\",\"Value\":\"sandbox\"},{\"ID\":\"separator\",\"Value\":\".\"}],\"OutputClaims\":[{\"ClaimTypeReferenceId\":\"DataJoin\",\"TransformationClaimType\":\"outputClaim\"}]}]}}"
            ],
            "displayName": "TestclaimsPolicy",
            "isOrganizationDefault": false
        }
    ]
}
```

<!-- uuid: 16cd6b66-4b1a-43a1-adaf-3a886856ed98
2019-02-04 14:57:30 UTC -->
<!-- {
  "type": "#page.annotation",
  "description": "List assigned claimsMappingPolicy",
  "keywords": "",
  "section": "documentation",
  "tocPath": ""
}-->

repository: microsoftgraph/msgraph-sdk-dotnet

branch_name: refs/heads/dev

gha_language: C#

gha_license_id: NOASSERTION

repo_name: microsoftgraph/msgraph-sdk-dotnet


text:
# Nerves Runtime Bootstrapper
Application gets split into (up too)? three parts.

## Boot Up
Boot up could go something like:
```
Power ON
  ├── Hardware Bootloader (uboot, etc)
  ├── Linux Kernel
  ├── Erlinit
  └── Nerves Bootloader
     └──Nerves Bootstrapper
        ├── Hardware init (driver loading)
        ├── Filesystem init (see block diagram)
        ├── Network Init
        └── HTTP Init (Maybe this could be generalized as a `Transport` as to not be locked into http?)
            └── Download an archive of some sort containing our actual application code (this is the hard part)
                ├── Extract/Verify (with black magic?) package
                └── Somehow shim into (and supervise) this package
```
## Partitions
So a partition map would look a little different
```
 ______________________________________________________________________________
|        A        |          B          |        C         |         D        |
|    Bootloader   | Nerves Bootstrapper | Application Code | Application Data |
|  (per platform) |     (Read only)     |    (Read Only)   |    (Read/Write)  |
|_________________|_____________________|__________________|__________________|
```
* A - Bootloader
  * Will be different per platform.
  * Black magic
* B - Nerves Bootstrapper
  * Will contain `linux` rootfs with `erlinit` and friends.
  * Should be read only, and _probably_ not need a mirror/backup partition. (Hopefully)
  * Should contain `Nerves.Bootloader`
* C - Application Code
  * One (or maybe many???) Erlang releases containing beam files and friends.
  * Read only at runtime. `BootStrapper` should be the only thing with access to overwriting.
  * Should be persistent, but if mangled somehow, BootStrapper can fix it/Request new Firmware
  * Hot code reloading
  * Probably have backup/mirror partition.
* D - Application Data
  * General Data partition

## Implementation

### Compile
* Application require the `NervesBootstrapper` dep, giving some configuration.
* `NervesBootstrapper` Provides a plugin for Distillery or something that:
  * Constructs the (cross compiled) release, and `Bootstrapper` firmware.
    * Bootstrapper will be a `.fw` file.
    * Application code will be a archive of some sort of just your release.

`mix firmware` Could still compile a fw file with your application code baked in thanks to `fwup`

### Running

`mix firmware.burn` could Still burn an entire firmware with your application code baked in.

## Problems
Biggest problem i can see is shimming into a second Erlang release. Maybe we can have two
instances of `erlinit`?

Semantics of bringing up hardware will need to be hashed out.


text:
---
title: Memcached Cache Connector
description: Learn how to use Memcached with deepstream
logoImage: memcached.png
---

*** Memcached not upgraded to V4/V5. Please [refer to this github issue](https://github.com/deepstreamIO/deepstream.io/issues/973) if you require this ***

#### What is Memcached?
[Memcached](https://memcached.org/) is a distributed caching system. All its data is purely kept in memory which means two things:

- its very fast
- everything is gone if you pull the plug.That's not necessarily a bad thing, but it means you need some sort of persistent database layer as well if you choose to go with Memcached.

#### Why use Memcached with deepstream?
For two reasons: Speed and scale. Memcached can power large clusters and writes and reads data very quickly. The memcached protocol has also seen some wider adoption, e.g. by [Hazelcast](../hazelcast/), so if you do decide to change caches at some point, migration might be quite easy.

#### I want to use AWS Elasticache with deepstream. Should I choose Memcached or Redis as a caching-engine?
Redis! Memcached is a great cache, but Redis also saves data to disk and can act as a message-bus for smaller deepstream clusters, giving you all the functionality you need.

#### How to use Memcached with deepstream?
deepstream comes preinstalled with an official connector for Memcached.

If you are using deepstream from Node, you can also install it via [NPM](https://www.npmjs.com/package/@deepstream/cache-memcached)

#### Configuring the Memcached connector
You can configure memcached in the plugin section of deepstream's config.yml file

```yaml
plugins:
  cache:
    name: memcached
    options:
      serverLocation: [ 'localhost:11211' ] # One or more endpoint URLs
```

gha_language: TypeScript


text:
# Calzone

Calzone is a build monitor plugin for [TeamCity](http://www.jetbrains.com/teamcity/), especially geared towards multi-project/multi-module environments.  It aims to present a concise, "shouty" report of which builds are failing, suitable for reading from a distance on a publicly visible monitor.

Inspired by Nat Pryce's [team-piazza](https://github.com/timomeinen/team-piazza), which we used to use.

### Building Calzone

Build Calzone by opening the IntelliJ project and building that.  The Calzone
jar file (calzone.jar) should then appear under plugins/server; run make-zipfile.sh
to build the plugin zip file.

Note that to build Calzone you'll need to copy the TeamCity 5 API jar's to
the lib directory.  These jars aren't in source control because they're not
freely (as in speech) redistributable.

> devPackage/common-api.jar
> devPackage/runtime-util.jar
> devPackage/server-api.jar

### Installing Calzone

Try one of the following two methods depending on your TeamCity environment:

Method 1: Copy calzone.zip to the plugins directory under your TeamCity
data directory, then bounce TeamCity.

Method 2: Copy calzone.jar to webapps/ROOT/WEB-INF/lib under your
TeamCity installation directory, then bounce TeamCity.

Calzone should then be visible at:

> http://YOUR_TEAMCITY_SERVER:8111/calzone/index.html

repository: pobrelkey/team-calzone

repo_name: pobrelkey/team-calzone


text:
# Change Log

## 1.0.0-rc.3

### Patch Changes

- [#2002](https://github.com/lit/lit/pull/2002) [`ff0d1556`](https://github.com/lit/lit/commit/ff0d15568fe79019ebfa6b72b88ba86aac4af91b) - Fixes polyfill-support styling issues: styling should be fully applied by firstUpdated/update time; late added styles are now retained (matching Lit1 behavior)

* [#2030](https://github.com/lit/lit/pull/2030) [`34280cb0`](https://github.com/lit/lit/commit/34280cb0c6ac1dc14ce5cc900f36b4326b0a1d98) - Remove unnecessary attribute:false assignment in @state decorator

- [#2034](https://github.com/lit/lit/pull/2034) [`5768cc60`](https://github.com/lit/lit/commit/5768cc604dc7fcb2c95165399180179d406bb257) - Reverts the change in Lit 2 to pause ReactiveElement's update cycle while the element is disconnected. The update cycle for elements will now run while disconnected as in Lit 1, however AsyncDirectives must now check the `this.isConnected` flag during `update` to ensure that e.g. subscriptions that could lead to memory leaks are not made when AsyncDirectives update while disconnected.

* [#1918](https://github.com/lit/lit/pull/1918) [`72877fd`](https://github.com/lit/lit/commit/72877fd1de43ccdd579778d5df407e960cb64b03) - Changed the caching strategy used in CSSResults returned from the css tag to cache the stylesheet rather than individual CSSResults.

- [#1942](https://github.com/lit/lit/pull/1942) [`c8fe1d4`](https://github.com/lit/lit/commit/c8fe1d4c4a8b1c9acdd5331129ae3641c51d9904) - For minified class fields on classes in lit libraries, added prefix to stable properties to avoid collisions with user properties.

* [#2041](https://github.com/lit/lit/pull/2041) [`52a47c7e`](https://github.com/lit/lit/commit/52a47c7e25d71ff802083ca9b0751724efd3a4f4) - Remove some unnecessary internal type declarations.

- [#1917](https://github.com/lit/lit/pull/1917) [`550a218`](https://github.com/lit/lit/commit/550a2186eaeffef9d2d87025de09bdd2bb9c82ac) - Use a brand property instead of instanceof to identify CSSResults to make the checks compatible with multiple copies of the @lit/reactive-element package.

* [#1959](https://github.com/lit/lit/pull/1959) [`6938995`](https://github.com/lit/lit/commit/69389958ab41b2ad3074fd86926ed18dc9968302) - Changed prefix used for minifying class field names on lit libraries to stay within ASCII subset, to avoid needing to explicitly set the charset for scripts in some browsers.

- [#1964](https://github.com/lit/lit/pull/1964) [`f43b811`](https://github.com/lit/lit/commit/f43b811405be32ce6caf82e80d25cb6170eeb7dc) - Don't publish src/ to npm.

* [#1943](https://github.com/lit/lit/pull/1943) [`39ad574`](https://github.com/lit/lit/commit/39ad574e2a386627ec30a4be19ae6a003e3a4766) - Add support for private custom element constructors in @customElement().

- [#2016](https://github.com/lit/lit/pull/2016) [`e6dc6a7`](https://github.com/lit/lit/commit/e6dc6a708adacec6a17a884784f821c3250d7532) - Clean up internal TypeScript types

* [#1972](https://github.com/lit/lit/pull/1972) [`a791514b`](https://github.com/lit/lit/commit/a791514b426b790de2bfa4c78754fb62815e71d4) - Properties that must remain unminified are now compatible with build tools other than rollup/terser.

- [#2050](https://github.com/lit/lit/pull/2050) [`8758e06`](https://github.com/lit/lit/commit/8758e06c7a142332fd4c3334d8806b3b51c7f249) - Fix syntax highlighting in some documentation examples

- (Since 1.0.0-rc.2) Reverted change of the `css` tag's return to CSSResultGroup, which was a breaking change. The `css` tag again returns a `CSSResult` object.
- (Since 1.0.0-rc.2) Remove the `CSSResultFlatArray` type alias in `css-tag.ts`.

---

Changes below were based on the [Keep a Changelog](http://keepachangelog.com/) format. All changes above are generated automatically by [Changesets](https://github.com/atlassian/changesets).

---

## 1.0.0-rc.2 - 2021-05-07

### Changed

- (Since 1.0.0-rc.1) [Breaking] Change the type name `Warnings` to `WarningKind` [#1854](https://github.com/Polymer/lit-html/issues/1854).

## 1.0.0-rc.1 - 2021-04-20

### Fixed

- (Since 1.0.0-pre.3) A controller's `hostConnected` is called only once if an element is upgraded to a custom element [#1731](https://github.com/Polymer/lit-html/issues/1731).

## 1.0.0-pre.3 - 2021-03-31

### Fixed

- (Since 1.0.0-pre.2) The `createRenderRoot` method is now called only once [#1679](https://github.com/Polymer/lit-html/issues/1679).

## [1.0.0-pre.2] - 2021-02-11

### Added

- (Since 1.0.0-pre.1) Adds `static addInitializer` for adding a function which is called with the element instance when is created. This can be used, for example, to create decorators which hook into element lifecycle by creating a reactive controller ([#1663](https://github.com/Polymer/lit-html/issues/1663)).
- (Since 1.0.0-pre.1) Added `removeController(controller)` which can be used to remove a controller from a `ReactiveElement`.

### Changed

- (Since 1.0.0-pre.1) A controller's `hostUpdated` method is now called before the host's `firstUpdated` method ([#1650](https://github.com/Polymer/lit-html/issues/1650)).
- (Since 1.0.0-pre.1) Fixed `@query` decorator when cache flag is used and code is compiled with Babel ([#1591](https://github.com/Polymer/lit-html/pull/1591)).

- (Since 1.0.0-pre.1) Renamed all decorator modules to use kebab-case filename convention rather than camelCase.
- (Since 1.0.0-pre.1) `ReactiveController` callbacks all now begin with `host`, for example `hostConnected`, `hostDisconnected`, `hostUpdate`, `hostUpdated`.
- (Since 1.0.0-pre.1) If a `Controller` is added after a host element is connected, its `connected` will be called.
- (Since 1.0.0-pre.1) Removed `willUpdate` from `ReactiveController`.
- (Since 1.0.0-pre.1) Renamed `Controller`'s `dis/connectedCallback` methods.
- (Since 1.0.0-pre.1) Renamed `Controller` to `ReactiveController`.
- Made JSCompiler_renameProperty block scoped so that it's inlined in the Terser prod build. Closure should compile from the development build, or after a custom TypeScript compilation.

## [1.0.0-pre.1] - 2020-12-16

### Changed

- [Breaking] (since 3.0.0-pre1) `UpdatingElement` has been renamed to `ReactiveElement`.
- [Breaking] (since 3.0.0-pre1) The `updating-element` package has been renamed to `@lit/reactive-element`.
- [Breaking] (since 3.0.0-pre1) The `@internalProperty` decorator has been renamed to `@state`.
- [Breaking] For consistency, renamed `_getUpdateComplete` to `getUpdateComplete`.
- [Breaking] When a property declaration is `reflect: true` and its `toAttribute` function returns `undefined` the attribute is now removed where previously it was left unchanged ([#872](https://github.com/Polymer/lit-element/issues/872)).
- Errors that occur during the update cycle were previously squelched to allow subsequent updates to proceed normally. Now errors are re-fired asynchronously so they can be detected. Errors can be observed via an `unhandledrejection` event handler on window.

- UpdatingElement's `renderRoot` is now created when the element's `connectedCallback` is initially run.

- [Breaking] Update callbacks will only be called when the element is connected
  to the document. If an element is disconnected while an update is pending, or
  if an update is requested while the element is disconnected, update callbacks
  will be called if/when the element is re-connected.

### Added

- Console warnings added for removed API and other element problems in developer mode. Some warnings are errors and are always issued while others are optional. Optional warnings can be configured per class via `MyElement.enable/disableWarning`. Making changes in update warns by default and can be toggled via `MyElement.disableWarning('change-in-update)`; migration warnings are off by default and can be toggled via `MyElement.enableWarning('migration')`.

- Added ability to add a controller to an element. A controller can implement callbacks that tie into element lifecycle, including `connectedCallback`, `disconnectedCallback`, `willUpdate`, `update`, and `updated`. To ensure it has access to the element lifecycle, a controller should be added in the element's constructor. To add a controller to the element, call `addController(controller)`.

- Added `willUpdate(changedProperties)` lifecycle method to UpdatingElement. This is called before the `update` method and can be used to compute derived state needed for updating. This method is intended to be called during server side rendering and should not manipulate element DOM.

- UpdatingElement moved from `lit-element` package to `updating-element` package.

### Removed

- [Breaking] Removed `requestUpdateInternal`. The `requestUpdate` method is now identical to this method and should be used instead.
- [Breaking] The `initialize` method has been removed. This work is now done in the element constructor.

### Fixed

- Fixes an issue with `queryAssignedNodes` when applying a selector on a slot that included text nodes on older browsers not supporting Element.matches [#1088](https://github.com/Polymer/lit-element/issues/1088).


text:
# Implementing configurable hot-keys in Stripes

<!-- ../../okapi/doc/md2toc -l 2 hotkeys.md -->
* [Background](#background)
* [Configuration of react-hotkeys](#configuration-of-react-hotkeys)
* [How this can work in Stripes](#how-this-can-work-in-stripes)
    * [Mapping key specifiers to action names](#mapping-key-specifiers-to-action-names)
    * [Action names](#action-names)
    * [Getting mappings to modules](#getting-mappings-to-modules)
* [Simplifications for v1](#simplifications-for-v1)

## Background

As described in [STRIPES-13](https://issues.folio.org/browse/STRIPES-13), we want to provide a general framework for module developers to specify hot-keys that can drive their components. And as described in [STRIPES-359](https://issues.folio.org/browse/STRIPES-359), this general requirement becomes specific in the need to navigate search-results with the keyboard -- up-arrow and down-arrow to move between results.

Our general approach will be use [the react-hotkeys library](https://github.com/Chrisui/react-hotkeys), which leverages React's existing hierarchy of components to induce a heirarchy of key-bindings which can be overridden as required on progressively lower levels. A good overview is given in [_Exploring HotKeys and focus in React_](http://chrispearce.co/exploring-hotkeys-and-focus-in-react/).

We need to provide a way to supply configuration to this library in a way that can be specified by FOLIO itself or by an individual tenant, or overridden on a per-user basis.

## Configuration of react-hotkeys

From [this post](http://chrispearce.co/exploring-hotkeys-and-focus-in-react/), the configuration of react-hotkeys looks like this:

```
const keyMap = {
  'deleteNode': ['del', 'backspace'],
  'snapLeft': 'ctrl+left',
  // ...
};

const handlers = {
  'deleteNode': this.deleteNode,
  'snapLeft': this.snap.bind(this, SNAP.LEFT),
  // ...
};

<HotKeys keyMap={keyMap} handlers={handlers}>
  <SomeComponentThatInterpretsKeys/>
</Hotkeys>
```

(This is rather odd: two maps, both of them with the same set of keys. The first one, `keymap`, seems to be reversed. But no matter -- react-hotkeys will take care of interpreting this. We just need to generate it.)

Evidently there are three kinds of thing involved in the configuration:

1. **action names** such as `deleteNode` and `snapLeft`. These are short strings with a meaning that is defined within the application. Stripes-relevant examples might be `gotoUsers`, `gotoSettings`, `clearSearch`, `nextRecord`, `edit`.
2. **key specifiers** such as `['del', 'backspace']` and `'ctrl+left'`. The acceptable forms are those of [the Mousetrap library](https://craig.is/killing/mice) and need not concern us at this stage.
3. **actual actions** such as `this.snap.bind(this, SNAP.LEFT)`. These are JavaScript fragments such as might be bound to event handlers.

Where do these things come from?

#3 are of course provided by the actual modules that interpret the keys: for example, the Users module will provide the function that opens the edit-user page.

#1 are the responsibility of the module to provide: doing so is part of the module API, and it will then be up to the invoking component (most often ultimately in stripes-core) to provide a map that associates them with the key specifications #2.

#2 are configuration that may be provided as part of FOLIO's code, or overridden by tenant-level configuration, or further overridden by user-level configuration. It will be the job of stripes-core to obtain these and provide them to the modules.

## How this can work in Stripes

What follows is a _proposal_, subject to further discussion.

### Mapping key specifiers to action names

FOLIO itself -- i.e. the stripes-core code -- provides a default set of bindings from well-known actions to key specifications. These are right in the code.

Additional bindings -- which override the defaults if they both specify a meaning for the same key specifications -- are kept in the FOLIO database, in mod-configuration.

We may additionally allow these to be further overridden by user-specific bindings, also kept in mod-configuration but associated with a specific user.

A UI settings module -- possible the existing ui-organization, maybe something new -- provides the means to maintain the tenant-wide and user-specific maps.

### Action names

How will the key-map editor know what actions exist, that key combinations can be mapped to? Stripes-core will supply a list of all the action-names that it knows about, likely in the `stripes.actionNames` array.

These are gathered from the modules that stripes-core pulls in (and of course deduplicated, since many modules will likely define, for example, an `edit` action).

Each module is responsible for providing a list of the action-names that it handles. One way to do this would be to have the modules export a well-known name such as `keyMap`; but since every module exports a React component -- which is a class -- it may be more elegant to say that the class must have a static member with a well-known name, just as stripes-connect uses the static member `manifest`.

### Getting mappings to modules

The react-hotkeys way is to pass a key-map into a `<HotKeys>` component, at which point is available to all the descendents of that component by the magic of React context. Then any descendent `<HotKeys>` component can supply a set of handlers which will be used by its own descendents. (You can supply both at once if you wish.)

In the context of Stripes, we can provide the whole key-map (generated from the data in mod-configuration) to the whole web-app by wrapping the `<Root>` component in a `<HotKeys map={globalMap}>` component.

But we can then also wrap each individual module in its own `<HotKeys map={moduleMap}>` component to provide key-mappings that are specific to the module.

(It is of course the responsibility of modules to provide the `<HotKeys handlers={handlers}>` wrapper component wherever it is needed, since only the modules can know what the actual actions are.)

## Simplifications for v1

* We will need to omit user-specific configuration for now, as we have done for locale and plugin preferences -- not least, because mod-configuration's data-model doesn't seem to have a slot for username.
* We do not need to make a GUI editor for key mappings: it will suffice for now to provide a text-area, and compile that into a key-map structure. Later, we can refine this in all sorts of ways.
* Since gathering action-names from the modules is of value only to the key-mapping editor, we don't need that part of the infrastructure at this point. The supported action names will be whatever a user types into the text-area.

repository: folio-org/stripes-core

repo_name: folio-org/stripes-core


text:
# MethodsLibrary
[Under development] A central repository for things related to the OHDSI Methods Library

This builds the [Methods Library website](https://ohdsi.github.io/MethodsLibrary).

# Requirements

Make sure you have the icon package installed:
```r
devtools::install_github("ropenscilabs/icon")
```

```r
shell("R -e 'rmarkdown::build_site()'")

shell("R -e rmarkdown::render_site()")
```


text:
Comparison Statistics
=====================

(a.k.a.) Pretty Graphs

As of Tuesday (March 19th, 10 PM)

Jobs on Dice (World)
    grails: 209
    playframework -> "play framework": 9
    "spring mvc": 552

LinkedIn Skills (World)
    grails: 14051
    "play framework": 3397
    "spring mvc": 13685

Google Trends
    google-trends.png

Indeed Absolute / Relative
    indeed-*.png

Mailing List Traffic
    grails: Dec/1059, Jan/973, Feb/828
    playframework: 8434 members, Dec/1181, Jan/1797, Feb/1623

Books on Amazon
    grails: 8
    "play framework": 3

2013 Releases
    grails: 1
    play: 1

    - 2012 (grails: 9, play: 6)

Stack Overflow
    grails: 10,710
    playframework: 3,950

----------

As of Thursday (June 14th, 3 AM)

Jobs on Dice (World)
    grails: 202
    playframework -> "play framework": 5
    play framework: 471

LinkedIn Skills (World)
    grails: 9,140
    play framework: 13,027
    playframework: 146

Google Trends
    google-trends.png

Indeed Absolute / Relative
    indeed-*.png

Mailing List Traffic
    grails: May/1299, April/1377, 1503
    playframework: 6081 members, Mar/3365, 2884, May/2760

Books on Amazon
    grails: 12 (first 2 pages)
    "play framework": 2

2012 Releases
    grails: 3
    play: 2

Stack Overflow
    grails: 7,424
    playframework: 2,467

repository: jamesward/happytrails

repo_name: jamesward/happytrails


text:
# ComEth

[![built-with openzeppelin](https://img.shields.io/badge/built%20with-OpenZeppelin-3677FF)](https://docs.openzeppelin.com/)

## _Built by "Rhino Team" for its certification project at Alyra, the Blockchain School_ !

[Rhino Team](./public/favicon.ico)

#### Developers : Sarah Marques, Stella Soler, Amine Benmissi, Guillaume Bézie

[![created-by LokieDieKatze](https://img.shields.io/badge/created%20by-LokiDieKatze-FFA07A)](https://github.com/LokiDieKatze)
[![created-by StellaGreen](https://img.shields.io/badge/created%20by-StellaGreen-FFA07A)](https://github.com/StellaGreen)
[![created-by Benmissi-A](https://img.shields.io/badge/created%20by-Benmissi-FFA07A)](https://github.com/Benmissi-A)
[![created-by LokieDieKatze](https://img.shields.io/badge/created%20by-GuillaumeB75-FFA07A)](https://github.com/GuillaumeB75)

---

## Description

- testnet use : Rinkeby
- **ComEth dApp**

  This repository contains a React project for our DAO-like ComEth dApp using the Ethereum Blockchain. There will be a "ComEth Factory" allowing a user to create a personalized ComEth project according to its own needs. Each ComEth gathers users who have common interests and offers them tools to organize their activity in a entirely decentralized way, including voting and managing the Ethers of a common pot.

---

## Installation

To use this dApp you need to "fork" this repository :

- Dapp_ComEth :

On your Git Bash, choose the location then:

```
git clone https://github.com/Benmissi-A/Dapp_ComEth
cd Dapp_ComEth
yarn
```

---

## Smart contracts

- **ComEthFactory.sol**

  This contract allows any user to create a ComEth by picking the options that applies best to its case. After filling out the form, a new ComEth will be created and deployed on Ethereum. The creator of the ComEth will automatically become the owner of the new ComEth Contract and will be the only member allowed to add new members to the ComEth.

- **ComEth.sol**

  Join your ComEth, pay your subscription and start submitting proposals to the community and vote! The amount of the subscription is defined in advance by the ComEth Owner and will remain the same. The subscription time lasts 4 weeks, after which the payment has to be proceeded again. The subscription starts at a specific time and does not depend on the day the user pays.

  Submit a proposal:
  Write a proposal and enter different possible vote options, a timelimit, an amount and payment address for the matching Ether transfer. An event is then emitted.

  Vote:
  You can vote if you are not banned and if you have the status "active" and are up-to-date with your subscription payments. An event is emitted but your choice is not saved.
  For a proposal to be approved, it must gather over 50 % of the total number of users. Once it is approved, the payment is processed: the defined amount will be transferred to the registered recipient.

  Quit your ComEth:
  You must not be banned if you wish to leave your ComEth. You will have to sort your payment situation out first.
  The amount that you can get back is calculated on the basis of your fair share (current amount of the common pot divided by the (weighted) number of users ).

---

## Licence

MIT License

Copyright (c) 2021 Dapp_ComEth

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

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

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


text:
# bluetooth-manager-bluegiga
A transport implementation for Bluetooth Manager based on Bluegiga API to work with BLE112 dongles (or similar)

To install bluegiga library:
mvn install:install-file -Dfile=com.zsmartsystems.bluetooth.bluegiga-1.0.0-SNAPSHOT.jar -DgroupId=com.zsmartsystems.bluetooth -Dversion=1.0.0-SNAPSHOT -Dpackaging=jar -DartifactId=com.zsmartsystems.bluetooth.bluegiga