text:
This tool converts a log stream of binary packets to human-readable output.

Reuses shared packet definitions and utilities found in [`common/inc/`](../../common/inc/).

See the [`commander`](../commander) readme for a nicer way to launch multiple `monitor`s.

Launch with:
```bash
# One-time read to end of file
make && cat ../../common/tests/data.bin | ./monitor

# Continuously read growing file
make && tail -c +1 -f ../commander/all.bin | ./monitor
```

Example output:
```
Sequence 0, Origin 0 Internal, ID 2 ParsingErrorInvalidLength: 134678021
Sequence 0, Origin 0 Internal, ID 6 ParsingErrorDroppedBytes: 64
Sequence 1, Origin 0 Internal, ID 8 VfdSetFrequency: node 3, frequency 2.5 Hz
Sequence 2, Origin 0 Internal, ID 8 VfdSetFrequency: node 3, frequency 5.0 Hz
Sequence 0, Origin 0 Internal, ID 2 ParsingErrorInvalidLength: 1
Sequence 0, Origin 0 Internal, ID 2 ParsingErrorInvalidLength: 316
Sequence 0, Origin 0 Internal, ID 4 ParsingErrorInvalidID: 12
Sequence 0, Origin 0 Internal, ID 3 ParsingErrorInvalidCRC: provided 0x000004D2, calculated 0xDE4F523F
Sequence 0, Origin 0 Internal, ID 6 ParsingErrorDroppedBytes: 112
Sequence 0, Origin 0 Internal, ID 5 ParsingErrorInvalidSequence: provided 7, expected 3
Sequence 7, Origin 0 Internal, ID 8 VfdSetFrequency: node 3, frequency 5.0 Hz
Sequence 8, Origin 0 Internal, ID 8 VfdSetFrequency: node 3, frequency 5.0 Hz
Sequence 0, Origin 0 Internal, ID 6 ParsingErrorDroppedBytes: 7
Got EOF
read a total of 318 bytes
remaining bytes 23
done
```


text:
A simple command line application to fetch kseb electricity payment dues as it takes too much time and effort to do this manually. ;)

Originally written for i3blocks.

The code is untested and there is no guarantee that it will not break when the webpage changes.

### Installation
```bash

git clone "git@github.com:4lhc/kseb-cli.git"
cd kseb-cli
python3 -m venv kseb-cli #requires python3-venv
pip install -r requirements.txt
sudo apt install firefox-geckodriver

```

### Run
```bash

python3 kseb-cli.py <customer-number>

```
![Screenshot](./Screenshot.png)

license: MIT

branch_name: refs/heads/master

extension: md

gha_language: Python

gha_license_id: MIT

license_type: permissive


text:
# Service Broker for HERE Location Services

Service Broker for HERE Location Services is an implementation of the [Open Service Broker][osb] for  [HERE][here] enterprise-grade, SLA-backed HERE Location Services. It  enables discovery and provisioning of HERE Location Services REST APIs in a cloud cluster.

## HERE Location Services
### Description
[HERE Location Services][here-location-services] are key in use cases such as Fleet Utilization, Supply Chain Optimization, Urban Mobility, etc. They open up new location intelligence opportunities in diverse enterprise and technology areas, including the Internet of Things, Automotive, Insurance, Advertising, Mobile Payments, Public Sector, Smart Cities, Telecom, Utilities, and Transportation and Logistics. HERE Location Services cover Geocoder, Search, Navigation, Routing, Fleet Telematics, Positioning and other services, providing soultions for map visualization, navigation, routing, geocoding, time zone lookups, geofencing, custom locations, routing, route matching GPS traces, geospatial, sequencing multiple waypoints, truck routing, positioning, etc.

### Features and Capabilities
| Feature  | Description |
| :------------- | :------------- |
| Map Tile API  | Integrate server-rendered raster 2D map tiles in multiple styles, such as base, aerial and fleet. Use different zoom levels, display options, map views and schemes, including the Truck Attributes Map layer for large vehicles. |
| Map Image API | Get access to pre-rendered map images that are optimized for desktop and mobile devices. Add route polygons, POI labels and other objects on top of the map to give your users the insights they need. |
|Vector Tile API | Integrate client-side rendered vector tiles and customize the look and feel of the map by changing, removing or adding specific map properties or objects. |
| Geocoding and Search API | Accurately pinpoint geo-coordinates, addresses and Places/POIs on the map; explore a vast database of Places/POIs through one box search and get better suggestions with fewer strokes with autosuggest. |
| Routing API | Complete complex journeys more efficiently with advanced routing algorithms including truck routing, large scale matrix routing and traffic-enabled routing. Get accurate ETAs and routing instructions in over 108 languages. |
| Public Transit API| Provide the best public transit routes while highlighting walking directions to stops, pedestrian access points, station locations and transfer locations along the way. |
| Intermodal Routing API | Provide a choice of routes that combine car, bike, taxi, pedestrian and public transit modes while taking into account several variables: real-time traffic, incidents, public transit timetables and other dynamic information. |
| Traffic API | Add real-world context to your application by integrating real-time and historical traffic information about accidents, congestion, construction and more. |
| Fleet Telematics API | Integrate advanced algorithms ready to solve complex location problems, such as toll cost calculation, route matching GPS traces and geofencing. |
| Weather API | Get current weather reports or weather forecasts and check for severe weather alerts at a specific location. |
| Positioning API | Build applications that require location estimates based on radio network measurement data. Supported measurement data includes 2G, 3G, 4G, and WLAN measurements. |

# Getting Started
[Get started for FREE][here-dev-sign-up-osb] with HERE Location Services to add location intelligence to any applications and solutions in your cluster.

The following guides make it easy for you to install the Service Broker. To proceed, choose the target platform for the installation:
  * [OpenShift](/docs/openshift.md)
  * [Kubernetes](/docs/kubernetes.md)

For HERE Location Services REST API Documentation please go to: [Documentation](/docs/HLSRESTAppID.md)

# License

Copyright (C) 2019 HERE Europe B.V.

See the [LICENSE](./LICENSE) file in the root of this project for license details.

[here]: https://www.here.com/

[here-dev-plans]: https://developer.here.com/plans

[here-dev-sign-up-osb]: https://developer.here.com/plans?utm_medium=referral&utm_source=GitHub-Service-Broker&create=Freemium

[here-location-services]: https://www.here.com/products/location-based-services

[osb]: https://www.openservicebrokerapi.org

[osb-spec]: https://github.com/openservicebrokerapi/servicebroker/blob/v2.14/spec.md

[youtube-here-osb]: https://www.youtube.com/user/heremaps

repository: herejithing/here-hls-service-broker

gha_language: Java

repo_name: herejithing/here-hls-service-broker


text:
# Yoast Coding Standards

Yoast Coding Standards (YoastCS) is a project with rulesets for code style and quality tools to be used in Yoast projects.

## Installation

### Standalone

Standards are provided as [Composer](https://getcomposer.org/) package and can be installed with:

```bash
composer create-project yoast/yoastcs:dev-master
```

Composer will automatically install dependencies, register standards paths, and set default PHP Code Sniffer standard to `Yoast`.

### As dependency

To include standards as part of a project require them as development dependencies:

```bash
composer require yoast/yoastcs:dev-master --dev
```

Note that Composer won't run configuration scripts in this scenario and the root project needs to take care of it.

## PHP Code Sniffer

Set of [PHP Code Sniffer](https://github.com/squizlabs/PHP_CodeSniffer) rules.

Based on [WordPress Coding Standards](https://github.com/WordPress-Coding-Standards/WordPress-Coding-Standards) project, implementing official [WordPress PHP Coding Standards](https://make.wordpress.org/core/handbook/coding-standards/php/).

Severity levels:

 - error level issues are considered mandatory to fix in Yoast projects and enforced in continuous integration
 - warning level issues are considered recommended to fix

### Command line

```bash
"vendor/bin/phpcs" --extensions=php /path/to/folder/
```

### PhpStorm

Refer to [Using PHP Code Sniffer Tool](https://www.jetbrains.com/phpstorm/help/using-php-code-sniffer-tool.html) in PhpStorm documentation.

After installation `Yoast` standard will be available as a choice in PHP Code Sniffer Validation inspection.

## PHP Mess Detector

Set of [PHP Mess Detector](http://phpmd.org/) rules.

Original ruleset, produced for Yoast projects, taking under consideration typical WordPress practices and current state of code base.

All issues are considered informational for code development and maintenance.

### Command line

```bash
"vendor/bin/phpmd" /path/to/folder/ text phpmd.xml
```

### PhpStorm

Refer to [Using PHP Mess Detector](https://www.jetbrains.com/phpstorm/help/using-php-mess-detector.html) in PhpStorm documentation.

After installation add `phpmd.xml` file from project as custom ruleset in PHP Mess Detector Validation inspection settings.

## Changelog

The changelog for this package can be found in the [CHANGELOG.md](https://github.com/Yoast/yoastcs/blob/develop/CHANGELOG.md) file.

repository: Danack/example

repo_name: Danack/example


text:
# YFA
Youtube Finished At. Shows the time a Youtube video ends if you start it now; right on the thumbnail.

![Preview image](https://raw.githubusercontent.com/bad-kitty9153/YFA/master/thumbnails.png)

Forgive the terrible code, I was sleep deprived and emotional when I wrote this and I won't bother fixing it because it's just for myself anyway. It fullfils its purpose and that's all I care about for now.

# Installation
* Clone or download.
* Unzip.
* Go to `chrome://extensions`.
* Enable Developer mode.
* Click `Load unpacked`.
* Browse to YFA folder and click open.

---

Icons made by Freepik from  www.flaticon.com

license: Unlicense

gha_language: JavaScript

gha_license_id: Unlicense


text:
# openvpn
openvpn easy installation

```bash
git clone https://github.com/Xaqron/openvpn.git
cd openvpn
sudo bash install.sh
```

During installation you need to specify some configurations:
* Your machine `public IP` address
* Although `UDP` protocol is recommended, you need to use `TCP` if you are gonna redirect traffic via [stunnel](https://www.stunnel.org) later.
* openvpn uses `UDP 1194` as default protocol/port. If you plan to use `stunnel` then a ~~port like `443` or `578`~~ use some TCP port (i.e. `1194`).
* Use Google as `DNS` provider (option two).

<img src ="img/config.png">

If you have no plan for redirecting traffic via `stunnel` then just proceed with default options (except for `DNS` provider which is recommended to be used the google ones).

# add/remove users
```bash
sudo bash openvpn.sh
```
Client config file (*.ovpn) will be placed at current user home.
```
ls ~/*.ovpn
```

repository: kenpachizrk/openvpn

repo_name: kenpachizrk/openvpn


text:
# Job Interview Web Application

Following the instructions within this readme should allow anyone to fully assess the functionality of this application.

Note that the database will be populated on application launch with two accounts:

    Account 1, with ID: 1, and balance 2209.29
    Account 2, with ID: 2, and balance 3569.00

## 1. Database

### 1.1. Setting Up a Local Postgres Docker Container

We will use a docker container for this application.

Firstly install and configure docker, then:

run:

    `docker pull postgres:11`

followed by:

    `docker run --name local-dev-postgres -p 5432:5432 -e POSTGRES_PASSWORD="password" -d postgres:11`

note: we only use a weak password such as "password" because this is a demo app.

create a database:

    `docker exec local-dev-postgres psql -U postgres -c"CREATE DATABASE bankdb" postgres`

### 1.2. To query the local running DB

if it is necessary to start the docker container: `docker start local-dev-postgres`

followed by: `docker exec -it local-dev-postgres bash`

then launch psql: `psql -U postgres`

enter the database: `\c bankdb`

finally, use `\dt` to view tables, and then any valid SQL query should be sufficient.

## 2. Building

First set up the database.

The build system in use is gradle, all the normal rules for gradle apply here.

To build:

    `gradlew build`

To run:

    `gradlew bootrun`

By default, the application will run on port 8080, with the address localhost.

## 3. Endpoints

Currently, the API here implements two endpoints:

    `/statement/{id}` (request type GET)

where ID is the ID of the account. By default the database will contain 2 accounts, with ID 1 and 2.
This endpoint returns a JSON object containing the accounts ID, current balance, and a list of all transactions the account was a part of, both as payee and recipient.

And:

    `/transaction/pay/{payeeId}/{recipientId}/{amount}` (request type POST)

Where payeeId is the ID of the payers account, recipientId is the ID of the recipients account, and amount is the amount of money as a floating point value.
This endpoint will return a boolean status flag, true if the transaction was successful, false if not. An error may also be returned if the account does not exist.

## 4. Examples of Usage

    `http://localhost:8080/transaction/pay/1/2/200.00`
    `http://localhost:8080/transaction/pay/2/1/304.23`
    `http://localhost:8080/statement/1`

branch_name: refs/heads/main


text:
![](https://img.shields.io/badge/Microverse-blueviolet)

# Philippe Jaroussky's Concert Webpage

> A webpage for a *somewhat fictional* concert of the artist [Philippe Jaroussky](http://www.philippejaroussky.fr/). Based on [Cindy Shin's concept](https://www.behance.net/gallery/29845175/CC-Global-Summit-2015).

## This is my first Capstone project for the Microverse program
- It consists of a web page for a concert;
- It's based on a given concept design;
- It has three pages;
- It's responsive and has optimized versions for different screen sizes:
    - mobile: up to 768px;
    - desktop: from 768px;
- It follows the colors, typographies, and layout of the given design.

## Built With

- HTML
- CSS

## Live Demo

[Here's a link to a live demo](https://brenoxav.github.io/philippe-jaroussky-concert/)

## Author

👨💻 **Breno Xavier**

- GitHub: [@brenoxav](https://github.com/brenoxav)
- Twitter: [@brenoxav](https://twitter.com/brenoxav)
- LinkedIn: [Breno Xavier](https://linkedin.com/in/brenoxav)

## Show your support

Give a ⭐ if you like this project!

## Acknowledgments

- [Cindy Shin](https://www.behance.net/adagio07) for the concept design.
- [Philippe Jaroussky](http://www.philippejaroussky.fr/): The artist who served as inspiration for this project's theme.

### I've made use of resources from:

- [Zeta Fonts](http://www.zetafonts.com/cocogoose) (typography)
- [Lato Fonts](https://www.latofonts.com/) (typography)
- [Free Vector](https://www.freevector.com/) (icons)
- [flaticon](https://www.flaticon.com/) (icons)

## 📝 License

This project is [MIT](LICENSE) licensed.

repository: brenoxav/philippe-jaroussky-concert

repo_name: brenoxav/philippe-jaroussky-concert


text:
# Cuneiform Plotting Library

This library visualizes Cuneiform history logs. These logs can be collected by connecting to a common runtime environment (CRE) via `localhost:4142/history.json`.

## Usage

### Building the cfplot Command Line Tool

A binary can be created by entering

    raco make -j 8 *.rkt
    raco exe cfplot.rkt

The resulting file `cfplot` provides a command line interface to the plotting library.

### Using cfplot

    cfplot my-history-file.json

## History JSON format

A history document is a JSON document with a single field `history`. The value of the `history` field is a list. Each entry in this list is an object with two fields: `app` and `delta`. The `app` field describes the task that was executed as it was scheduled to the execution engine. The `delta` field describes the result of the execution. Below is a history document with one app-delta pair. The ellipses at the end of the history list represent the following entries.

    {
      "history": [
        {
          "app": {
            "app_id": "042913bc99e7464b8ab377a36bbe17cda963445664cf5f3d1b70e74f",
            "arg_bind_lst": [
              {
                "arg_name": "idx",
                "value": "8d851bb_idx.tar"
              },
              {
                "arg_name": "fastq",
                "value": "558b7dd_SRR576938.sra.fastq"
              }
            ],
            "lambda": {
              "arg_type_lst": [
                {
                  "arg_name": "idx",
                  "arg_type": "File",
                  "is_list": false
                },
                {
                  "arg_name": "fastq",
                  "arg_type": "File",
                  "is_list": false
                }
              ],
              "lambda_name": "bowtie-align",
              "lang": "Bash",
              "ret_type_lst": [
                {
                  "arg_name": "bam",
                  "arg_type": "File",
                  "is_list": false
                }
              ],
              "script": "\n  bam=$fastq.bam\n  tar xf $idx\n  bowtie -S idx $fastq | samtools view -b - > $bam\n"
            }
          },
          "delta": {
            "app_id": "042913bc99e7464b8ab377a36bbe17cda963445664cf5f3d1b70e74f",
            "result": {
              "node": "cf_worker@default-ubuntu-1804",
              "ret_bind_lst": [
                {
                  "arg_name": "bam",
                  "value": "b70e74f_558b7dd_SRR576938.sra.fastq.bam"
                }
              ],
              "stat": {
                "run": {
                  "duration": "178156775904",
                  "t_start": "1545049650778968246"
                },
                "sched": {
                  "duration": "178197792686",
                  "t_start": "1545049650753821561"
                },
                "stage_in_lst": [
                  {
                    "duration": "13259112",
                    "filename": "8d851bb_idx.tar",
                    "size": "13373440",
                    "t_start": "1545049650755376933"
                  },
                  {
                    "duration": "9195502",
                    "filename": "558b7dd_SRR576938.sra.fastq",
                    "size": "1355957118",
                    "t_start": "1545049650769217200"
                  }
                ],
                "stage_out_lst": [
                  {
                    "duration": "10451127",
                    "filename": "b70e74f_558b7dd_SRR576938.sra.fastq.bam",
                    "size": "272845997",
                    "t_start": "1545049828936511802"
                  }
                ]
              },
              "status": "ok"
            }
          }
        },
        ...
      ]
    }

### App Field

The `app` field of a history entry describes an independent task (job, invocation, ...). An `app` is a closure of the form of a function application consisting of a function and argument bindings. An `app` object has the following fields:

- `app_id` a unique string that identifies the application. This can be a hash, a UUID, or any arbitrary identifying string.
- `lambda` an object describing the foreign function to be executed.
- `arg_bind_lst` a list of objects that enumerate the argument bindings.

### Delta Field

The `delta` field is says the result of the execution.

- `app_id` must match the corresponding application
- `result` contains a `ret_bind_list` field holding the values produced by the application, a `node` field identifying the computer the application ran on, and a `stat` field holding statistics about the execution.

## Graph Types

### Dependency Graph

![2019-01-17-variant-call-varscan-gruenau-4x120-2x32-2x16-gluster4-dep](img/2019-01-17-variant-call-varscan-gruenau-4x120-2x32-2x16-gluster4-dep.png)

*Complete variant call dependency graph*

![2019-01-17-variant-call-varscan-gruenau-4x120-2x32-2x16-gluster4-dep-detail](img/2019-01-17-variant-call-varscan-gruenau-4x120-2x32-2x16-gluster4-dep-detail.png)

*Detail of the variant call dependency graph*

### Worker Allocation Graph

![2019-01-17-variant-call-varscan-gruenau-4x120-2x32-2x16-gluster4-lipka](img/2019-01-17-variant-call-varscan-gruenau-4x120-2x32-2x16-gluster4-lipka.png)

### Staging Bandwidth over Time Scatter Plot

![2019-01-17-variant-call-varscan-gruenau-4x120-2x32-2x16-gluster4-bandwidth-scatter](img/2019-01-17-variant-call-varscan-gruenau-4x120-2x32-2x16-gluster4-bandwidth-scatter.png)

### Staging Bandwidth Density

![2019-01-17-variant-call-varscan-gruenau-4x120-2x32-2x16-gluster4-bandwidth-density](img/2019-01-17-variant-call-varscan-gruenau-4x120-2x32-2x16-gluster4-bandwidth-density.png)

### Stage-in Bandwidth Density per Compute Node

![2019-01-17-variant-call-varscan-gruenau-4x120-2x32-2x16-gluster4-stage-in-bandwidth-density-node](img/2019-01-17-variant-call-varscan-gruenau-4x120-2x32-2x16-gluster4-stage-in-bandwidth-density-node.png)

### Stage-out Bandwidth Density per Compute Node

![2019-01-17-variant-call-varscan-gruenau-4x120-2x32-2x16-gluster4-stage-out-bandwidth-density-node](img/2019-01-17-variant-call-varscan-gruenau-4x120-2x32-2x16-gluster4-stage-out-bandwidth-density-node.png)

### Processing Throughput Scatter Plot

![2019-01-17-variant-call-varscan-gruenau-4x120-2x32-2x16-gluster4-throughput-scatter](img/2019-01-17-variant-call-varscan-gruenau-4x120-2x32-2x16-gluster4-throughput-scatter.png)

### Processing Throughput Density

![2019-01-17-variant-call-varscan-gruenau-4x120-2x32-2x16-gluster4-throughput-density](img/2019-01-17-variant-call-varscan-gruenau-4x120-2x32-2x16-gluster4-throughput-density.png)

### Processing Throughput Density per Compute Node

![2019-01-17-variant-call-varscan-gruenau-4x120-2x32-2x16-gluster4-throughput-density-node](img/2019-01-17-variant-call-varscan-gruenau-4x120-2x32-2x16-gluster4-throughput-density-node.png)

### Processing Selectivity Scatter Plot

![2019-01-17-variant-call-varscan-gruenau-4x120-2x32-2x16-gluster4-selectivity](img/2019-01-17-variant-call-varscan-gruenau-4x120-2x32-2x16-gluster4-selectivity.png)

## System Requirements

- [Racket](https://www.racket-lang.org) 7.0 or higher

## Resources

- [cuneiform-lang.org](https://www.cuneiform-lang.org/). Official website of the Cuneiform programming language.

## Authors

- Jörgen Brandt ([@joergen7](https://github.com/joergen7/)) [joergen<EMAIL_ADDRESS>
## License

[Apache 2.0](https://www.apache.org/licenses/LICENSE-2.0.html)


text:
# bitcoin-sv

Docker-Bitcoin
Included in this repo are docker images for the Bitcoin SV Node implementation. Thanks to Josh Ellithorpe and his repository, which provided the base for this repo.

This Docker image provides bitcoind, bitcoin-cli and bitcoin-tx which can be used to run and interact with a Bitcoin server.

To see the available versions/tags, please visit the Docker Hub page.

Usage
To run the latest version of Bitcoin SV:

$ docker run bitcoinsv/bitcoin-sv
To run a container in the background, pass the -d option to docker run, and give your container a name for easy reference later:

$ docker run -d --rm --name bitcoind bitcoinsv/bitcoin-sv
Once you have the bitcoind service running in the background, you can show running containers:

$ docker ps
Or view the logs of a service:

$ docker logs -f bitcoind
To stop and restart a running container:

$ docker stop bitcoind
$ docker start bitcoind
Configuring Bitcoin
The best method to configure the server is to pass arguments to the bitcoind command. For example, to run Bitcoin SV on the testnet:

$ docker run --name bitcoind-testnet bitcoinsv/bitcoin-sv bitcoind -testnet
Alternatively, you can edit the bitcoin.conf file which is generated in your data directory (see below).

Data Volumes
By default, Docker will create ephemeral containers. That is, the blockchain data will not be persisted, and you will need to sync the blockchain from scratch each time you launch a container.

To keep your blockchain data between container restarts or upgrades, simply add the -v option to create a data volume:

$ docker run -d --rm --name bitcoind -v bitcoin-data:/data bitcoinsv/bitcoin-sv
$ docker ps
$ docker inspect bitcoin-data
Alternatively, you can map the data volume to a location on your host:

$ docker run -d --rm --name bitcoind -v "$PWD/data:/data" bitcoinsv/bitcoin-sv
$ ls -alh ./data
Using bitcoin-cli
By default, Docker runs all containers on a private bridge network. This means that you are unable to access the RPC port (8332) necessary to run bitcoin-cli commands.

There are several methods to run bitclin-cli against a running bitcoind container. The easiest is to simply let your bitcoin-cli container share networking with your bitcoind container:

$ docker run -d --rm --name bitcoind -v bitcoin-data:/data bitcoinsv/bitcoin-sv
$ docker run --rm --network container:bitcoind bitcoinsv/bitcoin-sv bitcoin-cli getinfo
If you plan on exposing the RPC port to multiple containers (for example, if you are developing an application which communicates with the RPC port directly), you probably want to consider creating a user-defined network. You can then use this network for both your bitcoind and bitclin-cli containers, passing -rpcconnect to specify the hostname of your bitcoind container:

$ docker network create bitcoin
$ docker run -d --rm --name bitcoind -v bitcoin-data:/data --network bitcoin bitcoinsv/bitcoin-sv
$ docker run --rm --network bitcoin bitcoinsv/bitcoin-sv bitcoin-cli -rpcconnect=bitcoind getinfo
Kubernetes Configs
The following directions will walk you through creating a Bitcoin SV node within GKE (Google Container Engine).

If you wish to run another version of bitcoind, just change the image reference in bitcoin-deployment.yml.

Steps:

Add a new blank disk on GCE called bitcoin-data that is 200GB. You can always expand it later.
Save the following code snippets and place them in a new directory kube.
Change the rpcuser and rpcpass values in bitcoin-secrets.yml. They are base64 encoded. To base64 a string, just run echo -n SOMESTRING | base64.
Run kubectl create -f /path/to/kube
Profit!

```
bitcoin-deployment.yml
apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  namespace: default
  labels:
    service: bitcoin
  name: bitcoin
spec:
  strategy:
    type: Recreate
  replicas: 1
  template:
    metadata:
      labels:
        service: bitcoin
    spec:
      containers:
      - env:
        - name: BITCOIN_RPC_USER
          valueFrom:
            secretKeyRef:
              name: bitcoin
              key: rpcuser
        - name: BITCOIN_RPC_PASSWORD
          valueFrom:
            secretKeyRef:
              name: bitcoin
              key: rpcpass
        image: bitcoinsv/bitcoin-sv
        name: bitcoin
        volumeMounts:
          - mountPath: /data
            name: bitcoin-data
        resources:
          requests:
            memory: "2Gi"
      restartPolicy: Always
      volumes:
        - name: bitcoin-data
          gcePersistentDisk:
            pdName: bitcoin-data
            fsType: ext4

bitcoin-secrets.yml

apiVersion: v1
kind: Secret
metadata:
  name: bitcoin
type: Opaque
data:
  rpcuser: YWRtaW4=
  rpcpass: aXRvbGR5b3V0b2NoYW5nZXRoaXM=
bitcoin-srv.yml
apiVersion: v1
kind: Service
metadata:
  name: bitcoin
  namespace: default
spec:
  ports:
    - port: 8333
      targetPort: 8333
  selector:
    service: bitcoin
  type: LoadBalancer
  externalTrafficPolicy: Local
```

Complete Example
For a complete example of running a bitcoin node using Docker Compose, see the Docker Compose example.

License
Configuration files and code in this repository are distributed under the MIT license.

Contributing
All files are generated from templates in the root of this repository. Please do not edit any of the generated Dockerfiles directly.

To add a new version, update versions.yml, then run make update.
To make a change to the Dockerfile which affects all current and historical versions, edit Dockerfile.erb then run make update.
If you would like to build and test containers for all versions (similar to what happens in CI), run make.

repository: reinaldoca/bitcoin-sv

repo_name: reinaldoca/bitcoin-sv


text:
# Working with Azure Databricks from the Data Science VM

This article discusses how you can develop your Spark (PySpark, Scala) code on the Data Science Virtual Machine and deploy them on Azure  Databricks for scaling out.
The Windows 2016 DSVM (Mar 2018 edition onwards) comes pre-loaded with Databricks CLI that is used throughout in this article. We will be adding the CLI to other editions soon.

Hence is a high level steps and commands:

1. Activate to the correct Python environment

Databricks CLI is supported currently only in Python 2.7. On the data science VM, the python 2.7 conda environment is ```python2```.

```
activate python2
```

2. Associate your CLI to your Azure Databricks account
```
databricks configure --token
```

This will prompt you to enter the token. You have to generate the token on your Databrocks workspace as specified in the [documentation](https://docs.azuredatabricks.net/api/latest/authentication.html#token-management).

3. Now you can create folders on Databricks workspace
```
databricks workspace mkdirs /dsvmtest
```

4. Develop you Spark programs including notebooks on the Data Science VM. Test it locally on the standalone Spark on the Data Science VM.

5. Upload the Python or Scala or Notebook  file to the Databricks workspace
```
databricks workspace import "sample1.ipynb" /dsvmtest/sample1 -l PYTHON -f JUPYTER
```

6. Next you can create a cluster on Databricks that will serve as the compute.
```
#Create a cluster on the portal and run the notebook.
# You can also create through CLI "databricks clusters create --json-file <cluster spec file>"

# Now try to deploy the notebook as a Job.
```
7. Submit a Job
```
databricks jobs create --json-file <JOB SPEC FILE>
```

The Job Spec file looks like this:
```
dbjobspec.txt
{
	"name":"MMLspark submit python job",
      "existing_cluster_id": "0222-234567-cloud137",
    "notebook_task": {
      "notebook_path": "/dsvmtest/sample1"
    }
}
```

Note: You can also upload Python scripts/ notebooks to DBFS and reference notebook_path as dbfs:/xxx.ipynb or dbfs://yyy.py

8. Check the status of the Job
```
databricks runs list
databricks runs get --run-id <runID>
```

We have shown how easy is it to develop and debug your Spark applications on the Data Science VM on the standalone instance and then scale it out on the Databricks Spark cluster for performance and manageability.

repository: Azure/DataScienceVM

gha_language: Jupyter Notebook

repo_name: Azure/DataScienceVM


text:
Setting up DPDK
===============

Compile DPDK
    cd dpdk
    make config T=x86_64-native-linuxapp-gcc
    make T=x86_64-native-linuxapp-gcc

Load the `igb_uio` driver and its dependency `uio`
	modprobe uio
	insmod build/kmod/igb_uio.ko

Use the tool `dpdk-devbind.py` to bind the VirtIO NICs to the `igb_uio` driver.
(Find out how to do this, the tool is pretty self-explanatory.)
	usertools/dpdk-devbind.py --h

Setup hugetlbfs huge pages for DPDK
	mkdir /mnt/huge
	mount -t hugetlbfs nodev /mnt/huge
Statically allocate 256 2MB huge pages
	echo 256 > /sys/devices/system/node/node0/hugepages/hugepages-2048kB/nr_hugepages

Compiling your App
==================

This example project comes with a CMakeFile and a simple wrapper that initializes DPDK for you.
Run the following steps to build the router app
    cmake .
    make

That's all!

Commpiling gtest
================

Compiling the gtest library is required to execute table-test

Fetching gtest
    apt-get install libgtest-dev

Compiling gtest
    cd /usr/src/googletest/googletest
    cmake .
    make install


text:
---
title: Resilience
permalink: /literature/curatedreads/values/resilience
breadcrumb: Curated Reads - Resilience
collection_name: literature
third_nav_title: Values
---

We are far more resilient than we think. All of us possess inner strength and have the ability to overcome obstacles.

It has been said that adversity builds character. To bounce back from failures requires one to focus on requires positivity, patience and persistence.

What happens when life throws us lemons? Can we make lemonade?

Be inspired by these resources about triumphing despite difficult circumstances.

## **CORE READ**

| ![Resilience image](/images/literature/curatedreads/values/HiRes_Resized.jpg) | **How to Bounce Back from Failure – Over and Over Again**

 Resilient people seek out growth experiences that boost self-reliance and individual decision-making skills, which gives them confidence in their ability to bounce back from failure. Those who have mastered the art of resilience know that setbacks and challenges can be our most powerful learning opportunities. |

Not once, not twice but getting right back up every time we fall. [Here’s a practical article](https://www.huffpost.com/entry/habits-of-resilient-people_n_381865) about seven habits of highly resilient people and ways to improve our own ability to cope with challenges. While we cannot avoid setbacks, we can choose to persevere and not give up!

**Anne Frank: The Diary of a Young Girl**

Call no.:<PHONE_NUMBER>6 FRA

Discover the vivid and moving diary entries of Anne Frank, a 13-year-old Jewish girl who, together with her family, went into hiding for two years in Amsterdam during the Nazi occupation of Holland in 1942.

[Visit our public libraries to borrow a physical copy.](https://eservice.nlb.gov.sg/item_holding.aspx?bid=201651957)

Book cover image credit: All rights reserved, London: Viking, 2012.

**Speech by Dr Ng Eng Hen, Minister for Education and Second Minister for Defence, at the National University of Singapore Dialogue, 22 January 2010**

Dr Ng [talks about how Singapore faced and overcame](https://www.nas.gov.sg/archivesonline/data/pdfdoc/20100129001/nuss_ministerial_speech(final).pdf) four global and national challenges between 2001 and 2008 and the learning lessons drawn from these experiences.

![Snail image](/images/literature/curatedreads/values/iStock_36889986_MEDIUM_Resized.jpg)

**Harper Lee's Only Recorded Interview About "To Kill a Mockingbird"**

[Listen as the author talks](https://www.youtube.com/watch?v=EfsFeMRF7CU&feature=youtu.be) about her critically acclaimed novel that tells the story about racial injustice through the eyes of a child. The bestseller, "To Kill a Mockingbird", won the Pulitzer Prize in 1961 and was adapted into the well-known classic film the following year.

![Logos image](/images/literature/curatedreads/logos-updated.jpeg)

repository: nlbnls/nlb-reference

repo_name: nlbnls/nlb-reference


text:
# effrit-action

A github action for [effrit](https://github.com/Skarlso/effrit).

## Example Action

A simple example on how to use this action:

```yaml
name: Effrit
on: pull_request
jobs:
  effrit:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v2
      - name: Unshallow
        run: git fetch --prune --unshallow
      - name: Effrit
        uses: skarlso/effrit
        with:
          pr_number: ${{ github.event.pull_request.number }}
          owner: Skarlso
          repo: effrit
          project_name: effrit
          parallel_files: 5
        env:
          EFFRIT_GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
```

repository: Skarlso/effrit-action

repo_name: Skarlso/effrit-action


text:
# devunity-installer

This is the installer for Devunity.

## How to use
To execute it, run the following commands:

```
wget https://raw.githubusercontent.com/Ubuntu-Unity/devunity-installer/master/devunity-inst
chmod +x devunity-inst
./devunity-inst <PATH-TO-DEVUNITY-BINARY>
```

where `<PATH-TO-DEVUNITY-BINARY>` is the path to the downloaded binary of Devunity from https://github.com/Ubuntu-Unity/devunity/releases/.

## Where is the source code of Devunity?
Please check https://github.com/Ubuntu-Unity/devunity/.

repository: Surfndez/devunity-installer

repo_name: Surfndez/devunity-installer


text:
AeonGUI
=======
[![MinGW64 Build status](https://ci.appveyor.com/api/projects/status/g1hx08cchdmkbw3m?svg=true)](https://ci.appveyor.com/project/Kwizatz/aeongui) [![MinGW32 Build status](https://ci.appveyor.com/api/projects/status/yogupd65ow1dr8pq?svg=true)](https://ci.appveyor.com/project/Kwizatz/aeongui-altq2)

Last Updated: 07-31-2019

DESCRIPTION
-----------
Right now AeonGUI is a project to create a graphic user interface library to be used primarily on video games and interactive media.
It's primary goal is to stay agnostic of any advanced/dedicated graphics rendering API such as OpenGL, Vulkan, Direct3D, X11 or GDI.

**WARNING!!!: The library is not currently on a stable or even usable state, and is mostly a sandbox for ideas and POCs.**

HISTORY
-------
The idea for the library was born around 2004 or 2005 under the name 'Glitch', and has evolved overtime but never quite reached maturity.
The name change to AeonGUI came about as a way to identify the library as part of the AeonGames brand
and to avoid confusion since originaly the name 'GLitch' was chosen to emphasize OpenGL support, which is no longer the priority.

On 2013 the goal of the library was to create a widget toolkit similar to Qt or GTK+ to be rendered inside the contexts of different
graphic APIs, but that idea was dropped due to the complexity required and the fact that the target for the library was video games,
not spreadsheets. The library remained mostly dormant while restart development on the [AeonEngine](https://github.com/AeonGames/AeonEngine)
was going on without the need for a GUI.

Somewhere between 2013 and 2018 the idea of the GUI as an HTML agent lingered, it would have been easy to create UIs for anyone
with CSS and HTML experience, no need to learn a new paradigm, but that idea died as well due to the complexity required plus
the actual similarities between HTML documents and video game UIs being very limited.

Right now, in 2019 the idea is to create a SVG agent that implements a subset of the SVG DOM, making UIs easily implemented via SVG files.
**I really hope this is the last iteration of what AeonGUI actually IS**

COMPILATION
-----------
The library uses CMake to build the required files used to build the binary depending on the platform.
For information on how to use CMake refer to the [CMake official site](https://www.cmake.org).
There is only "official" support for Windows(MSYS2 and Visual Studio) and Linux at this time,
however, Linux builds may break from time to time as most development is done on Windows.

Optional USE variables are available to add support for various features such as freetype font rendering and PNG file format loading, these add external dependencies to the library, so they are all initially set to OFF, if turned ON, the user has the option to provide the dependencies or let CMake download and configure the dependencies which will show up as projects inside the build environment.
The rules to download and configure external dependencies are most useful to Windows users as Linux distributions usually provide
development libraries for most software packages.

LICENSE
-------
The library is released under the terms of the permisive [Apache 2.0 license](http://www.apache.org/licenses/LICENSE-2.0)
The Aeon Games logo is __NOT__ covered by the Apache license, it is a Trade Mark and may not be used for any purpose without permision.

AUTHORS
-------
Rodrigo Hernandez (kwizatz at aeongames dot com).

repository: blockspacer/AeonGUI

repo_name: blockspacer/AeonGUI


text:
# PurpleWave
### An extensible AI player for *StarCraft: Brood War*

https://github.com/dgant/PurpleWave

## About
PurpleWave is a *StarCraft: Brood War* AI written in Scala. It can play all races and a large variety of strategies.

PurpleWave has won:
 * 2nd Place in the [2017 AIIDE StarCraft AI Competition](http://www.cs.mun.ca/~dchurchill/starcraftaicomp/2017/)
 * 3rd Place in the [2017 IEEE CIG StarCraft AI Competition](https://cilab.sejong.ac.kr/sc_competition/?p=1090)
 * And has ranked as high as #2 on the [SSCAIT Ladder](https://sscaitournament.com/index.php?action=scores).

PurpleWave vs. Iron, AIIDE 2017:

[![PurpleWave vs. Iron, AIIDE 2017](https://img.youtube.com/vi/g33PIqDdTqs/0.jpg)](https://www.youtube.com/watch?v=g33PIqDdTqs)

## Credits
Thanks to:
* Nathan Roth (Antiga/Iruian) for strategy advice and consulting -- so much of the polish in PurpleWave's strategies comes from his wisdom and replay analysis
* @jaj22/JohnJ for lots of advice navigating Brood War mechanics
* @IMP42 @AdakiteSystems and @tscmoo for helping me get BWAPI up and running when I was getting started
* @kovarex @heinermann @bgweber @certicky @krasi0 @davechurchill and the Cognition & Intelligence Lab at Sejong University for making Brood War competitions possible in the first place
* @vjurenka for BWMirror and Luke Perkins for BWTA

## How to build PurpleWave
What you'll need:
* Windows
* BWMirror 2.5, via https://github.com/vjurenka/BWMirror/blob/master/dist/bwmirror_v2_5.jar
* 32-bit (x86) Java Runtime Environment 8: http://www.oracle.com/technetwork/java/javase/downloads/jre8-downloads-2133155.html
* 32-bit (x86) Java Development Kit 8:http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html
* IntelliJ IDEA Community Edition: https://www.jetbrains.com/idea/download/#section=windows
* (Optional) Git: Git-2.13.2-64-bit.exe
* (Very optional, if you'd like to package PurpleWave as an EXE) Launch4j: http://launch4j.sourceforge.net/

Steps:
* Clone or download this repository (I keep it in c:\prog\pw but it should work from anywhere)
* Put bwmirror_v2_5.jar in /lib
* Make a copy of bwmirror_v2_5.jar called bwmirror_v2_5.zip
* From bwmirror_v2_5.zip, extract bwapi_bridge2_5.dll, libgmp-10.dll, and libmpfr-4.dll to /lib
* Open IntelliJ IDEA
* In IntelliJ IDEA: File -> Settings -> Plugins -> Check off Scala
* In IntelliJ IDEA: File -> Open -> Select the PurpleWave directory
* In IntelliJ IDEA: File -> Project Structure -> Select the Java Development Kit directory (like c:\Program Files\Java\jdk\1.8.0_121)
* In IntelliJ IDEA: Build -> Build Artifacts... -> Build

This will produce PurpleWave.jar. See below for "How to run PurpleWave"

(Optional) If you'd like to run or distribute PurpleWave as a standalone executable, here's how:
* Run Launch4j (see link above for download)
* In Launch4j: Open -> From the PurpleWave directory, launch4j/PurpleWave-launch4j.xml
* In Launch4j: Point the Jar to the Jar you just built.
* In Launch4j: Double-check the Output file and Jar directories
* In Launch4j: Click build. This will producePurpleWave.exe

You should find PurpleWave.exe in a directory with several DLLs which it needs to run:
* BWAPI.dll
* bwapi_bridge2_5.dll
* libgmp-10.dll
* libmpfr-4.dll

## How to run PurpleWave
* From IntelliJ IDEA: Run -> Run 'PurpleWave' or Debug 'PurpleWave'
* As a JAR: java.exe -jar ./out/artifacts/PurpleWave.jar <-- Make sure you use a 32-bit version of java.exe!
* As an EXE: Just double-click it! Make sure if you move the EXE that you move the aforementioned DLLs along with it

## Questions and feedback
Say hi! Post an issue here on Github or email dsgant at gmail

## License
PurpleWave is published under the MIT License.

repository: ml-lab/PurpleWave

repo_name: ml-lab/PurpleWave


text:
# MeteorTodo
Demo Meteor Todo Application

This was built throughout the learning process of the Meteor Javascript framework.
More information can be found at https://www.meteor.com/

## License
Do what you want with it. It is simply a demo application.

repository: tomarrell/MeteorTodo

repo_name: tomarrell/MeteorTodo


text:
WebScraper
===========

# Introduction
Scraping Webpage and get its contents

# Instalation
```
git clone https://github.com/deckyfx/WebScraper.git

cd WebScraper

npm install -d

npm build
```

# Usage
Get this page title
```
./bin/scrap --url https://github.com/deckyfx/WebScraper --xpath '//*[@id="js-repo-pjax-container"]/div[2]/div[1]/div[1]/div[1]/div/span' --property textContent
```

Run with specific config.json
```
./bin/scrap --config {path to your config file}
```

For more usages
```
./bin/scrap --help
```

# Configuration File
Cofiguration file are text file with JSON format with the following structure
```
{
    "name": string,                 // Name of your project, required, all files wil be saved in scraper/cache/{projectname}/
    "tasks": [{
        "name": string | number,    // Name of a Task, optional, the name of the task that will be use as base name
        "load": string,             // URL to load, optional
        "delay": number,            // Optional, delay {delay} milisecond before executing this task
        "use": string               // Optional, use previous task data by name to load the anchor url, you have to set previous task name
        "useRegExp": string,        // Optional, using previous task data by its name that match of regex
        "anchor": string,           // Optional, get anchor href using querySelector from used task
        "anchorXpath": string,      // Optional, get anchor href using xpath from used task
        "anchorLimit": number,      // Optional, when anchor querySelector result is multiple, limit it by {anchorLimit}
        "regexpLimit": number,      // Optional, useRegExp result multiple previous tasks, limit it by {useRegExpLimit}
        "queries": [{
            "query": string,        // Optional, get elements using querySelector
            "xpath": string,        // Optional, get elements using xpath
            "property": string | Array<string> | { [name:string]: string },
                                    // Optional, get property of acquired elements
            "attr": string | Array<string> | { [name:string]: string },
                                    // Optional, get attribute value of acquired elements
            "name": string          // Optional, name of this query task result
            "index": number         // Optional, if queries result returning array, get the {index}th item
            "value": any            // Optional, when this config present, the result will give this value instead of element property,
            "group": Array<ParseConfig>
                                    // Optional, process queries and group it all in one result
        }
        ...
        ]
    }
    ...
    ]
}
```

## Special Parser Config
there are some special value for queries task, that when mentioned, the program will perform special actions instead of regular command

### Text Nodes property
```
    property: "textNodes"
```
when textNodes is asked, then the queries will get all non empty textNode in direct child of resolved elements

please see ```sample/tasks.json``` for sample

# Result
The process will generate result file ```scraper/cache/{project name}/result.json```
with the following format

```
{
    {Task Name}: {
        {Query Task Name}: {Query Task Result},
        ...
    },
    ...
}
```

please see ```sample/result.json``` for sample

# Change Log
 - resolve elements using xpath
 - get attributes of resolved elements
 - obtain textNode
 - group another query tasks as one single result
 - get multiple properties / attributes from resolved elements

# ToDo
 - Implement Exclude Rule
 -- Exclude Use
 -- Exclude Anchor

 - Implement Extendable Caching strategy
 -- Base abstract class of Cache
 -- Memory Cache
 -- File Cache
 -- Redis Cache
 -- MySQLCache
 -- etc

repository: deckyfx/WebScraper

repo_name: deckyfx/WebScraper


text:
# detect-csv
Windows | Mac/Linux
------- | ---------
[![Windows Build status](http://img.shields.io/appveyor/ci/finnp/detect-csv.svg)](https://ci.appveyor.com/project/finnp/detect-csv/branch/master) | [![Build Status](https://travis-ci.org/finnp/detect-csv.svg?branch=master)](https://travis-ci.org/finnp/detect-csv)

Detect if a chunk in the beginning of a CSV (in the sense of character seperated values)
is valid and determine the delimiter character. Install with `npm install detect-csv`.

Right now it only parses the first line and counts characters.
So the rest of the CSV might be invalid. Also I recommend checking for json/ndjson first,
since it's the more strict format.

```js
var detect = require('detect-csv')

var csv = detect('a,b,c\n1,2,3')

console.log(csv.delimiter)
console.log(csv.newline)
// prints ',' and '\n'

var isCsv = detect('notacsv')
console.log('This is ' + (isCsv ? '' : 'not') + ' a csv')
// prints: This is not a csv
```

You add the following options as a second parameter:
* *delimiters* Delimiters to detect, defaults to `[',', ';', '\t', '|']`.
* *newlines* Newline characters to detect, defaults to `['\n', '\r']`.

Delimiters and newlines don't work with multiple characters, e.g. `\r\n`.

repository: dotmindlabs/detect-csv

repo_name: dotmindlabs/detect-csv


text:
# API Testing

For our api tests, we use Postman to make requests and assert the responses.

## Prerequisites

A few services must be running and accessible before the api tests can be run;

- The target `lang/framework` api must be running and accessible on port 8080 (this is the api you want to test).
- The expectations api must be running and accessible on port 3000.

## Running the API Tests

You can choose to run the api tests with docker or directly within Postman itself.

### Postman

This method uses the development environment as opposed to the Api Testing environment. This is because the Api Testing env uses Docker service names which are used to identify containers on the same network.

1. Download and install Postman (download link [here](https://www.postman.com/downloads/)).
2. Import Development environment and collection. These can be located at `postman/Development.api_farm.json` and `postman/API_farm.postman_collection.json` respectively.

![Postman Importing](./img/postman_imports.JPG)

3. Ensure the Development environment is selected within Postman.

![Postman Environment](./img/postman_env.JPG)

4. Check that your workspace includes the Samples & Tests (yours might not look exactly like the image below due to updates made).

![Postman Workspace](./img/postman_workspace.JPG)

5. Highlight the Tests folder and click Run, this will open the Postman Test Runner.

![Postman Test Runner](./img/postman_test_runner.JPG)

6.  Provided services are available and you're using master, you should have results similar to those below;

![Postman Test Results](./img/postman_test_results.JPG)

### Docker

This method is used for the CI pipeline.

1. Download and install Docker (download link [here](https://www.docker.com/products/docker-desktop))
2. From this directory, run the `run.sh` script. It requires the api container name you wish to run the tests against (e.g; `ruby_sinatra` for ruby/sinatra).

```shell
./run.sh ruby_sinatra
```

3. Results from the tests should be output to the console. As well as a final indication as to whether all the tests passed;

![Docker Test Results](./img/docker_test_results.JPG)

Logs are captured from api tests run using Docker. These can be found within the relative directory `./logs`.

repository: LarsFin/API-Farm

gha_language: C#

repo_name: LarsFin/API-Farm


text:
# ask-refugees{code}

A Q&A web app for [refugees{code}](http://www.refugeescode.at/) built with [React Starter Kit](https://reactstarter.com/), using [Node.js](https://nodejs.org/), [Express](http://expressjs.com/), [GraphQL](http://graphql.org/), and
[React](https://facebook.github.io/react/).

See the [React Starter Kit Documentation](https://github.com/kriasoft/react-starter-kit/tree/master/docs) for more technical information.

[Live website](https://ask-refugeescode.herokuapp.com/) on [Heroku](https://www.heroku.com/)

## Prerequesites

You need [Node.js](https://nodejs.org/) and [Yarn](https://yarnpkg.com/en/) installed to run and develop this application locally. A great editor / IDE to write JavaScript (and other) code is [Visual Studio Code](https://code.visualstudio.com/).

## Scripts

* `yarn install`: install dependencies
* `yarn start`: start development server
* `yarn deploy`: deploy to Heroku

## Data

During local development, data is stored in an [SQLite](https://www.sqlite.org/) database `database.sqlite`. You can copy `database.sample.sqlite` to `database.sqlite` to get some initial data.

On the production server, data is stored in a [Heroku Postgres](https://www.heroku.com/postgres) database. The necessary `DATABASE_URL` environment variable is automatically set by Heroku.

To interface with the database (both locally and on production), the Node.js ORM [Sequelize](http://docs.sequelizejs.com/) is used. Data is exposed as a [GraphQL](http://graphql.org/) API, using [React Apollo](https://github.com/apollographql/react-apollo) to fetch data from React components.

Data is only editable when logged in as one of the predefined administrators via Facebook. To make Facebook login work, we set the environment variables `FACEBOOK_APP_ID` and `FACEBOOK_APP_SECRET` in the Heroku app configuration.

## TODO

* Improve design
* Improving editing workflow
* Add more tests
* Make videos answering actual questions

repository: poeschko/ask-refugeescode

repo_name: poeschko/ask-refugeescode


text:
# QML CMake boilerplate
Boilerplate for get quickly start the project with Qt/QML using Cmake.
The project also include Test with Catch and my frequently use lib i.e. spdlog, JSONListModel and SortFilterProxyModel.

## List of Opensource project that use in the application
- JSONListModel: https://github.com/kromain/qml-utils
- SortFilterProxyModel: https://github.com/oKcerG/SortFilterProxyModel
- qml-kickstart for QML live reload: https://github.com/pkoretic/qml-kickstart
- spdlog: https://github.com/gabime/spdlog

repository: eswizardry/Qml-cmake-boilerplate

repo_name: eswizardry/Qml-cmake-boilerplate


text:
# ethkey

An Ethereum wallet consists of a _public address_ and a _private key_.
When using the [Ethereum Wallet / Mist Browser](https://github.com/ethereum/mist/releases)
or when running the [geth](https://geth.ethereum.org/downloads/)
Ethereum node the wallet information is stored in a
<EMAIL_ADDRESS>file.
In this file the private key is encrypted using the wallet's password.

The _ethkey_ tool reads the keystore file and extracts the decrypted private key and the
[checksum encoded](https://github.com/ethereum/EIPs/blob/master/EIPS/eip-55.md) public wallet address.
It is also possible to generate QR code images of the key and the address.

## Installation Requirements
* [python 3.x](https://realpython.com/installing-python) must be installed
* relevant python packes must be installed using `pip install -r requirements.txt`

## Usage
```
python ethkey.py [-h] [--password PASSWORD] [--address_qr ADDRESS_QR] [--private_key_qr PRIVATE_KEY_QR] keystore_file

positional arguments:
  keystore_file                     path to the Ethereum keystore file.

optional arguments:
  -h, --help                        show this help message and exit
  --password PASSWORD               password of the keystore (use with care!).
  --address_qr ADDRESS_QR           QR code image name representing the public wallet address
  --private_key_qr PRIVATE_KEY_QR   QR code image name representing the private key
```
If the password parameter is omitted the user is prompted for the wallet password.
Since commands are typically stored in the shell history this is the more secure and preferred approach.
If the image name parameters are provided, QR code images are generated for the address and the key, respectively.

An example call would look like this:
```
python ethkey.py ~/Library/Ethereum/keystore/UTC--2016-02-29T20-16-53.925667321Z--0af977bb21cf972a538187f72299614121549454 \
  --address_qr=address.png \
  --private_key_qr=key.png
```

repository: yanrising/ethkey

repo_name: yanrising/ethkey


text:
#### Let us play more with commits

So far, we have done something very simple: started tracking a new file, added it to the staging area,
and made your first commit.

Let us simulate the natural evolution of a project.

Let us add a new line to the ``README.md`` file:

```bash
echo "Some additional info" >> README.md
```

and see how git reacts to this change.

---

__Question 1__

Explain the output of ``git status`` after the change.

---

Ok, let us create a new file in the checkout folder:

```bash
echo "print('Hello world')" > hello_world.py
```

Most likely, you would like to view all the changes that you have
introduced in your checkout folder.

Git can list for you at any time the difference between the present content of the checkout folder and the content of
 the commit that you have checked out. Just type

```bash
git diff
```

---

__Question 2__

Explain the output of ``git diff`` after the change.

---

__Tips for the experts__
Let us point out that it is not git that calculates the differences, but git rather extracts the content of the reference commit
and provides it together with the content of the checkout folder to a data comparison tool, ``diff`` by default.

However, this is configurable; for instance you can instruct ``git`` to use ``vimdiff``.

```bash
git config diff.tool vimdiff
```
and try how different the output of `git diff` looks.

Also, if you want to

---

Our goal is now to save a version of the latest changes.

To this aim, we first have to _stage_ the modified file via:

```bash
git add README.md
```

N.B. this time the effect of ``git add`` is only that of adding the changes to the staging area, since `README.md` was already tracked by git.

__Exercise 1__

Let git start tracking the newly created file ``hello_world.py``, verify the addition,
 and check the inclusion in the staging area.
___

---

__Tips for the experts__

This is probably the right time to tell you more about the staging area. Let me remind you that
in git jargon the words `stage`, `cache`, and `index` are used interchangeably.

You might be wondering what the staging area actually is, and the answer is nothing but a special
file ``.git/index``. This file has a complex encoding, so it is not human readable,
 as you will have discovered if you tried to open it.

By default, this content of this file matches that of the commit that is checked out.

However, when you stage some modifications of your work tree through ``git add``,
 these are reflected in ``.git/index``, whose content changes.

Commands like ``git status`` know that changes have been staged by comparing
 the index against the content of the commit that is checked out.

__

Well, enought talking. Let us make a new commit:

```bash
git commit
```

this time without the `-m` to specify a commit message. You will be redirected to a text editor,
and asked to write a commit message and save it.

The editor is `nano`, therefore after having written your message,
type `Ctrl^O, Enter`, to save ther file and `Ctrl^X` to exit.

Once more, you can instruct git to use an editor other than the default one.
Say, you are more familiar with ``vim``, you can set it as the git editor via:

```bash
git config core.editor vim
```

#### A commit is not like a kiss! You remember the second better than the first.

Now that we have a first and a **subsequent** commit, we should have a look at some interesting features of git.

You have seen previously that a commit is basically a set of objects stored under `.git/objects/`

that contain the metadata of the commit, the tree of file, and the content of each committed file (blob objects).

In git, all commits but the first include in their metadata the id of the parent commit.

___

__Exercise 2__

Check what is the parent commit of the last commit, from the content of its commit object.

List all the content stored in the commit.

Hint:

- First, check the id of the last commit
- Second, check the content of the object identified by this id
- Third, similar to exercise 2, browse the content of the commit
___

Now, you might be wondering why git has stored all the tracked files in the second commit,
including those that are unchanged with respect to the first one. Couldn't git just store deltas,
namely incremental differences, with respect to the parent commit?

It turns out that it can. In fact, git has a utility, called `gc` to rationalize and compress
the object storage. `gc` calculates and saves deltas between commits,
 and packs all object owing to a commit in a _packfile_.

Git performs `gc` occasionally, for instance when there are too many non-packed objects (_loose_),

when you push to a remote server (you will learn this later in this course), or if you force the process, running:

```bash
git gc
```

Don't be shy, try it!

Now, have a look at the files contained in ``.git/objects``

```bash
$ find .git/objects -type f
```

It seems like object have gone and two more files appeared under ``pack/`` subfolder, which should look like

```bash
$ find .git/objects/ -type f
.git/objects/pack/pack-32ca4626a2c93a8f2c9a49de9020bfb5096989e9.pack
.git/objects/pack/pack-32ca4626a2c93a8f2c9a49de9020bfb5096989e9.idx
.git/objects/info/packs
$
```

Once more, it is certain that the ids of the pack files will differ.
Surely enough, you are curious to see what is contained in a packfile. There is a plumbing command to list the content
of a pack file:. Use it, for instance,

```bash
git verify-pack -v .git/objects/pack/pack-32ca4626a2c93a8f2c9a49de9020bfb5096989e9.idx
```

The output does not differ whether you point to the `.idx` or to the `.pack` file and should like similar to:

```bash
$ git verify-pack -v .git/objects/pack/pack-32ca4626a2c93a8f2c9a49de9020bfb5096989e9.pack
a8ec68d096fe1abbff9357277291142e7036287c commit 266 177 12
9fdddf978cb46b3dcdc0f82ed616411a99b3ab87 commit 195 126 189
298b04f8007204598d9f335a0507069539089aae blob   91 87 315
f7d178505b318eef258da550b9341aaf1970769a blob   21 31 402
2836704d2b561a3fb838128bd16f5a86be175aa0 tree   79 86 433
f50cd6e249075cd984b5bccaf68f097c474784d2 tree   37 48 519
7c21b9fe6a85e4569236c376dc0003968b6d42a0 blob   4 15 567 1 298b04f8007204598d9f335a0507069539089aae
non delta: 6 objects
chain length = 1: 1 object
.git/objects/pack/pack-32ca4626a2c93a8f2c9a49de9020bfb5096989e9.pack: ok
```

Let us sort out the format of this file. The first two columns are the id of the objects and its types.
You can see that `git` has packed two commits, two tree objects (one for each commit), and three blobs
 (the single file of the first commit, and the two files of the second one).

 The third column is the size in byte of the object once extracted, the fourth the size in the packfile,
  the fifth the positioning within the packfile (ok, nevermind if you haven't grasped it, it is pointless for this purpose).

But the interesting thing is the last line:

1. Look at its size: is is very small (should be less than 10 bytes), definitely smaller than the other blobs.
2. It has an extra field which is the id of another blob object.

---
__Question 3__

Why the last blob is peculiar?

___

---
__Exercise 3__

1. Verify that the last object is a delta with respect to the blob referenced in the last field.
2. Determine whether the second commit is stored as a delta with respect to the first commit or vicevers.

---

repository: agdiiura/katacoda-scenarios

repo_name: agdiiura/katacoda-scenarios


text:
**2048 Assist** is an *artificial intelligence* solver for the popular 2048 game. The algorithm is designed to solve the game as a human would do. The solver solves the problem 99.9% of the time.

The algorithm performs a  Expectimax search on a game tree and assigns appropriate utility score for state.

Expectimax has 2 parts : a)Expectation  b)Maximizer
     - Expectation gives the expected value of current game state
     - Maximizer takes the maximum of all expected values.

The program uses parallelization on supported Windows phone devices.

2048 Assist was designed to be used in windows phone. The actual game is a clone of Gabriel Cirulli's 2048 (https://github.com/gabrielecirulli/2048) with minor variations to included an AI solver. The Solver is implemented in the native layer using C#(solver.cs) as performing a game tree search inside the browser using Javascript turned out to be very slow.

The game can be downloaded at http://www.windowsphone.com/en-us/store/app/2048-assist/dcf7723d-8ad2-46f4-a5ce-7f43d8a72bc7.

![alt tag](https://github.com/antonydeepak/2048-Assist/blob/master/2048-Assist/Assets/Promotional/2048_won.png)


text:
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
[![npm package](https://badge.fury.io/js/aurelia-kis-oidc.svg)](https://www.npmjs.com/package/aurelia-kis-oidc)
[![codecov](https://codecov.io/gh/kisssdev/aurelia-kis-oidc/branch/master/graph/badge.svg)](https://codecov.io/gh/kisssdev/aurelia-kis-oidc)

# aurelia-kis-oidc

An Aurelia plugin inspired by [aurelia-open-id-connect](https://github.com/aurelia-contrib/aurelia-open-id-connect) and based on the library [oidc-client-js](https://github.com/IdentityModel/oidc-client-js) that adapts the OpenID Connect Implicit Client protocol to the Aurelia router in a 'keep it simple' way.

- After a successful login to the OpenID provider, the access token is automatically attached to the http client, so that further calls to an OAuth2 protected web api will be authenticated.

- When a web api call is made, the plugin will check the access token validity. If the token has expired, the plugin will try to sign in the user silently in order to get a new access token.

- If the user has a valid browser session to the OpenID provider, a new access token is retrieved, and the web api is called transparently.

- If the silent login is not possible the user is prompted to login to the OpenID provider.

- After the successful login, the user is redirected to his original page.

## Features

- This plugin registers dynamically two routes (__signin-oidc__ and __signout-oidc__) within your application in order to implement the OpenID Connect Implicit Client protocol.

- It implements an http interceptor that deals with silent login and bearer token.

- It is possible to redirect the application on a specific route based on the presence of a specific claim in the user profile (See the __redirectsOnClaim__ configuration property).

- There is a simulation mode that connect/disconnect the user without interacting with the OpenID provider (See the __simulation__ and __simulationUser__ configuration properties).

## Example

A full example written in typescript is available on the following [github repo](https://www.github.com/kisssdev/aurelia-kis-oidc-sample). The example is also available in live [here](https://aureliakisoidc.z16.web.core.windows.net/). It is using a Microsoft Azure B2C OpenID/OAuth2 provider and you can login using your GitHub, Microsoft or Google account.

## Installation

1. Install the plugin:

   ```node
   npm install aurelia-kis-oidc
   ```

1. Call the plugin:

   ```javascript
   // in your main.js or main.ts
   export function configure(aurelia) {
     aurelia.use
       .standardConfiguration()
       .plugin(PLATFORM.moduleName('aurelia-kis-oidc'), () => configureOpenidPlugin(aurelia))
   ```

1. Define the plugin configuration method:

   ```javascript
   function configureOpenidPlugin(aurelia) {
     return {
       userIdClaimSelector: profile => profile.emails[0],
       reconnectPrompt: loginFunc =>
         iziToast.show({
           title: 'Session expired',
           message: 'Please reconnect',
           buttons: [[`<button>Reconnect</button>`, (instance, toast) => loginFunc(), true]]
         }),
       userManagerSettings: {
         // your oidc-client-js configuration
       }
     }
   }
   ```

1. Connect the router and the httpclient with the plugin:

   ```javascript
   // in your app.js or app.ts
   import { inject } from 'aurelia-framework';
   import { HttpClient } from 'aurelia-fetch-client';
   import { OpenidRouting, Oauth2Interceptor } from 'aurelia-kis-oidc';

   @inject(OpenidRouting, HttpClient, Oauth2Interceptor)
   export class App {

     constructor(openidRouting, client, authInterceptor) {
       this.openidRouting = openidRouting;
       this.configureHttpClient(client, authInterceptor);
     }

     configureRouter(configuration, router) {
       ...
       // required
       configuration.options.pushState = true;
       // add dynamically routes for OpenID Connect
       this.openidRouting.configureRouter(configuration);
       ...
     }

     configureHttpClient(client, authInterceptor) {
       return client.configure(config => {
         config
           .withDefaults({
             headers: {
               'Access-Control-Allow-Credentials': 'true',
               'Accept': 'application/json'
             },
             credentials: 'include',
             mode: 'cors'
           })
           .rejectErrorResponses()
           .withInterceptor(authInterceptor)
       });
     }
   ```

## User interface

This plugin does not come with any user interface element but it provides a [Connection](./doc/src_connection.md) class that encapsulates the OpenID Connect user connection. Just inject the Connection class within your viewmodel and bind your html elements to it.

```javascript
//login.js
import { inject } from 'aurelia-framework';
import { Connection } from 'aurelia-kis-oidc';

@inject(Connection)
export class Login {
  constructor(connection) {
    this.connection = connection;
  }
```

```html
<!-- login.html -->
<template>
  <!-- a login button -->
  <button click.trigger="connection.loginUser()">
    Login
  </button>
  <!-- a conditional lougout link with user name -->
  <a if.bind="connection.isUserLoggedIn" click.trigger="connection.logoutUser()">
    Logout ${connection.userId}
  </a>
</template>
```

You can change the claim that is used to represent the identifier of the user (property userId): see the __userIdClaimSelector__ configuration property.

You can also change the user prompt interface when the session has expired: see the __reconnectPrompt__ configuration property.

## Configuration options

You can define specific options in the configuration returned by the __configureOpenidPlugin__ function.

### `userIdClaimSelector`

Function that defines the profile claim used as user identifier.

_Example:_

 ```javascript
 /**
 * Defines the profile claim used as user identifier.
 * @param {Object} profile - the user profile containing claims
 * @return {string} the user identifier
 */
const userIdClaimSelector = profile => profile.emails[0];
 ```

If you do not define this option, the default claim used is the __name__ claim.

### `reconnectPrompt`

_Function that defines the user prompt to reconnect the session when it is expired._

By default, it displays the native browser prompt.

_Here's an example with the [iziToast](https://github.com/marcelodolza/iziToast) component:_

 ```javascript
/**
 * Implements the reconnect prompt with izitoast component.
 * @param {I18N} i18n -  the translation plugin
 * @return {function} the function called to reconnect the session
 */
const reconnectPrompt = loginFunc => {
  iziToast.show({
    theme: 'dark',
    title: 'Session expired!',
    message: 'Please reconnect...',
    buttons: [[`<button>Reconnect</button>`, (instance, toast) => loginFunc(), true]]
  });
};
```

### `loginRequiredSelector`

To determine that the silent login is not possible the OpenID provider will return an error. The plugin must handle the correct error code in order to show the reconnect prompt. The __loginRequiredSelector__ function defines this code analysis.
The default function is the following (which is what Microsoft Azure B2C authentication currently returns when silent login is no more available):

```javascript
error => error.error === 'interaction_required';
```

You can customize it. For instance this is the function I use for an application authenticated by Azure Active Directory (and it should be the same for Azure B2B authentication):

```javascript
error => error.error === 'login_required';
```

### `redirectsOnClaim`

Sometimes you want to redirect the router to a specific route after the login when a special claim is present.

For instance, with __Azure B2C__ there is a special claim when the user has just created his account.

You can use the __redirectsOnClaim__ function for that.

_Example:_

 ```javascript
 /**
 * Defines the redirect route based on specific profile claims.
 * @param {Object} profile - the user profile containing claims
 * @return {string} the route name or undefined
 */
 const redirectsOnClaim = profile => {
   // redirect newly created users to the settings view
   if (profile?.newUser) return 'settings';
 };
 ```

### `onError`

Sometimes the oicd provider may return an error during the response callback.

You can use the __onError__ callback to retrieve the error.

_Example:_

 ```javascript
 const onError = error => {
   // for instance for errors returned by Azure AD
   console.log(error.error_description);
 };
 ```

### `userManagerSettings`

This object is the exact configuration object of the openid-client-js library.

See [oidc-client-js](https://github.com/IdentityModel/oidc-client-js/wiki) wiki.

The __redirect_uri__ must be:
`https://whatever_your_aurelia_app_url/signin-oidc`

If you specify __post_logout_redirect_uri__ it should be:
`https://whatever_your_aurelia_app_url/signout-oidc`

### `simulation`

This boolean is for __development__ purpose only. It enables to bypass the OpenID provider dialog and to connect virtually the user.

When you call the `loginUser` method of the [Connection](doc/src_connection.md) class the user is automatically connected as the default following user:

```javascript
{
  profile: { name: 'Test User' },
  expired: false,
  access_token: '0123456789'
}
```

You can define your own user object: see the __simulationUser__ configuration property.

When you call `logoutUser` of the [Connection](doc/src_connection.md) class the user is automatically disconnected.

Of course as the access token is fake you won't be able to call a protected web api.

### `simulationUser`

This object enables you to define a custom connected user that should fit your needs.

_Example:_

```javascript
simulationUser: {
      profile: { name: 'J.DOE', emails<EMAIL_ADDRESS>      expired: false,
      access_token: '0123456789'
    },
```

## Project documentation

The project documentation has been generated with jsdoc and the [kis-jsdoc-plugin](https://github.com/kisssdev/kis-jsdoc-plugin).

The [table of content](./doc/toc.md) is here.

repository: kisssdev/aurelia-kis-oidc

repo_name: kisssdev/aurelia-kis-oidc


text:
gradle-ekstazi-plugin
======================

Gradle plugin to run tests with [Ekstazi](http://www.ekstazi.org/index.html) - the lightweight test selection
library.

Ekstazi computes the dependencies of each test and determines which ones need to be run after a code change. So,
rather than running the whole test suite, Ekstazi will only run tests whose behavior may be affected by recent changes.

Usage
-----
Add the following to buildscript:
```groovy
buildscript {
  repositories {
    jcenter()
  }
  dependencies {
    classpath "com.kageiit:ekstazi-gradle-plugin:0.1.0"
  }
}

apply plugin: "com.kageiit.ekstazi"
```

You can configure the plugin with a few options
```groovy
ekstazi {
  version = '4.6.3' // The version of ekstazi to use
  forceFailing = true // Forces re-running failing tests always
  mode = 'junit' // junit is the default. For other modes, see http://www.ekstazi.org/agent.html
}
```

After applying the plugin, the typical workflow would be
- Run tests (runs all tests the first time)
- Make code changes
- Run tests (Ekstazi runs only the tests that are affected by the code changes)
- Repeat

License
-------

```
The MIT License (MIT)

Copyright (c) 2017 Gautam Korlam

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

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

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

repository: kageiit/ekstazi-gradle-plugin

repo_name: kageiit/ekstazi-gradle-plugin


text:
# Animations are included

Note: You have to allow the animations for Android ([see React Native's documentation](https://facebook.github.io/react-native/docs/layoutanimation.html))

```js
UIManager.setLayoutAnimationEnabledExperimental &&
  UIManager.setLayoutAnimationEnabledExperimental(true);
```


text:
# teine
WIP

## Setup
### Prerequisite
* AWS account with access to DynamoDB and S3
* Twitter Consumer Key/Secret
* Twitter Access Token/Secret

### Run
1. `python setup.py`
1. `python runserver.py`

## License
Released under [MIT] (http://opensource.org/licenses/MIT)

repository: hirogwa/teine

repo_name: hirogwa/teine


text:
# Drug Reactions... Explained (DRE) Install Guide

## What is the DRE server and what is included?

The DRE server contains all of the backend components to support the Drug Reactions Explained [DRE] application.

It is comprised of a a single [node.js](https://nodejs.org/) project that uses the [express](http://expressjs.com/) framework.

It is responsible for:

- Acting as a web server for the **DRE Application** front end [angularjs](https://angularjs.org/) application (contained in the `/client` folder)

- Powering the **Reaction Lookup APIs** that provide the application a reaction explanation lookup service

- Hosting the **Reaction Lookup APIs** documentation (powered by [swagger-ui](https://github.com/swagger-api/swagger-ui))

### Prerequisites
* git ([git](https://git-scm.com/))
* node.js ([node.js](https://nodejs.org/))
* MongoDB ([MongoDB](https://www.mongodb.org/))

### You will also need a set of API keys for:
* The [Merriam Webster API](http://www.dictionaryapi.com)
* The [Wordnik API](https://www.wordnik.com/)

# Running the application
1. Clone this repo
2. Change directory to `ads-bpa`

        cd ads-bpa

3. Create configuration files

        # Copy sample config files
        cp client/app/scripts/config-sample.js client/app/scripts/config.js
        cp server/config-sample.js server/config.js

        # Update config files with your hostnames, api keys, and mongo settings
        vim client/app/scripts/config.js
        vim server/config.js

4. Install npm dependencies

        npm install -g bower grunt-cli mocha

5. Change directory to `client` and install npm modules / bower components

        cd client
        npm install
        bower install

   And use grunt to build all dependencies into a single directory.

        grunt build

   > NOTE: The Backend Node.js app serves the Frontend AngularJS app.

6. Change directory to `server` and install npm modules

        cd ../server
        npm install

7. Start mongo and then start the App

        mongod --config /usr/local/etc/mongod.conf # You may need to modify path to mongod.conf
        npm start

8. View App.  Default url is: http://localhost:3000

# Using docker containers

1. Clone this repo
2. Change directory to `ads-bpa`

        cd ads-bpa

3. Create configuration files

        # Copy sample config files
        cp client/app/scripts/config-sample.js client/app/scripts/config.js
        cp server/config-sample.js server/config.js

        # Update config files with your hostnames, api keys, and mongo settings
        vim client/app/scripts/config.js
        vim server/config.js

4. Build a docker image

        # replace [image_name] with the name you want to call the image
        docker build -t [image_name] .

   The above command used the Dockerfile include in the repo.

5. Start the mongo container and then start a container using the image you just built:

        docker pull mongo
        docker run -d --name db mongo

        # replace [image_name] with the name of the image you used in step 4
        docker run -d --name dre -p 3000:3000 --link db:db [image_name]

6. View App.  Default url is: http://localhost:3000

gha_language: CSS


text:
# Entoloma mougeotii var. fuscomarginatum Noordel., 1987 VARIETY

#### Status
ACCEPTED

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

#### Published in
Beih. Nova Hedwigia 91: 237 (1987)

#### Original name
Entoloma mougeotii var. fuscomarginatum Noordel., 1987

### Remarks
null

repository: mdoering/backbone

repo_name: mdoering/backbone


text:
# # GetCorporationsCorporationIdStructures200Ok

## Properties

Name | Type | Description | Notes
------------ | ------------- | ------------- | -------------
**corporation_id** | **int** | ID of the corporation that owns the structure |
**fuel_expires** | **\DateTime** | Date on which the structure will run out of fuel | [optional]
**name** | **string** | The structure name | [optional]
**next_reinforce_apply** | **\DateTime** | The date and time when the structure's newly requested reinforcement times (e.g. next_reinforce_hour and next_reinforce_day) will take effect | [optional]
**next_reinforce_hour** | **int** | The requested change to reinforce_hour that will take effect at the time shown by next_reinforce_apply | [optional]
**profile_id** | **int** | The id of the ACL profile for this citadel |
**reinforce_hour** | **int** | The hour of day that determines the four hour window when the structure will randomly exit its reinforcement periods and become vulnerable to attack against its armor and/or hull. The structure will become vulnerable at a random time that is +/- 2 hours centered on the value of this property | [optional]
**services** | [**\Swagger\Client\Eve\Model\GetCorporationsCorporationIdStructuresService[]**](GetCorporationsCorporationIdStructuresService.md) | Contains a list of service upgrades, and their state | [optional]
**state** | **string** | state string |
**state_timer_end** | **\DateTime** | Date at which the structure will move to it's next state | [optional]
**state_timer_start** | **\DateTime** | Date at which the structure entered it's current state | [optional]
**structure_id** | **int** | The Item ID of the structure |
**system_id** | **int** | The solar system the structure is in |
**type_id** | **int** | The type id of the structure |
**unanchors_at** | **\DateTime** | Date at which the structure will unanchor | [optional]

[[Back to Model list]](../../README.md#models) [[Back to API list]](../../README.md#endpoints) [[Back to README]](../../README.md)

repository: tkhamez/swagger-eve-php

repo_name: tkhamez/swagger-eve-php


text:
# Database Design

A good post on the overall topic: https://medium.com/@kimtnguyen/relational-database-schema-design-overview-70e447ff66f9

## Rules of thumb

* Avoid storing relevant data inside text field. E.g. don't make a "comment" field and then search inside every comment for a particular value.
* Avoid update/delete unles totally necessary, you are "rewriting history" when you do this.
* Use constraints for data integrity.
* Don't use relational tables for non-relational data. E.g. don't store HTML or JSON for your site inside a table.
* Be verbose, don't abbreviate if you don't have to. Should I read `cust_dets` as "customer details" or as "custom detectives"?
* Don't oversimplify. Just because "customers" and "shoppers" are both people, with names and phone numbers, emails and addresses, does not mean their data all belongs in same table.
* Don't overengineer. If you're sure you will only ever store 90% the same data about both "customers" and "shoppers", put them in a "users" or "people" table.
* Document! Be nice not only to your co-developers but to future you.

## Additional Resources

* https://www.vertabelo.com/blog/13-blog-articles-with-database-design-tips-and-best-practices/
* http://joins.spathon.com/

repository: carrot-u/carrot-u-docs

gha_language: Ruby

repo_name: carrot-u/carrot-u-docs


text:
# LaTeX Complete

![recording](recording.gif)

## Developing

After running your first build (below), add the plugin to your Figma desktop client. Open the `Resources` panel (shift-I), then click `Plugins`, select `Development`, click `+`, `Import plugin from manifest`, then select `manifest.json` in this repo.

### Dev build

`npm run build:watch`

### Prod build

**Note: prod build is much faster to load when testing stuff**

`npm run build`

`symbols.json` mapped from https://github.com/vspinu/math-symbol-lists/blob/master/math-symbol-lists.el via https://repl.it/@MaxKrieger/PuzzlingAppropriateMuse

## Roadmap

-   [ ] Adjustable size
-   [ ] Reduce package size via webpack magic

## Related work

https://www.figma.com/c/plugin/754622689958838972 (seems to be broken as of 01/06/2020)

https://github.com/zindlerb/tex-block

repository: maxkrieger/figma-latex-complete-plugin

gha_language: TypeScript

repo_name: maxkrieger/figma-latex-complete-plugin


text:
jenkins-job Cookbook
============
Install jenkins with plugins and users.

Requirements
------------
- cookbook 'jenkins', '~> 2.3.1'

Platform Support
------------
- only tested on ubuntu trusty

repository: kulpree/ops-pipeline

repo_name: kulpree/ops-pipeline


text:
# La7lo7, the first true egyption cryptocurrency 😂

## IMPORTANT CLARIFICATIONS

1. I am doing this project for fun
2. Don't relay on my implementation for any means 😅

## Roadmap

- [x] Basic structure of blocks and transactions.
- [x] Basic proof of work.
- [x] Storing the transactions in the disk.
- [x] Some sort of cli to ease the mining process.
- [ ] Advanved Transactions and user's adresses.
- [ ] Implement a true network.

### Build the app

```
$ go build .
```

### CLI

The cli here is very simple and has only 2 commands

1. Add a new block
    ```
    $ ./la7lo7 addblock -data "Send one la7lo7 to 7oss"
    ```

2. Print the chain
    ```
    $ ./la7lo7 printchain
    ```

### Persestance of the data

I have used a simple key value database implemented with golang [bolt](https://github.com/boltdb/bolt)


text:
spring-boot-maven-angular-starter [![travisci Build Status](https://travis-ci.org/mhoennig/spring-boot-maven-angular-starter.svg?branch=master)](https://travis-ci.org/mhoennig/spring-boot-maven-angular-starter) [![codecov.io Code Coverate](https://codecov.io/gh/mhoennig/spring-boot-maven-angular-starter/branch/master/graph/badge.svg)](https://codecov.io/gh/mhoennig/spring-boot-maven-angular-starter)
-----

This is a multi-module Spring Boot Angular Maven starter app with good defaults.
The frontend Angular app is built using [angular-cli](https://cli.angular.io/). The project packages Angular application code as a [WebJar](https://www.webjars.org/).

This template represents a monolithic application and is mostly meant for small applications or for technology / feasibility exporations.

The original author has also written [a blog that explains step by step how to create this starter project](https://shekhargulati.com/2017/11/08/a-minimalist-guide-to-building-spring-boot-angular-5-applications/).

This project provides productive setup for building Spring Boot Angular applications. The application is divided into two Maven modules:

1. `backend`: This contains Java code of the application using the SpringFramework.
2. `frontend`: This contains source code for the Angular based frontend.

This project uses following versions:

1. Spring Boot v1.5.9
2. Angular v5.0.4
3. Node v8.9.0
4. Yarn v1.3.2

## Running the full application

You can build the package as a single artifact by running the `./mvnw clean install`.
Next, you can run the application by executing:

```bash
$ java -jar backend/target/ngboot-app.jar
```

The application will be accessible at `http://localhost:8080`.

## Features

This starter comes bundled with the following features:

1. Multi module Maven project: A multi module project to modularize backend and frontend code separately.
2. Maven wrapper: So, you don't need to install Maven on your machine.
3. Checkstyle: Enforce sane coding standard guidelines.
4. ErrorProne: Find errors in your code.
5. Frontend packaged as a WebJar.
6. CORS enabled: A global configuration is added to enable CORS so that frontend can work seamlessly with backend during development.
7. REST API base path: Sets the base REST API path to `/api`. You can configure it by changing `rest.api.base.path` property.
8. Maven release plugin
9. CI: The project is preconfigured to use TravisCI as continuous integration server.

## Running the backend for development mode

There are multiple ways to run the backend. For development, you can use your favorite IDE and run the
`com.example.app.Application`. As soon as your code compiles, Spring Boot DevTools will reload the code.

You can also run the application using Maven.

```bash
$ cd backend
$  ../mvnw spring-boot:run
```

## Running the frontend for development mode

Make sure to install [yarn on your development machine](https://yarnpkg.com/en/docs/install).

To install all the required binaries for your project, you can run following command.

```
$ cd frontend
$ ../mvnw frontend:install-node-and-yarn frontend:yarn
```

Once the above command finishes, you can start the frontend using the `yarn start` command.

## Hot reloading

Both the front-end and back-end modules support hot reloading.

## Realtime Collaboration

There is a public Floobits workspace for this project: https://floobits.com/mhoennig/spring-boot-maven-angular-starter/info.\
It allows for remote pair- and mob-programming.


text:
# Teaservideo
Ugly hack to render a teaser video for a podcast episode

## Disclaimer

This is not a tool, but a hack. So there is no settings menu or something like
that. Everything can be changed in the python code. Furthermore there's no
error handling whatsoever (see also "Restrictions").

## Usecase

I am doing podcasts and I wanted to have short teaser videos for my episode to
post them to Facebook, Twitter, Youtube, etc. A bit like Clammr but
different. So I hacked a python script that takes

* a logo image
* a sound clip
* an episode image

and renders out of them an VU-animated video clip.

Examples here: https://www.youtube.com/channel/UCVKivSw1Kr7rhOtPcciEBWg

## Usage

Put your logo image `logo.png`, the audio clip `audioclip.wav` and the episode image
`episodeimage.jpg` into the folder of the script and invoke

`$ ./doit.sh logo.png audioclip.wav episodeimage.jpg videoclip.mp4`

This should result in a video clip file `videoclip.mp4`

## Prequisites

You need to have installed

* python 2.7
  * scipy
  * scikit-image
* ffmpeg

## Restrictions

This is a hack, not a released tool. Some restrictions that I know
spontaneously.

* The video resolution is 1900x1080
* The audio clip format must be `wav`
* It's tested with episode images of 900x900, don't know what happens if yours
  are different.
* There must be no file matching the pattern `frame*.png` in the working
  directory. They will be erased.
* ... probably a lot more

## Support

Good luck!

repository: linux-podcasting-hacks/teaservideo

repo_name: linux-podcasting-hacks/teaservideo


text:
# API

## Purpose and Vision

Redwood believes the future is serverless and multi-client. And `@redwoodjs/api` makes Redwood serverless and multi-client ready. Redwood has one API to rule them all. Your API is abstracted away from any one side of your application, so you can have as many sides as you need, and when you need them.

Right now, the `@redwoodjs/api` package exposes functions that help with logging, services, data fetching via Prisma, webhooks and authentication.

We also plan to make Functions platform-agnostic. At the moment, we're targeting AWS Lambda, but we aim to provide a single interface for other providers and build-time support when you've targeted them.

## Package Lead

[@peterp](https://github.com/peterp/)
[@dthyresson](https://github.com/dthyresson/)
### Logging

RedwoodJS provides an opinionated logger with sensible, practical defaults that grants you visibility into the JAMStack applications you're developing and have deployed  -- with ease.

Logging in the serverless ecosystem is not trivial and neither is its configuration.

When choosing a Node.js logger to add to the framework, RedwoodJS required that it:

* Have a low-overhead, and be fast
* Output helpful, readable information in development
* Be highly configurable to set log levels, time formatting, and more
* Support key redaction to prevent passwords or tokens from leaking out
* Save to a file in local (or other) environments that can write to the file system
* Stream to third-party log and application monitoring services vital to production logging in serverless environments like [logFlare](https://logflare.app/) and [Datadog](https://www.datadoghq.com/)
* Hook into [Prisma logging](https://www.prisma.io/docs/concepts/components/prisma-client/working-with-prismaclient/logging) to give visibility into connection issues, slow queries, and any unexpected errors
* Have a solid Developer experience (DX) to get logging out-of-the-gate quickly
* Use a compact configuration to set how to log (its `options`) and where to log -- file, stdout, or remote transport stream -- (its `destination`)

With those criteria in mind, Redwood includes [pino](https://github.com/pinojs/pino) with its rich [features](https://github.com/pinojs/pino/blob/master/docs/api.md), [ecosystem](https://github.com/pinojs/pino/blob/master/docs/ecosystem.md) and [community](https://github.com/pinojs/pino/blob/master/docs/ecosystem.md#community).

Plus ... pino means 🌲 pine tree! How perfect is that for RedwoodJS?

Note: RedwoodJS logging is setup for its api side only. For browser and web side error reporting or exception handling, these features will be addressed in a future release.

For detailed logger configuration, see the RedwoodJS logger package [README](./src/logger/README.md).

## Contributing

`@redwoodjs/api` uses a few things you should be familiar with:

- [Prisma](https://www.prisma.io)
- [Pino](https://getpino.io)

Although this package depends, in the code-dependency sense, only on `@redwoodjs/internal`, it still hangs together with the others—notably, `@redwoodjs/web` and `@redwoodjs/api-server`. So, if you’re asking yourself “but when does my server run?” head over to `@redwoodjs/api-server`.

If you’re asking yourself “but where is my GraphQL Server” head over to `@redwoodjs/graphql-server`.

repository: redwoodjs/redwood

repo_name: redwoodjs/redwood