text:
# veth

  veth interfaces are virtual ethernet interfaces that always exist in pairs. Whatever enters on one interface, exits from the other one, and viceversa. A simple test to check:

```shell
ip link add type veth
ip link show
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN mode DEFAULT
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP mode DEFAULT qlen 1000
    link/ether 52:54:00:5a:d2:86 brd ff:ff:ff:ff:ff:ff
3: eth1: <BROADCAST,MULTICAST> mtu 1500 qdisc noop state DOWN mode DEFAULT qlen 1000
    link/ether 52:54:00:d7:26:a6 brd ff:ff:ff:ff:ff:ff
23: veth0: <BROADCAST,MULTICAST> mtu 1500 qdisc noop state DOWN mode DEFAULT qlen 1000
    link/ether ee:c0:0e:d6:ae:09 brd ff:ff:ff:ff:ff:ff
24: veth1: <BROADCAST,MULTICAST> mtu 1500 qdisc noop state DOWN mode DEFAULT qlen 1000
    link/ether 4e:e8:84:bd:01:f0 brd ff:ff:ff:ff:ff:ff
ip addr add <IP_ADDRESS>/24 dev veth0
ip link set veth0 up
ip link set veth1 up
#force sending packets out veth0
ping <IP_ADDRESS>
```

While the ping is running, tcpdump on veth1 will show traffic (most likely ARP).

  One thing to note is that for an interface to be up, the other one must be up too.

  The main use for veth interfaces seems to be in the context of container virtualization, especially LXC. Once a veth pair is created, one end is assigned to the container and one end is assigned to the main host. Communication can then happen either using the pair as a point-to-point direct link (assigning IPs to both ends and doing routing on the host) or via bridging (the host-side interface is added to a bridge, perhaps where other interfaces are already connected, and the guest-side interface is assigned an IP inside the container).

  Since containers are possible because of namespaces, this is also the method used to "assign" the guest-side interface to the container. Note that doing so makes the interface deisappear from the host.

Let's try a simple example. First we start a container without network:
```shell
container# ip link
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
```

Then, on the host, we create a pair of veth:
```shell
host# ip link add vHOST type veth peer name vGUEST
host# ip link
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN mode DEFAULT
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP mode DEFAULT qlen 1000
    link/ether 52:54:00:5a:d2:86 brd ff:ff:ff:ff:ff:ff
3: eth1: <BROADCAST,MULTICAST> mtu 1500 qdisc noop state DOWN mode DEFAULT qlen 1000
    link/ether 52:54:00:d7:26:a6 brd ff:ff:ff:ff:ff:ff
25: vGUEST: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP mode DEFAULT qlen 1000
    link/ether be:86:db:5b:ec:a5 brd ff:ff:ff:ff:ff:ff
26: vHOST: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP mode DEFAULT qlen 1000
    link/ether d6:c9:65:e3:bb:e9 brd ff:ff:ff:ff:ff:ff
```
Bring the links up:
```shell
host# ip link set vHOST up
host# ip link set vGUEST up
```
Now we have to find out the PID of the container's main process; there are a few ways to do this, pstree is probably visually easier:
```shell
host# pstree -Apc
...
        |-lxc-start(3615)---init(3619)-+-getty(4236)
        |                              |-getty(4238)
        |                              |-getty(4239)
        |                              |-getty(4240)
        |                              |-login(4237)---bash(4447)
        |                              `-sshd(4223)
...
```
so we want PID 3619, and thus we do
```shell
host# ip link set vGUEST netns 3619
```
Doing this makes the interface disappear from the host:
```shell
host# ip link
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN mode DEFAULT
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP mode DEFAULT qlen 1000
    link/ether 52:54:00:5a:d2:86 brd ff:ff:ff:ff:ff:ff
3: eth1: <BROADCAST,MULTICAST> mtu 1500 qdisc noop state DOWN mode DEFAULT qlen 1000
    link/ether 52:54:00:d7:26:a6 brd ff:ff:ff:ff:ff:ff
26: vHOST: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP mode DEFAULT qlen 1000
    link/ether d6:c9:65:e3:bb:e9 brd ff:ff:ff:ff:ff:ff
```
and appear in the guest container:
```shell
container# ip link
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
25: vGUEST: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP qlen 1000
    link/ether be:86:db:5b:ec:a5 brd ff:ff:ff:ff:ff:ff
```
Now we can configure IPs and we're set:
```shell
host# ip addr add <IP_ADDRESS>/24 dev vHOST
container# ip addr add <IP_ADDRESS>/24 dev vGUEST
container# ping <IP_ADDRESS>
PING <IP_ADDRESS> (<IP_ADDRESS>) 56(84) bytes of data.
64 bytes from <IP_ADDRESS>: icmp_req=1 ttl=64 time=0.103 ms
...
```
As mentioned, another possibility would be adding vHOST to a bridge.


text:
plic
====

Use plic to send a one-time secret message.

Get started
-----------

    shards install
    crystal run src/plic.cr

Open [localhost:8080](http://localhost:8080).

Security
--------

### Client

WebCrypto is used for all cryptographic operations in the browser. Messages are
encrypted using AES-128-GCM and the authentication tag is used as a unique ID.
When using a password, the secret key is derived using PBKDF2-HMAC-SHA256 with
100000 iterations. No external resources (such as scripts, styles and links)
are used. The webpage is loaded in a single request and is less than 250 lines
long which can be easily reviewed.

### Server

Strict security headers (including CSP and HSTS) are set on all requests. No
data is stored other than the encrypted blob, the ID (extracted from the blob)
and the creation time (used to delete unopened messages after 30 days). No logs
are kept on the server.

license: MIT

repository: mohd-akram/plic

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: mohd-akram/plic


text:
vaulted-shell 1
=============

NAME
----

vaulted shell - starts an interactive shell with the secrets for the vault loaded into the shell

SYNOPSIS
--------

`vaulted shell` *name*

DESCRIPTION
-----------

Starts an interactive shell (uses the `SHELL` environment variable, if set;
otherwise defaults to `/bin/sh`).

repository: ryan-norton/vaulted

repo_name: ryan-norton/vaulted


text:
tesslinesplit
=============

This is a standalone program for using Tesseract's line segmentation algorithm to split up document images. The default output filenames are designed to be suitable for feeding into [Ocular](https://github.com/tberg12/ocular).

Requirements:

 * `tesseract`
 * `leptonica`

Requirements are handled in the `Makefile` via `pkg-config`. You may need the `-dev` versions of the `lib` packages for these requirements, depending on your system and package manager.

Usage:

 * `make`
 * `./tesslinesplit imagefile.ext outputdir`

repository: Duum/tesslinesplit

repo_name: Duum/tesslinesplit


text:
---
title: Configure SCM
linktitle: Configure SCM
description: Making your Source Code Manager to work with Jenkins X
weight: 40
menu:
  docs:
    parent: "Install and Setup"
    title: "Configuring SCM"
---

Jenkins X works seamlessly with Source Code Management (SCM) systems through *webhooks*, which allows repository events such as a pull request (PR) to trigger the Jenkins X Pipeline execution.

The default webhook handler for Jenkins X is  [Lighthouse](/docs/reference/components/lighthouse/), which manages webhooks similarly to Prow, but is  designed to support a variety of Git providers.

## Configuring Jenkins X for your SCM

Jenkins X has support for github.com for source code management by default.
To enable support for other providers to work with Jenkins X, configure the `jx-requirements.yml` file according to your preferred SCM provider.

### GitHub Enterprise

[GitHub Enterprise](https://github.com/enterprise) supports the same features as the github.com service but scaled for on-premises deployment on local networks.

To configure support for GitHub Enterprise webhook events in Jenkins X, add `webhook: lighthouse` in the `cluster` section of your `jenkins-x.yml` file. For example:

```sh
cluster:
  provider: gke
  zone: europe-west1-c
  environmentGitOwner: myowner
  gitKind: github
  gitName: ghe
  gitServer: https://my-github.com
webhook: lighthouse
```

In this example, the `cluster` uses Google Kubernetes Engine (GKE) as the provider type and a server `zone` in western Europe. `gitName` is configured as GitHub Enterprise (`ghe`).

### GitLab

[GitLab](https://about.gitlab.com/stages-devops-lifecycle/source-code-management/) features a popular SCM that supports version control, code reviews, and Git-based code branching, changes and merging.

To configure support for GitLab webhook events in Jenkins X, add `webhook: lighthouse` in the `cluster` section of your `jenkins-x.yml` file. For example:

```sh
cluster:
  provider: gke
  environmentGitOwner: myowner
  gitKind: gitlab
  gitName: gitlab
  gitServer: https://my-gitlab-server.com
webhook: lighthouse
```

In this example, the `cluster` uses Google Kubernetes Engine (GKE) as the provider type. `gitKind` and `gitName` is configured as `gitlab`.

repository: sharepointoscar/jx-docs

repo_name: sharepointoscar/jx-docs


text:
# jsonfmt

Like `gofmt`, but for JSON files.

Usage: `jsonfmt` or `jsonfmt -w` to autofix the issues.

## Install

**homebrew**:

```sh
brew install caarlos0/tap/jsonfmt
```

**docker**:

```sh
docker run -v $PWD:/data --workdir /data caarlos0/jsonfmt -h
```

**apt**:

```sh
echo 'deb [trusted=yes] https://repo.caarlos0.dev/apt/ /' | sudo tee /etc/apt/sources.list.d/caarlos0.list
sudo apt update
sudo apt install jsonfmt
```

**yum**:

```sh
echo '[caarlos0]
name=caarlos0
baseurl=https://repo.caarlos0.dev/yum/
enabled=1
gpgcheck=0' | sudo tee /etc/yum.repos.d/caarlos0.repo
sudo yum install jsonfmt
```

**deb/rpm**:

Download the `.deb` or `.rpm` from the [releases page][releases] and
install with `dpkg -i` and `rpm -i` respectively.

**manually**:

Download the pre-compiled binaries from the [releases page][releases] or
clone the repo build from source.

[releases]: https://github.com/caarlos0/jsonfmt/releases

## Stargazers over time

[![Stargazers over time](https://starchart.cc/caarlos0/jsonfmt.svg)](https://starchart.cc/caarlos0/jsonfmt)

gha_language: Go

gha_license_id: MIT


text:
# angular2 calendar
[![Build Status](https://travis-ci.org/mattlewis92/angular2-calendar.svg?branch=master)](https://travis-ci.org/mattlewis92/angular2-calendar)
[![npm version](https://badge.fury.io/js/angular2-calendar.svg)](http://badge.fury.io/js/angular2-calendar)
[![devDependency Status](https://david-dm.org/mattlewis92/angular2-calendar/dev-status.svg)](https://david-dm.org/mattlewis92/angular2-calendar#info=devDependencies)
[![GitHub issues](https://img.shields.io/github/issues/mattlewis92/angular2-calendar.svg)](https://github.com/mattlewis92/angular2-calendar/issues)
[![GitHub stars](https://img.shields.io/github/stars/mattlewis92/angular2-calendar.svg)](https://github.com/mattlewis92/angular2-calendar/stargazers)
[![GitHub license](https://img.shields.io/badge/license-MIT-blue.svg)](https://raw.githubusercontent.com/mattlewis92/angular2-calendar/master/LICENSE)

## Demo
https://mattlewis92.github.io/angular2-calendar/demo/

## Table of contents

- [About](#about)
- [Installation](#installation)
- [Documentation](#documentation)
- [Development](#development)
- [License](#licence)

## About

A calendar component that can display events on a month, week or day view. The successor of: https://github.com/mattlewis92/angular-bootstrap-calendar

## Installation

Install through npm:
```
npm install --save angular2-calendar moment
```

For a full e2e example see the [demo source](https://github.com/mattlewis92/angular2-calendar/blob/master/demo/demo.component.ts). Better docs to follow in the future!

### Usage without a module bundler
```
<script src="node_modules/angular2-calendar/angular2-calendar.js"></script>
<script>
    // everything is exported angular2Calendar namespace
</script>
```

## Documentation
All documentation is auto-generated from the source via typedoc and can be viewed here:
https://mattlewis92.github.io/angular2-calendar/docs/

## Angular 1 version
https://github.com/mattlewis92/angular-bootstrap-calendar

## Development

### Prepare your environment
* Install [Node.js](http://nodejs.org/) and NPM (should come with)
* Install local dev dependencies: `npm install` while current directory is this repo

### Development server
Run `npm start` to start a development server on port 8000 with auto reload + tests.

### Testing
Run `npm test` to run tests once or `npm run test:watch` to continually run tests.

### Release
* Bump the version in package.json (once the module hits 1.0 this will become automatic)
```bash
npm run release
```

## License

MIT

repository: obeza/planning

repo_name: obeza/planning


text:
# React & Redux Project Seed

## Production Notes
* To build and pack (from /src), run: ```npm run build```
  * This will build and webpack into a /build directory in the root of the project, containing the following:
    * js/
      * debug/
        * client_bundle.js
      * client_bundle.js
    * index.html
    * server_bundle.js
  * The /debug directory is used for debugging in production.
    * In production, you can enable debug mode by adding ```?debug_mode=true``` to the end of the URL
      * This will retrieve the client_bundle.js with sourcemaps included
* The /build directory can then be distributed.
* To start the application for production, run: ```PORT=5000 NODE_ENV=production node server_bundle.js```

## Development Notes
* To build and pack for development, you also run: ```npm run build```
  * Individual build commands:
    * ```npm run build-client``` -- Production Client build
    * ```npm run build-client-debug``` -- Dev (Debug) Client build
    * ```npm run build-server``` -- Production Server
  * Note: The above build commands will not enable linting. To run the linter, run:
    * ```npm run lint-client``` or ```npm run lint-client-report``` to generate an HTML report
    * ```npm run lint-server``` or ```npm run lint-server-report``` to generate an HTML report
    * Alternatively, you can run ```npm run lint``` or ```npm run lint-reports``` to run both of the above.
* To start the application for development, run:
  * ```npm run start-dev``` -- Run using node pointing at /build/debug directory
  * ```npm run dev``` -- Run using nodemon pointing at /client for Client source and /build for Server source
* To start the application with live-reload from the /src direcotry, run:
  * ```npm run dev-server```
    * This will run the app at http://localhost:8080
    * This will also enable linting when a file is saved
* To run the unit tests, you can run either of the following:
  * ```npm run test```
  * ```npm run test:watch```
* To run coverage reports, you can run either of the following:
  * ```npm run cover```
  * ```npm run cover:teamcity```

## Technologies & Resources
Below you will find resource links for many of the different technologies used within this project seed. Please refer to the ```package.json``` file to find the specific version of a library being used. We do our best to keep these up to date with the latest release.

#### Frameworks / Libraries / Tools
|Type            | Name                    | Link                                                          |
|:---------------|:------------------------|:-------------------------------------------------------------:|
| Client         | React                   | [Link](https://facebook.github.io/react/)                     |
| Client         | Redux                   | [Link](http://redux.js.org/)                                  |
| UI Design      | Material UI             | [Link](http://www.material-ui.com/#/)                         |
| I18N           | i18n-react              | [Link](https://github.com/alexdrel/i18n-react)                |
| Server         | Express                 | [Link](https://expressjs.com/)                                |
| Build          | Webpack                 | [Link](https://webpack.github.io/)                            |
| Build          | Babel                   | [Link](https://babeljs.io/)                                   |
| Testing        | Mocha                   | [Link](https://mochajs.org/)                                  |
| Testing        | Sinon                   | [Link](http://sinonjs.org/)                                   |
| Testing        | Chai                    | [Link](http://chaijs.com/api/bdd/)                            |
| Testing        | Enzyme                  | [Link](http://airbnb.io/enzyme/index.html)                    |
| Testing        | Supertest               | [Link](https://github.com/visionmedia/supertest)              |
| Testing        | JSDom                   | [Link](https://github.com/tmpvar/jsdom)                       |
| Linting        | ESLint                  | [Link](http://eslint.org/)                                    |
| Linting        | AirBnB ESLint Config    | [Link](https://github.com/airbnb/javascript)                  |

#### Tutorials / Learning Resources
|Type            | Name                    | Link                                                                         |
|:---------------|:------------------------|:----------------------------------------------------------------------------:|
| Client         | Redux Tutorial Videos   | [Link](https://egghead.io/courses/getting-started-with-redux)                |
| Client         | Redux Intro             | [Link](https://www.codementor.io/reactjs/tutorial/intro-to-react-redux-pros) |
| Client         | ES2015 Tutorial         | [Link](https://babeljs.io/docs/learn-es2015/)                                |

repository: cody-lettau/react-redux-starter

repo_name: cody-lettau/react-redux-starter


text:
# API to convert between values
## Endpoints
### /conversions
### /extended-conversions
### /validate/extended-conversions

# expressions usable in extensions send to /extended-conversions

## govaluate documentation
https://github.com/Knetic/govaluate#what-operators-and-types-does-this-support
https://github.com/Knetic/govaluate/blob/master/MANUAL.md

## custom functions

### atoi

- parses string as integer
- signature: func(string)int64
- example: `atoi(x) == 42`

### atof

- parses string as float
- signature: func(string)float64
- example: `atof(x) == 42.13`

### ntoa

- formats number as string
- signature: func(number)string; number may be int, int16, int32, int64, float32, float64
- example: `ntoa(x) == "42"`

### strlen

- returns length of string
- signature: func(string)int
- example: `strlen("42") == 2`

### strIndex

- returns the index of the first instance of substr in s, or -1 if substr is not present in s
- signature: func(s string, substr string)int
- example: `strIndex("4.2", ".") == 1`

### substr

- returns a slice of the string s, from 'from' up to excluding 'to'
- signature: func(s string, from int, to int)string
- example: `substr("0123456789", 2, 4) == "23"`

### trimPrefix

- returns s without the provided leading prefix string. if s doesn't start with prefix, s is returned unchanged.
- signature: func(s string, prefix string)string
- example: `trimPrefix("foo:4.2", "foo:") == "4.2"`

### trimSuffix

- returns s without the provided trailing suffix string. if s doesn't end with suffix, s is returned unchanged.
- signature: func(s string, suffix string)string
- example: `trimSuffix("foo:4.2", ":4.2") == "foo"`

### replace

- returns a copy of the string s with all non-overlapping instances of old replaced by new. if old is empty, it matches at the beginning of the string
- signature: func(s string, old string, new string)string
- example: `replace("foo:4.2", ":", "/") == "foo/4.2"`

### toUpperCase

- returns s with all Unicode letters mapped to their upper case.
- signature: func(s string)string
- example: `toUpperCase("fooBAR") == "FOOBAR"`

### toLowerCase

- returns s with all Unicode letters mapped to their lower case.
- signature: func(s string)string
- example: `toLowerCase("fooBAR") == "foobar"`

### mapGet

- returns element of a map
- signature: func(m map[string]interface{}, key string)map[string]interface
- example: `mapGet(x, "foo")`

### mapSet

- sets element of a map and returns the new map
- signature: func(m map[string]interface{}, key string, value interface{})map[string]interface
- example: `mapSet(x, "bar", 42)`

### mapGet

- removes element of a map
- signature: func(m map[string]interface{}, key string)map[string]interface
- example: `mapDelete(x, "bar")`

# default conversions
to get a graph of possible conversions, call
```
go generate ./...
```
which prints a dot graph. you can use https://dreampuf.github.io/GraphvizOnline to generate images from the output.

![conversion graph](./graphviz.svg)

# known dependent repositories

- https://github.com/SENERGY-Platform/marshaller
- https://github.com/SENERGY-Platform/external-task-worker
- https://github.com/SENERGY-Platform/mgw-external-task-worker
- https://github.com/SENERGY-Platform/device-command

repository: SENERGY-Platform/converter

repo_name: SENERGY-Platform/converter


text:
BRIGHT SPOTS
-----------

# FIGURES

## FIGURE 3 - decision rules

#### Fig 3A
Expert examples - response to the question:
Have you encountered instances of notable resilience?
Filtering steps
 1. 97 respondents to start
 2. Remove non-climate disturbances; 71 remaining

#### Fig 3B
Literature examples
 1. Start with 131 suggested papers - called 'litOrig' (131 rows).
 2. Removed 1 paper that could not be found (130)
 3. Removed 43 papers that were not relevant to the resilience question (87)
 4. Removed 0 papers that were on restoration (87)
 This dataset is called 'litFull'
 5. Including only habitat forming species and whole community (70)
 6. Including only climatic disturbances (55) - called 'litSub'

## FIGURE 4 - decision rules
Fig 4A, B, C - promoting resilience; D, E - preventing resilience

#### Fig 4A
What factors promote resilience? Used respondents in survey that did
observe at least one instance of resilience.

Filtering steps
 1. 97 respondents to start
 2. Remove non-climate disturbances; 71 remaining
 3. Some respondents gave more than one factor promoting resilience;
 each of these were counted separately.
 4. Collating both factors into one column resulted in a dataframe with
 73 rows (some respondents gave no factors promoting resilience)

#### Fig 4B
Expert opinions.
Calculated percentage of 'very important' responses for resistance and recovery separately.
Used Jen's summary.

#### Fig 4C
Literature examples
Follow decision rules for Fig 3B, start with litSub (55)
 1. Remove papers without evidence of resilience (46)
 2. Remove one paper without a factor promoting resilience (45)
 3. Some papers gave more than one factor promoting resilience;
 each of these were counted separately.
 4. Collating both factors into one column (67)

#### Fig 4D
Expert opinions.
Used all data.

#### Fig 4E
Literature examples - resume after step 2 from Fig 4C (46)
 1. Collated both factors preventing resilience into one column (49)


text:
# Soup-Salad-Sandwich
Revature: Project 2

## Project Description

This is an app design for the user base to debate on whether or not a food is under the catagorization of 'soup', 'salad', or 'sandwich'.

A user can introduce a new food, and if the food is not in the database, then it must go through admin approval.

After approval, it is introduced to the 'Chopping Block', during which users will debate on what category it falls under, and voting for it.

The food's category dynamically changes, based on which category gets the most votes, and has a forum associated with each food/dish in which users
debate and reason on their choice.

The app has a 'The Menu' section of exisiting dishes that was introduced again.

## Technologies Used

* Postgresql
* SpringBoot
* Hibernate
* HTML
* CSS
* Bootstrap
* JavaScript/TypeScript
* Angular
* Apache tomcat

## Features

- Users can log in
- Admin approval of food submission
- Two main sections of the application
	- Chopping Block
		- New Dishes
		- Hot Topic
	- The Menu
		- Three catagory to orgaize existing dishes

## Getting Started

>$ git clone https://github.com/Hyuria/Soup-Salad-Sandwich

>$ git clone https://github.com/Hyuria/Soup-Salad-Sandwich-Frontend

Backend applications run on an Apache Tomcat Server. You would need to create a PostgreSQL server on AWS RDS or locally, and change the Soup-Salad-Sandwich/src/main/resources/hibernate.cfg.xml file accordingly. To run the frontend, you will need to install Angular 4, alongside npm.

- Frontend Repository: https://github.com/Hyuria/Soup-Salad-Sandwich-Frontend

## Database Structure

- Category (category_id, String(Soup, Salad, Sandwich, Undecided))

- Status(status_id, String(New Dish, Hot Topic, Classic) )

- User (user_id, username, password, role)

- Role (role_id, String(role))

- Comment(forum_id, Dish ID, User ID, date, like count, message)

- Dish(dish_id, Dish name, Category, photo_url)

- Vote(vote_id, dish_id, user_id, category_id) (unique constraint on dish_id, user_id)

- Like(like_id, forum_id, user_id, like_or_dislike)

## Usage

Start the frontend server using the command:
> npm install

> ng serve

Start the backend in your IDE of choice, IntelliJ and Eclipse were used during development. Make sure to start it but using Apache Tomcat.

## Contributors

Contributors: Henry Chen, Jakeem, Ben Hsieh, Brodie Hufnagel

## License

This project uses the following license: [<APACHE LICENSE, VERSION 2.0>](<https://www.apache.org/licenses/LICENSE-2.0>).

repository: Hyuria/Soup-Salad-Sandwich

branch_name: refs/heads/main

repo_name: Hyuria/Soup-Salad-Sandwich


text:
This folder contains everything that's required to build
ECS' docker images and push those images
to [DockerHub](https://hub.docker.com). docker images published
to DockerHub are required before provisioning an ECS cluster.

ECS has 3 docker images:

* [ecs-apidocs](apidocs)
* [ecs-services](services)
* [ecs-nginx](nginx)

# Building Images

Instructions for building all ECS containers are below. First
```git clone``` the ECS repo.

```bash
>cd
>git clone git clone https://github.com/simonsdave/ecs.git
```

Configure the development environment.

```bash
>cd ecs
>source cfg4dev
```

Build the API docs.

```bash
>cd api_docs
>./build-api-docs.sh -t
>ls -l api_docs.tar
-rw-rw-r-- 1 vagrant vagrant 133120 Mar 14 19:50 api_docs.tar
>
```

Build services package.

```bash
>cd ..
>python setup.py sdist --formats=gztar
>
```

Build local copies of all docker images.

```bash
>cd dockerfiles
>build-docker-images.sh \
  -v \
  ../dist/ecs-0.8.0.tar.gz \
  ../api_docs/api_docs.tar \
  simonsdave
>
```

repository: simonsdave/ecs

gha_language: Python

repo_name: simonsdave/ecs


text:
# Hiccdown

Hiccdown is a very simple gem that parses Ruby arrays and turns them into HTML strings.

The name is a variation on the popular Clojure package [Hiccup](https://github.com/weavejester/hiccup). Hiccdown introduces the same (?) functionality in Ruby.

## Usage

```ruby
# plain
Hiccdown::to_html [:h1, 'hello world']
# => '<h1>hello world</h1>'

# nested siblings
Hiccdown::to_html [:div, [:h1, 'hello world'], [:h2, 'hello again']]
# => '<div><h1>hello world</h1><h2>hello again</h2></div>'

# attributes
Hiccdown::to_html [:h1, {class: 'heading big'}, 'hello world']
# => '<h1 class="heading big">hello world</h1>'

# children as arrays
Hiccdown::to_html [:ul, [[:li, 'first'], [:li, 'second']]]
# => '<ul><li>first</li><li>second</li></ul>'
#
# This is equivalent to writing:
Hiccdown::to_html [:ul, [:li, 'first'], [:li, 'second']]
# So why use it? So you can use methods that return arrays inside your hiccdown structure without having to use the splat operator every time:
Hiccdown::to_html [:ul, ['first', 'second'].map { |i| [:li, i] }]
# => '<ul><li>first</li><li>second</li></ul>'
```

## Usage within Rails

Delete your view file. In your controller action, do:

```ruby
class FooController < ApplicationController
  def bar
    render html: Hiccdown::to_html([:h1, 'hello world!']).html_safe
  end
end
```

(Be careful with `html_safe`.)

## Why?

If you're used to writing embedded Ruby (those pesky `.erb` files), you may not realize how bad it is.

Consider this template:

```erb
<ul>
  <% [1, 2, 3].each do |i| %>
    <li><%= i %></li>
  <% end %>
</ul>
```

This is *gross*. Embedded Ruby makes you mix your template and your logic. Rails is big on *separation of concerns*, and the above example is the opposite of that. It's "programming in strings", as a former colleague would call it. This problem is well known in the Clojure world. Logic should be taken care of *before* rendering, not *during*.

Hiccdown makes this happen by taking a datastructure representing your template – which you're free to build up logically in any way you like, using the full power of the Ruby programming language (`map`, `filter`, `reduce` etc) – and then turning that into HTML *at the end*. All of this still happens on the server, so you still get all the benefits of pre-processing.

## License

MIT

repository: dchacke/hiccdown

repo_name: dchacke/hiccdown


text:
# trailz

> A library for generating mazes

[![build](https://circleci.com/gh/jmquigley/trailz/tree/master.svg?style=shield)](https://circleci.com/gh/jmquigley/trailz/tree/master)
[![tslint code style](https://img.shields.io/badge/code_style-TSlint-5ed9c7.svg)](https://palantir.github.io/tslint/)
[![Test Runner](https://img.shields.io/badge/testing-ava-blue.svg)](https://github.com/avajs/ava)
[![NPM](https://img.shields.io/npm/v/trailz.svg)](https://www.npmjs.com/package/trailz)
[![Coverage Status](https://coveralls.io/repos/github/jmquigley/trailz/badge.svg?branch=master)](https://coveralls.io/github/jmquigley/trailz?branch=master)

This library is based on the algorithms from the book [Mazes for Programmers: Code Your Own Twisty Little Passages](https://www.amazon.com/Mazes-Programmers-Twisty-Little-Passages/dp/1680500554/ref=sr_1_1?ie=UTF8&qid=1503783819&sr=8-1&keywords=Mazes+for+programmers), by Jamis Buck

## Requirements

- [Node](https://nodejs.org/en/) v7.5+
- [Yarn](https://yarnpkg.com) v0.28.4

## Installation

This module uses [yarn](https://yarnpkg.com/en/) to manage dependencies and run scripts for development.

To install as an application dependency:
```
$ yarn add trailz
```

To install as a global dependency for CLI use (options below):
```
$ yarn global add trailz
```

To build the app and run all tests:
```
$ yarn run all
```

## Overview

To use the library create an instance of the `Maze` class with the size requirements and algorithm type.  It will automatically generate the maze and save it within a grid.  The contents of the maze can be retrieved by using the `.string` or `.repr` properties to get the contents.  The `.string` will give an ASCII string representation of the maze.  The `.repr` method will return a two dimensional array that contains the representation of that cell.  This representation is 1 of 16 possible representations for a cell (for drawing purposes).

```
+---+---+---+---+---+---+---+---+---+---+
|                                       |
+---+   +   +   +   +   +   +---+---+   +
|       |   |   |   |   |   |           |
+---+---+   +   +   +---+---+---+---+   +
|           |   |   |                   |
+   +---+---+   +---+   +---+   +---+   +
|   |           |       |       |       |
+---+---+---+---+   +   +   +   +---+   +
|                   |   |   |   |       |
+---+   +   +   +---+---+   +   +   +   +
|       |   |   |           |   |   |   |
+---+---+   +   +   +   +---+---+---+   +
|           |   |   |   |               |
+   +---+   +   +---+   +---+   +---+   +
|   |       |   |       |       |       |
+   +   +---+---+   +---+   +---+---+   +
|   |   |           |       |           |
+   +   +   +---+   +---+---+   +   +   +
|   |   |   |       |           |   |   |
+---+---+---+---+---+---+---+---+---+---+

 11,  8,  8,  8,  8,  8,  8, 10, 10, 12
 11,  6,  5,  5,  5,  7,  7, 11, 10,  4
  9, 10,  6,  5,  7,  9, 10,  8, 10,  4
  7, 11, 10,  6,  9,  4,  9,  4, 11,  4
 11,  8,  8,  8,  6,  7,  5,  5,  9,  4
 11,  6,  5,  5,  9,  8,  6,  7,  7,  5
  9, 10,  4,  5,  7,  5, 11,  8, 10,  4
  5,  9,  6,  7,  9,  6,  9,  6, 11,  4
  5,  5,  9, 10,  4, 11,  6,  9,  8,  4
  7,  7,  7, 11,  6, 11, 10,  6,  7,  7
```

![SREPR Values](srepr-values.png)

### Usage

```javascript
import {AlgorithmType, Maze} from 'trailz';

const maze = new Maze(10, 10, AlgorithmType.BinaryTree);
console.log(maze.string);
```

This will create a new instance of a maze using the BinaryTree algorithm.  A new instance of the maze can be rebuilt without creating a new instance with:

```javascript
maze.rebuild(AlgorithmType.BinaryTree);
```

This will reset the grid and reapply the BinaryTree algorithm to the grid.  The grid can be resized and rebuilt too.

```javascript
maze.resize(5, 5)
```

This will resize the grid to a 5x5 maze and reapply the algorithm.

### CLI

The command line interface allows one to create mazes and print their contents to a text file.

```
$ trailz -r 25 -c 25 -a Sidewinder --verbose -o maze.txt
```

This will create a 25x25 maze using the [Sidewinder](docs/lib/sidewinder.md) algorithm.  The contents will be printed to the terminal and also written to a file named `maze.txt` (the default).

##### Arguments

- `-r|--rows {#}` - the number of rows to create in the maze.  The default is 10.
- `-c|--cols {#}` - the number of columns to create in the maze.  The default is 10.
- `-a|--algorithm {name}` - the string name of the algorithm to use when generating the maze (see the list below).  The current default is the `BinaryTree` algorithm.
- `-v|--verbose` - will dump the contents of the generated maze to stdout.  Not shown by default.
- `-o|--output {filename}` - where to dump the contents of the maze (text file).  The file `maze.txt` is used by default and will be overwritten on successive runs.

## API

- [Cell](docs/lib/cell.md)
- [Grid](docs/lib/grid.md)
- [Maze](docs/lib/maze.md)
- [Algorithm](docs/lib/algorithm.md)

## Algorithms

- [AldousBroder](docs/lib/aldousbroder.md)
- [BinaryTree](docs/lib/binarytree.md)
- [HuntAndKill](docs/lib/huntandkill.md)
- [RecursiveBacktracker](docs/lib/recursivebacktracker.md)
- [Sidewinder](docs/lib/sidewinder.md)
- [Wilsons](docs/lib/wilsons.md)

repository: jmquigley/trailz

gha_language: TypeScript

repo_name: jmquigley/trailz


text:
# Skillets

A skillet is just a collection of templates with a bit of meta-data that goes along with them. Meta-data can include things like a
name for the collection, a type that describes how the templates can be consumed, a description, optional labels, etc.

What's up with the [name 'Skillets' anyway?](https://live.paloaltonetworks.com/t5/Skillets-Blogs/The-Palo-Alto-Networks-Skillet-Story/ba-p/308056)

## Skillet types

Although most skillets consist of loadable PAN-OS configurations, Panhandler can also load additional types
of Skillets including:

* PAN-OS
* Terraform
* Python
* REST
* Docker
* Template

For more information, see the Panhandler [documentation](https://panhandler.readthedocs.io).

## More information

The [Live Community](https://live.paloaltonetworks.com/t5/Skillet-District/ct-p/Skillets)
 is the central place for all things [Skillets](https://live.paloaltonetworks.com/t5/Skillets-Blogs/The-Palo-Alto-Networks-Skillet-Story/ba-p/308056).

## How to use Skillets

There are several applications that can deploy Skillets:

* [Panhandler](https://panhandler.readthedocs.io)

* [Skilletlib](https://github.com/paloaltonetworks/skilletlib)

* [SkilletCLI](https://github.com/adambaumeister/skilletcli)

## Skillet Metadata syntax

See the [Panhandler documentation](https://panhandler.readthedocs.io/en/develop/skillets.html) for a the meta-cnc syntax.

## Disclaimer and Support Policy

This template/solution is released under an as-is, best effort, support policy. These scripts should be seen as community
supported and Palo Alto Networks will contribute our expertise as and when possible. We do not provide technical support or
help in using or troubleshooting the components of the project through our normal support options such as Palo Alto Networks
support teams, or ASC (Authorized Support Centers) partners and backline support options. The underlying product used (the VM-
Series firewall) by the scripts or templates are still supported, but the support is only for the product functionality and
not for help in deploying or using the template or script itself. Unless explicitly tagged, all projects or work posted in our
GitHub repository (at https://github.com/PaloAltoNetworks) or sites other than our official Downloads page on
https://support.paloaltonetworks.com are provided under the best effort policy.

repository: nembery/Skillets

repo_name: nembery/Skillets


text:
# CellTreeEditDistance

## Information

This code is the implementation of Tree Edit Distance in neurons. It computes the distance between two or more neurons represented in swc format file. It uses the APTED Algorithm [2] and was first introduced from Heumann and Wittum [1].

## Usage

The code is intended to be used as a plugin in VRL-Studio. Therefore you need to have [VRL-Studio](https://vrl-studio.mihosoft.eu/) installed and follow these [instructions](https://vrl-studio.mihosoft.eu/documentation.html).

Another way to use it is in every IDE. Simply open the Main Class and run the following command with the label of your choice:

```
CellTreeEditDistance matrix=new CellTreeEditDistance();
matrix.compareFiles(11);
```
To see the labels call the static function *showLabels()*
````
CellTreeEditDistance.showLabels();
````

## Input

Multiple swc files or a folder. Supported are only files in swc format. Any digital representation of neuron in other format will not be recognized as input.

## Output

The Output is a distance Matrix printed in a table and can be exported to a txt file. The txt file can be used for custer analysis. It is a *n x (n+1)* matrix for *n* files given as input where each entry is divided by a semikolon and the first row contains the names of the selected files. To analyse the distance matrix with the hierarchical clustering method in RStudio do the following:
```
clusterfile <- read.csv2("YOUR_PATH_OF_THE_DISTANCE_MATRIX/EXPORTFILE.txt", header=FALSE, row.names=1)
View(clusterfile)
d=as.dist(clusterfile)
hcs <- hclust(d, method="ward.D")
plot(hcs)
rect.hclust(hcs, k = 2, border = "red")
````
## License

This code is published under the BSD 2-Clause terms. For more details see the licence file found in the root directory of the project.

## Reference

 [1] H. Heumann and G. Wittum. The Tree Edit Distance, a Measure for Quantifying Neuronal Morphology. Neuroinform 2009.

 [2] M. Pawlik and N. Augsten. Tree edit distance: Robust and memory- efficient. Information Systems 56. 2016.

gha_language: Java


text:
# reaction

Sometimes you need to react to changes to state. Typically you want to run some imperative logic related to something in the state changing.

```js
reaction(
  // Access and return some state to react to
  (state) => state.foo,

  // Do something with the returned value
  (foo) => {},

  {
    // If you return an object or array from the state you can set this to true.
    // The reaction will run when any nested changes occur as well
    nested: false,

    // Runs the reaction immediately
    immediate: false
  }
)
```

There are two points of setting up reactions in Overmind.

## onInitialize

The onInitialize hook is where you set up reactions that lives throughout your application lifetime. The reaction function returns a function to dispose it. That means you can give effects the possibility to create and dispose of reactions in any action.

```marksy
h(Example, { name: "api/reaction_oninitialize" })
```

## components

With components you typically use reactions to manipulate DOM elements or other UI related imperative libraries.

```marksy
h(Example, { name: "api/reaction_components" })
```

repository: hipertracker/overmind

repo_name: hipertracker/overmind


text:
# core

The [core][core] library abstracts the UI without invoking into any platform.

We don't need to know how it works if you just want to develop Apps using
ElvisJS, because the [elvis][elvis] library provides all we need in the
core library.

## Node

The common UI of ElvisJS are composed with nodes which are defined in this core
library, just the frame and transform stuffs.

## UI

### Attribute && Class

Attribute and Class are defined in this library as well, both of them are served for
the `Node`, attribute controls the features of Node, and the class affect on the style
of Node.

### Values

All static values are defined in this library, for example, `Color`, `Unit`.

### Layout

Finally, we are reaching the layout part. The difference of ElvisJS and other UI library
in rust/wasm is ElvisJS provides UI itself, not just give you guys a parser parsing rust
to Javascript or html.

The layout part is only defined in the core library, for example, the [web][web] library
is just a re-export of the layout part of this core library, migrating the ElvisJS UI
into browser.

## Lifecycle

The lifecycle of ElvisJS defines like

| LifeCycle | Description                                         |
|-----------|-----------------------------------------------------|
| Create    | Triggers while creating the component in node tree  |
| Render    | Triggers while rendering the component in node tree |
| Update    | Triggers when the state machine changes             |
| Drop      | Triggers while droping the component                |

## State machine

State machine of Elvisjs equipped for user-defined components, the fields of the struct
are the storage of the state machine, which we can modify in gestures.

[web]: https://github.com/elvisjs/elvis/tree/master/crates/web
[core]: https://github.com/elvisjs/elvis/tree/master/crates/core
[elvis]: https://github.com/elvisjs/elvis

repository: songlinshu/elvis

repo_name: songlinshu/elvis


text:
---
name: Release checklist
about: '[for maintainer use]'
title: 'Release gsd 3.X.Y'
labels: ''
assignees: 'joaander'

---

Release checklist:

- [ ] Run *bumpversion*.
- [ ] Review the change log.
- [ ] Check for new or duplicate contributors since the last release:
  `comm -13 <(git log LAST_TAG --format="%aN <%aE>" | sort | uniq) <(git log --format="%aN <%aE>" | sort | uniq)`.
  Add entries to `.mailmap` to remove duplicates.
- [ ] Check readthedocs build, especially change log formatting.
  - [Build status](https://readthedocs.org/projects/gsd/builds/)
  - [Output](https://gsd.readthedocs.io/en/latest/)
- [ ] Tag and push.
- [ ] Update conda-forge recipe.
- [ ] Update glotzerlab-software.

repository: glotzerlab/gsd

branch_name: refs/heads/trunk-patch

repo_name: glotzerlab/gsd


text:
# Kuberty
<img src="https://github.com/kuberty/kuberty/raw/master/logos/logo.png" width="100">

Kubernetes native testing framework for microservices. Write your tests in any language, declare your service dependencies and Kuberty will build a test cluster and test your service for you.

## Documentation
To learn more about Kuberty go to [our documentation](https://wiki.tcbv.be/en/ict/kubernetes/kuberty).

## Installation
**Install the Kuberty cli locally:**

```bash
wget https://github.com/kuberty/kuberty/releases/...  && chmod +x kuberty  && mv kuberty /bin/bash/kuberty
```

Installation instructions for [Windows](/docs/installation/windows), [Mac](/docs/installation/mac) and [Docker](/docs/installation/docker).

**Install Kuberty on your cluster:**
```bash
kubectl apply -f https://raw.githubusercontent.com/kuberty/kuberty/master/deploy/install-kuberty.yaml
```

### Custom Resource Definitions
**Applications** specifies your application and it's dependencies

```yaml
apiVersion: kuberty.io/v1
kind: Application
metadata:
  name: auth-service-test-deployment-{{ .Values.test_id }}
  namespace: kuberty
  labels:
    app: auth-service
spec:
  app:
    chart: 3000 bytes
    path: helm
  database:
    type: redis
    service:
      name: redis
      namespace: auth-service
  dependencies:
  - app: count-service
    repository: https://github.com/kuberty/example-count-service.git
    revision: v0.0.1
    path: helm
```
**Files** define the artifacts for your tests
```yaml
apiVersion: kuberty.io/v1
kind: File
metadata:
  name: auth-service-tests-file-{{ .Values.file_digest }}
  namespace: Kuberty
spec:
  type: http
  url: https://raw.githubusercontent.com/kuberty/auth-/prometheus/release-2.16/documentation/examples/prometheus.yml
  digest: sha256:4377ad582f1aa7002791e0643f9b2e260b8b015e002d6dc915bf3e4b10927f9e
```
**Tests** define the tests you wish to run

```yaml
apiVersion: kuberty.io/v1
kind: Test
metadata:
  name: auth-service-test-{{ .Values.test_id }}
  namespace: kuberty
  labels:
    test_id: {{ .Values.test_id }}
spec:
  source:
    file: auth-service-tests-file-{{ .Values.file_digest }}
    revision: {{ .Values.revision }}
    path: tests
  tests:
  - name: setup
    file: setup.py
    children:
    - name: get-test
      file: get-test.py
    - name: add-test
      file: add-test.py
      children:
      - name: get-after-add-test
        file: get-after-add-test.py
    - name: subtract-test
      file: subtract-test.py
      children:
      - name: get-after-subtract-test
        file: get-after-subtract-test.py
```

## Interesting projects:
| Project | Relevance | Stars |
| -- | -- | -- |
| [kubernetes/kube-infra kubetest](https://github.com/kubernetes/test-infra/blob/master/kubetest/README.md) | Kube-test is the way Kubernetes spins up k8s clusters in their e2e testing framework, this has Google Cloud as the only provider for the cluster, which is an issue if we want to test locally. It could be used as one of the bootstrapping frameworks though. | 1.9k
| [srossross/k8s-test-controller](https://srossross.github.io/k8s-test-controller/) | Very simple jobs you can run in a bootstrapped cluster to test functionality. | 17 |
| [kubernetes-sigs/controller-runtime/pkg/envtest](https://godoc.org/github.com/kubernetes-sigs/controller-runtime/pkg/envtest) | The recommended way to setup environments to integration test your controllers | 499 |

## Interesting articles:
| Article | Relevance |
| ------- | --------- |
| [Kubernetes article on using the e2e framework](https://kubernetes.io/blog/2019/03/22/kubernetes-end-to-end-testing-for-everyone/) |

repository: kuberty/kuberty

repo_name: kuberty/kuberty


text:
# @generilla/core

This is the core package of `Generilla`. [See the full README here.](https://github.com/gannochenko/generilla)

repository: gannochenko/generilla

repo_name: gannochenko/generilla


text:
# The-Little_Foot-Keyboard-rev2.3-PCB Gerbers

![Little_Foot](https://i.imgur.com/GC1st7U.png)
===

**PCB Dimensions:** `190.5mm x 95.3mm`
===

## Required Parts for PCB & PCB Assembly:

+ **x40-44** - 1N4148 Diodes (PCB Supports both/either SMD and THT Diodes)

   - LCSC SMD Diodes: [C2099](https://lcsc.com/product-detail/Switching-Diode_Changjiang-Electronics-Tech-CJ-1N4148W_C2099.html)

   OR*

   - LCSC Through-Hole Diodes: [C14516](https://lcsc.com/product-detail/Switching-Diode_1N4148_C14516.html)

.

.

.

+ **x1** - SMD Flat Tactile Switch (Reset)

   - LCSC Reset Switch: [C92584](https://lcsc.com/product-detail/Tactile-Switches_Korean-Hroparts-Elec-K2-1187SQ-A4SW-06_C92584.html)

   OR*

   - Reset Switch [MSLPT5252AG2TR](https://www.mouser.com/ProductDetail/506-MSLPT5252AG2TR)

.

.

.

+ **x1** - Elite-C (USB_C) or Pro-Micro Variant (Micro_USB)

   - Pro Micro [Clone from Amazon](https://www.amazon.com/KeeYees-ATmega32U4-Development-Microcontroller-Bootloader/dp/B07FXCTVQP/ref=sr_1_3?dchild=1&keywords=pro+micro&qid=1589765488&sr=8-3)

+ **x2** - 12P-2.54mm Header-Pin Connectors (Most controllers already come with these)

+ **x41 or x44** - Cherry MX compatible key switches

   - Cherry MX Switches [Cherry MX Clear](https://www.mouser.com/ProductDetail/540-MX1A-C1NW)

## Optional Parts:

+ **x10-x20** WS2812b RGB LEDs (Strip)

   - [Kingly-Keys RGB Strips](https://kingly-keys.xyz/collections/parts-and-pieces/products/ws2812b-leds-strip)

.

.

.

+ **x2** - 2u Stabilizers (GMK Brand *screw-in* Preffered)

OR*

+ **x1** - 7u Stabilizer (GMK Brand *screw-in* Preffered)

   - [Novelkeys Stabilizers](https://novelkeys.xyz/collections/miscellaneous/products/cherry-stabilizers?variant=3747938893864)

## A Helpful Build Guide by Mr. [Brandon Foltz](https://github.com/JayWalker512)
0. Orient yourself with the board. You're looking at the **top**  of the PCB when the Little Foot emblem is visible on the **right side** of the board.

1. Solder in diodes, making sure to orient them according to the silk screen on the board. You should solder them on to the bottom of the board (with leads coming out of the top of the board) because there are 2 diodes which will interfere with switches if soldered to the top.

2. Take the pin headers that came with your Pro Micro and push LONG ends through the BACK of the PCB, so that the black plastic spacers are on the back side of the PCB. Solder to the pins poking through the FRONT of the board. I like to use a small piece of tape to hold the pins in place while I solder, otherwise the headers might fall out of the holes when the board is flipped over to solder.

 When the build is finished, the Pro Micro will sit on top of the black plastic spacers now on the back of the PCB.

3. Solder in pin headers or pin sockets for an RGB strip if you're using one. The pins/sockets should be mounted on the bottom off the board, so that you can plug in your RGB strip there.

4. Install stabilizers (either 2x 2U or 1x 7U depending on your spacebar configuration). Ensure they are mounted on the **top** of the board.

5. Solder on the reset switch. I find it's easiest to do this by applying a tiny (tiny!) blob of solder to the pads first, then using tweezers to hold the switch and solder the pins to the solder blob on the board.

6. If you're building this with a plate, now is the time to put all your switches in the plate, and then use that to align all the switch pins with their holes on the board.

 If you're building this without a plate, you can mount all the switches in their holes and use a piece of flat cardboard or plastic to help you flip the PCB over without any of the switches coming out of the holes.

 Solder the switches in place.

7. Put the pin headers coming from the PCB through the holes on the microcontroller. The components and socket on the microcontroller should be facing away from the PCB, with the USB port facing towards the top of the PCB. You can double check that everything is facing the correct direction by making sure the TX and RAW labels on the PCB line up with the corresponding holes on the microcontroller. The microcontroller should rest on the black pin spacers placing it just above the PCB, with enough space for the diode and switch leads under it.

8. Flash micro controller firmware if not already done. In my experience with these Pro Micro clones it helps to hold the reset button, then run the programmer command, then release the reset button. The programmer should recognize the board and flash it. I use the following command on my Ubuntu 16.04 system:

 ```
sudo avrdude -F -p atmega32u4 -P /dev/ttyACM0 -c avr109 -U flash:w:kingly_keys_little_foot_default.hex
```

9. Header over to [Keyboard Tester](https://keyboardtester.com) and ensure that all the keys are registering. If some of the switches are not registering, check to ensure that you do not have any incomplete or cold solder joins on your switch pins. Additionally, check to make sure the keymap in your firmware matches the switch layout that you installed.

 At this point your PCB is fully assembled, and you can install it in a case of your choice.

path: /01 - Complete Kits/The_Little_Foot-Keyboard-rev2.3/PCB_Gerbers/README.md

gha_language: G-code


text:
Fire Basis Cash

## Introduction

Fire Basis is an algorithmic stable coin protocol where the money supply is dynamically adjusted to meet changes in money demand.

When demand is rising, the blockchain will create more Fire Basis Cash. The expanded supply is designed to bring the Basis price back down.
When demand is falling, the blockchain will buy back Fire Basis Cash. The contracted supply is designed to restore Fire Basis price.
The basis protocol is designed to expand and contract supply similarly to the way central banks buy and sell fiscal debt to stabilize purchasing power. For this reason, we refer to Fire Basis Cash as having an algorithmic central bank.

## The Fire Basis Cash Protocol

Basis Cash differs from the original Basis Project in several meaningful ways:

1. **Rationally simplified** - several core mechanisms of the Basis protocol has been simplified, especially around bond issuance and seigniorage distribution. We've thought deeply about the tradeoffs for these changes, and believe they allow significant gains in UX and contract simplicity, while preserving the intended behavior of the original monetary policy design.
2. **Censorship resistant** - we launch this project anonymously, protected by the guise of characters from the popular SciFi series Rick and Morty. We believe this will allow the project to avoid the censorship of regulators that scuttled the original Basis Protocol, but will also allow Basis Cash to avoid founder glorification & single points of failure that have plagued so many other projects.
3. **Fairly distributed** - both Basis Shares and Basis Cash has zero premine and no investors - community members can earn the initial supply of both assets by helping to contribute to bootstrap liquidity & adoption of Basis Cash.

### A Four-token System

There exists three types of assets in the Fire Basis Cash system.

- **Fire Basis Cash ($FBC)**: a stablecoin, which the protocol aims to keep value-pegged to 1 US Dollar.
- **Fire Basis Bonds ($FBB)**: IOUs issued by the system to buy back Fire Basis Cash when price($FBC) < $1. Bonds are sold at a meaningful discount to price($FBC), and redeemed at $1 when price($FBC) normalizes to $1.
- **Fire Basis Shares ($FBS)**: receives surplus seigniorage (seigniorage left remaining after all the bonds have been redeemed).
- **Fire Basis Goverance ($FBG)**: the fire basis governance token,which can accelerate the speed of mining and get more priority in boardroom.

### Stability Mechanism

- **Contraction**: When the price($FBC) < ($1 - epsilon), users can trade in $BAC for $FBB at the BABBAC exchange rate of price($FBC). This allows bonds to be always sold at a discount to cash during a contraction.
- **Expansion**: When the price($FBC) > ($1 + epsilon), users can trade in 1 $FBB for 1 $FBC. This allows bonds to be redeemed always at a premium to the purchase price.
- **Seigniorage Allocation**: If there are no more bonds to be redeemed, (i.e. bond Supply is negligibly small), more $FBC is minted totalSupply($FBC) * (price($FBC) - 1), and placed in a pool for $FBS holders to claim pro-rata in a 24 hour period.

Visit our official website [Fire Basis Cash](https://firebasis.com).

## Questions and Contribution

To chat with us & stay up to date, join our [Telegram](https://t.me/hecofire).

Join us on [Medium](https://firebasis.medium.com).

## License

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

Copyright (c) 2013-present

repository: FireBasisCash/basiscash-frontend

repo_name: FireBasisCash/basiscash-frontend


text:
##### [Back to Application docs](./README.md)

## Order Methods
Handles Platform websites OMS
* [getOrders](#getorders)
* [getOrderById](#getorderbyid)
* [getShipmentById](#getshipmentbyid)
* [getShipmentReasons](#getshipmentreasons)
* [updateShipmentStatus](#updateshipmentstatus)
* [trackShipment](#trackshipment)
* [getPosOrderById](#getposorderbyid)
* [getCustomerDetailsByShipmentId](#getcustomerdetailsbyshipmentid)
* [sendOtpToShipmentCustomer](#sendotptoshipmentcustomer)
* [verifyOtpShipmentCustomer](#verifyotpshipmentcustomer)

## Methods with example and description

### getOrders
Get all orders

```javascript
// Promise
const promise = order.getOrders({  pageNo : value,
 pageSize : value,
 fromDate : value,
 toDate : value,
 status : value });

// Async/Await
const data = await order.getOrders({  pageNo : value,
 pageSize : value,
 fromDate : value,
 toDate : value,
 status : value });
```

| Argument  |  Type  | Required | Description |
| --------- | -----  | -------- | ----------- |
| pageNo | number | no | The page number to navigate through the given set of results. Default value is 1. |
| pageSize | number | no | The number of items to retrieve in each page. Default value is 10. |
| fromDate | string | no | The date from which the orders should be retrieved. |
| toDate | string | no | The date till which the orders should be retrieved. |
| status | number | no | A filter to retrieve orders by their current status such as _placed_, _delivered_, etc. |

Use this API to retrieve all the orders.

*Returned Response:*

[OrderList](#OrderList)

Success. Returns all the orders. Check the example shown below or refer `OrderList` for more details.

  Example:

```json

```

---

### getOrderById
Get details of an order

```javascript
// Promise
const promise = order.getOrderById({  orderId : value });

// Async/Await
const data = await order.getOrderById({  orderId : value });
```

| Argument  |  Type  | Required | Description |
| --------- | -----  | -------- | ----------- |
| orderId | string | yes | A unique number used for identifying and tracking your orders. |

Use this API to retrieve order details such as tracking details, shipment, store information using Fynd Order ID.

*Returned Response:*

[OrderById](#OrderById)

Success. Check the example shown below or refer `OrderById` for more details.

  Example:

```json

```

---

### getShipmentById
Get details of a shipment

```javascript
// Promise
const promise = order.getShipmentById({  shipmentId : value });

// Async/Await
const data = await order.getShipmentById({  shipmentId : value });
```

| Argument  |  Type  | Required | Description |
| --------- | -----  | -------- | ----------- |
| shipmentId | string | yes | ID of the shipment. An order may contain multiple items and may get divided into one or more shipment, each having its own ID. |

Use this API to retrieve shipment details such as price breakup, tracking details, store information, etc. using Shipment ID.

*Returned Response:*

[ShipmentById](#ShipmentById)

Success. Check the example shown below or refer `ShipmentById` for more details.

  Example:

```json

```

---

### getShipmentReasons
Get reasons behind full or partial cancellation of a shipment

```javascript
// Promise
const promise = order.getShipmentReasons({  shipmentId : value });

// Async/Await
const data = await order.getShipmentReasons({  shipmentId : value });
```

| Argument  |  Type  | Required | Description |
| --------- | -----  | -------- | ----------- |
| shipmentId | string | yes | ID of the shipment. An order may contain multiple items and may get divided into one or more shipment, each having its own ID. |

Use this API to retrieve the issues that led to the cancellation of bags within a shipment.

*Returned Response:*

[ShipmentReasons](#ShipmentReasons)

Success. Check the example shown below or refer `ShipmentReasons` for more details.

  Example:

```json

```

---

### updateShipmentStatus
Update the shipment status

```javascript
// Promise
const promise = order.updateShipmentStatus({  shipmentId : value,
 body : value });

// Async/Await
const data = await order.updateShipmentStatus({  shipmentId : value,
 body : value });
```

| Argument  |  Type  | Required | Description |
| --------- | -----  | -------- | ----------- |
| shipmentId | string | yes | ID of the shipment. An order may contain multiple items and may get divided into one or more shipment, each having its own ID. |
| body | [ShipmentStatusUpdateBody](#ShipmentStatusUpdateBody) | yes | Request body |

Use this API to update the status of a shipment using its shipment ID.

*Returned Response:*

[ShipmentStatusUpdate](#ShipmentStatusUpdate)

Success. Check the example shown below or refer `ShipmentStatusUpdateBody` for more details.

  Example:

```json

```

---

### trackShipment
Track shipment

```javascript
// Promise
const promise = order.trackShipment({  shipmentId : value });

// Async/Await
const data = await order.trackShipment({  shipmentId : value });
```

| Argument  |  Type  | Required | Description |
| --------- | -----  | -------- | ----------- |
| shipmentId | string | yes | ID of the shipment. An order may contain multiple items and may get divided into one or more shipment, each having its own ID. |

Use this API to track a shipment using its shipment ID.

*Returned Response:*

[ShipmentTrack](#ShipmentTrack)

Success. Check the example shown below or refer `ShipmentTrack` for more details.

  Example:

```json

```

---

### getPosOrderById
Get POS Order

```javascript
// Promise
const promise = order.getPosOrderById({  orderId : value });

// Async/Await
const data = await order.getPosOrderById({  orderId : value });
```

| Argument  |  Type  | Required | Description |
| --------- | -----  | -------- | ----------- |
| orderId | string | yes | A unique number used for identifying and tracking your orders. |

Use this API to retrieve a POS order and all its details such as tracking details, shipment, store information using Fynd Order ID.

*Returned Response:*

[PosOrderById](#PosOrderById)

Success. Check the example shown below or refer `PosOrderById` for more details.

  Example:

```json

```

---

### getCustomerDetailsByShipmentId
Get Customer Details by Shipment Id

```javascript
// Promise
const promise = order.getCustomerDetailsByShipmentId({  orderId : value,
 shipmentId : value });

// Async/Await
const data = await order.getCustomerDetailsByShipmentId({  orderId : value,
 shipmentId : value });
```

| Argument  |  Type  | Required | Description |
| --------- | -----  | -------- | ----------- |
| orderId | string | yes | A unique number used for identifying and tracking your orders. |
| shipmentId | string | yes | ID of the shipment. An order may contain multiple items and may get divided into one or more shipment, each having its own ID. |

Use this API to retrieve customer details such as mobileno using Shipment ID.

*Returned Response:*

[CustomerDetailsByShipmentId](#CustomerDetailsByShipmentId)

Success. Check the example shown below or refer `CustomerDetailsByShipmentId` for more details.

  Example:

```json

```

---

### sendOtpToShipmentCustomer
Send and Resend Otp code to Order-Shipment customer

```javascript
// Promise
const promise = order.sendOtpToShipmentCustomer({  orderId : value,
 shipmentId : value });

// Async/Await
const data = await order.sendOtpToShipmentCustomer({  orderId : value,
 shipmentId : value });
```

| Argument  |  Type  | Required | Description |
| --------- | -----  | -------- | ----------- |
| orderId | string | yes | A unique number used for identifying and tracking your orders. |
| shipmentId | string | yes | ID of the shipment. An order may contain multiple items and may get divided into one or more shipment, each having its own ID. |

Use this API to send OTP to the customer of the mapped Shipment.

*Returned Response:*

[sendOTPApplicationResponse](#sendOTPApplicationResponse)

Success to acknowledge the service was notified

  Example:

```json

```

---

### verifyOtpShipmentCustomer
Verify Otp code

```javascript
// Promise
const promise = order.verifyOtpShipmentCustomer({  orderId : value,
 shipmentId : value,
 body : value });

// Async/Await
const data = await order.verifyOtpShipmentCustomer({  orderId : value,
 shipmentId : value,
 body : value });
```

| Argument  |  Type  | Required | Description |
| --------- | -----  | -------- | ----------- |
| orderId | string | yes | A unique number used for identifying and tracking your orders. |
| shipmentId | string | yes | ID of the shipment. An order may contain multiple items and may get divided into one or more shipment, each having its own ID. |
| body | [ReqBodyVerifyOTPShipment](#ReqBodyVerifyOTPShipment) | yes | Request body |

Use this API to verify OTP and create a session token with custom payload.

*Returned Response:*

[ResponseVerifyOTPShipment](#ResponseVerifyOTPShipment)

Success, the code is valid and returns a session token

  Example:

```json

```

---

### Schemas

 #### [OrderById](#OrderById)

 | Properties | Type | Nullable | Description |
 | ---------- | ---- | -------- | ----------- |
 | order | [OrderSchema](#OrderSchema) |  yes  |  |

---

 #### [OrderList](#OrderList)

 | Properties | Type | Nullable | Description |
 | ---------- | ---- | -------- | ----------- |
 | items | [[OrderSchema](#OrderSchema)] |  yes  |  |
 | page | [OrderPage](#OrderPage) |  yes  |  |
 | filters | [OrderFilters](#OrderFilters) |  yes  |  |

---

 #### [OrderPage](#OrderPage)

 | Properties | Type | Nullable | Description |
 | ---------- | ---- | -------- | ----------- |
 | item_total | number |  no  |  |
 | type | string |  no  |  |
 | size | number |  no  |  |
 | current | number |  no  |  |
 | has_next | boolean |  no  |  |

---

 #### [OrderFilters](#OrderFilters)

 | Properties | Type | Nullable | Description |
 | ---------- | ---- | -------- | ----------- |
 | statuses | [[OrderStatuses](#OrderStatuses)] |  no  |  |

---

 #### [OrderStatuses](#OrderStatuses)

 | Properties | Type | Nullable | Description |
 | ---------- | ---- | -------- | ----------- |
 | display | string |  no  |  |
 | value | number |  no  |  |
 | is_selected | boolean |  no  |  |

---

 #### [ReqBodyVerifyOTPShipment](#ReqBodyVerifyOTPShipment)

 | Properties | Type | Nullable | Description |
 | ---------- | ---- | -------- | ----------- |
 | request_id | string |  yes  |  |
 | otp_code | string |  yes  |  |

---

 #### [ResponseVerifyOTPShipment](#ResponseVerifyOTPShipment)

 | Properties | Type | Nullable | Description |
 | ---------- | ---- | -------- | ----------- |
 | success | boolean |  yes  |  |

---

 #### [sendOTPApplicationResponse](#sendOTPApplicationResponse)

 | Properties | Type | Nullable | Description |
 | ---------- | ---- | -------- | ----------- |
 | success | boolean |  yes  |  |
 | request_id | string |  yes  |  |
 | message | string |  yes  |  |
 | resend_timer | number |  yes  |  |

---

 #### [ShipmentById](#ShipmentById)

 | Properties | Type | Nullable | Description |
 | ---------- | ---- | -------- | ----------- |
 | shipment | [Shipments](#Shipments) |  yes  |  |

---

 #### [CustomerDetailsByShipmentId](#CustomerDetailsByShipmentId)

 | Properties | Type | Nullable | Description |
 | ---------- | ---- | -------- | ----------- |
 | order_id | string |  yes  |  |
 | shipment_id | string |  yes  |  |
 | name | string |  yes  |  |
 | phone | string |  yes  |  |
 | country | string |  yes  |  |

---

 #### [ShipmentReasons](#ShipmentReasons)

 | Properties | Type | Nullable | Description |
 | ---------- | ---- | -------- | ----------- |
 | reasons | [[Reasons](#Reasons)] |  yes  |  |

---

 #### [ShipmentStatusUpdateBody](#ShipmentStatusUpdateBody)

 | Properties | Type | Nullable | Description |
 | ---------- | ---- | -------- | ----------- |
 | statuses | [[StatusesBody](#StatusesBody)] |  yes  |  |
 | force_transition | boolean |  yes  |  |

---

 #### [StatusesBody](#StatusesBody)

 | Properties | Type | Nullable | Description |
 | ---------- | ---- | -------- | ----------- |
 | status | string |  no  |  |
 | shipments | string |  no  |  |

---

 #### [ShipmentStatusUpdate](#ShipmentStatusUpdate)

 | Properties | Type | Nullable | Description |
 | ---------- | ---- | -------- | ----------- |
 | message | [string] |  yes  |  |
 | status | boolean |  yes  |  |

---

 #### [ShipmentTrack](#ShipmentTrack)

 | Properties | Type | Nullable | Description |
 | ---------- | ---- | -------- | ----------- |
 | results | [[Track](#Track)] |  yes  |  |

---

 #### [OrderSchema](#OrderSchema)

 | Properties | Type | Nullable | Description |
 | ---------- | ---- | -------- | ----------- |
 | order_id | string |  no  |  |
 | breakup_values | [[BreakupValues](#BreakupValues)] |  no  |  |
 | order_created_time | string |  no  |  |
 | shipments | [[Shipments](#Shipments)] |  no  |  |
 | total_shipments_in_order | number |  no  |  |
 | user_info | [UserInfo](#UserInfo) |  no  |  |
 | bags_for_reorder | [[BagsForReorder](#BagsForReorder)] |  no  |  |

---

 #### [BagsForReorder](#BagsForReorder)

 | Properties | Type | Nullable | Description |
 | ---------- | ---- | -------- | ----------- |
 | item_id | number |  no  |  |
 | item_size | string |  no  |  |
 | store_id | number |  no  |  |
 | seller_id | number |  no  |  |
 | quantity | number |  no  |  |
 | article_assignment | [BagsForReorderArticleAssignment](#BagsForReorderArticleAssignment) |  no  |  |

---

 #### [BagsForReorderArticleAssignment](#BagsForReorderArticleAssignment)

 | Properties | Type | Nullable | Description |
 | ---------- | ---- | -------- | ----------- |
 | level | string |  no  |  |
 | strategy | string |  no  |  |

---

 #### [PosOrderById](#PosOrderById)

 | Properties | Type | Nullable | Description |
 | ---------- | ---- | -------- | ----------- |
 | order | [OrderSchema](#OrderSchema) |  yes  |  |

---

 #### [Bags](#Bags)

 | Properties | Type | Nullable | Description |
 | ---------- | ---- | -------- | ----------- |
 | item | [Item](#Item) |  no  |  |
 | prices | [Prices](#Prices) |  no  |  |
 | current_status | [CurrentStatus](#CurrentStatus) |  no  |  |
 | id | number |  no  |  |
 | financial_breakup | [[FinancialBreakup](#FinancialBreakup)] |  no  |  |

---

 #### [Item](#Item)

 | Properties | Type | Nullable | Description |
 | ---------- | ---- | -------- | ----------- |
 | brand | [ItemBrand](#ItemBrand) |  no  |  |
 | name | string |  no  |  |
 | size | string |  no  |  |
 | slug_key | string |  no  |  |
 | image | [string] |  no  |  |
 | code | string |  no  |  |
 | id | number |  no  |  |

---

 #### [Prices](#Prices)

 | Properties | Type | Nullable | Description |
 | ---------- | ---- | -------- | ----------- |
 | amount_paid_roundoff | number |  no  |  |
 | fynd_credits | number |  no  |  |
 | cod_charges | number |  no  |  |
 | cashback | number |  no  |  |
 | added_to_fynd_cash | boolean |  no  |  |
 | price_marked | number |  no  |  |
 | transfer_price | number |  no  |  |
 | coupon_value | number |  no  |  |
 | price_effective | number |  no  |  |
 | refund_credit | number |  no  |  |
 | amount_paid | number |  no  |  |
 | refund_amount | number |  no  |  |
 | cashback_applied | number |  no  |  |
 | gst_tax_percentage | number |  no  |  |
 | value_of_good | number |  no  |  |
 | brand_calculated_amount | number |  no  |  |
 | promotion_effective_discount | number |  no  |  |
 | discount | number |  no  |  |
 | coupon_effective_discount | number |  no  |  |
 | delivery_charge | number |  no  |  |

---

 #### [CurrentStatus](#CurrentStatus)

 | Properties | Type | Nullable | Description |
 | ---------- | ---- | -------- | ----------- |
 | updated_at | string |  no  |  |
 | status | string |  no  |  |
 | name | string |  no  |  |
 | journey_type | string |  no  |  |

---

 #### [FinancialBreakup](#FinancialBreakup)

 | Properties | Type | Nullable | Description |
 | ---------- | ---- | -------- | ----------- |
 | brand_calculated_amount | number |  no  |  |
 | coupon_value | number |  no  |  |
 | amount_paid_roundoff | number |  no  |  |
 | gst_fee | string |  no  |  |
 | refund_credit | number |  no  |  |
 | cashback | number |  no  |  |
 | refund_amount | number |  no  |  |
 | value_of_good | number |  no  |  |
 | promotion_effective_discount | number |  no  |  |
 | size | string |  no  |  |
 | total_units | number |  no  |  |
 | discount | number |  no  |  |
 | amount_paid | number |  no  |  |
 | fynd_credits | number |  no  |  |
 | added_to_fynd_cash | boolean |  no  |  |
 | delivery_charge | number |  no  |  |
 | hsn_code | string |  no  |  |
 | coupon_effective_discount | number |  no  |  |
 | transfer_price | number |  no  |  |
 | identifiers | [Identifiers](#Identifiers) |  no  |  |
 | gst_tag | string |  no  |  |
 | price_marked | number |  no  |  |
 | price_effective | number |  no  |  |
 | cod_charges | number |  no  |  |
 | item_name | string |  no  |  |
 | cashback_applied | number |  no  |  |
 | gst_tax_percentage | number |  no  |  |

---

 #### [Identifiers](#Identifiers)

 | Properties | Type | Nullable | Description |
 | ---------- | ---- | -------- | ----------- |
 | ean | string |  no  |  |
 | sku_code | string |  no  |  |

---

 #### [ItemBrand](#ItemBrand)

 | Properties | Type | Nullable | Description |
 | ---------- | ---- | -------- | ----------- |
 | name | string |  no  |  |
 | logo | string |  no  |  |

---

 #### [BreakupValues](#BreakupValues)

 | Properties | Type | Nullable | Description |
 | ---------- | ---- | -------- | ----------- |
 | display | string |  no  |  |
 | value | number |  no  |  |
 | name | string |  no  |  |

---

 #### [DeliveryAddress](#DeliveryAddress)

 | Properties | Type | Nullable | Description |
 | ---------- | ---- | -------- | ----------- |
 | pincode | string |  no  |  |
 | landmark | string |  no  |  |
 | contact_person | string |  no  |  |
 | phone | string |  no  |  |
 | state | string |  no  |  |
 | version | string |  no  |  |
 | address1 | string |  no  |  |
 | created_at | string |  no  |  |
 | address_type | string |  no  |  |
 | address_category | string |  no  |  |
 | area | string |  no  |  |
 | city | string |  no  |  |
 | latitude | number |  no  |  |
 | longitude | number |  no  |  |
 | email | string |  no  |  |
 | country | string |  no  |  |
 | address2 | string |  no  |  |
 | updated_at | string |  no  |  |
 | name | string |  no  |  |
 | address | string |  no  |  |

---

 #### [FulfillingStore](#FulfillingStore)

 | Properties | Type | Nullable | Description |
 | ---------- | ---- | -------- | ----------- |
 | code | string |  no  |  |
 | id | number |  no  |  |
 | name | string |  no  |  |
 | company_id | number |  no  |  |

---

 #### [Invoice](#Invoice)

 | Properties | Type | Nullable | Description |
 | ---------- | ---- | -------- | ----------- |
 | updated_date | string |  no  |  |
 | invoice_url | string |  no  |  |
 | label_url | string |  no  |  |

---

 #### [Promise](#Promise)

 | Properties | Type | Nullable | Description |
 | ---------- | ---- | -------- | ----------- |
 | timestamp | [Timestamp](#Timestamp) |  no  |  |

---

 #### [Timestamp](#Timestamp)

 | Properties | Type | Nullable | Description |
 | ---------- | ---- | -------- | ----------- |
 | min | string |  no  |  |
 | max | string |  no  |  |

---

 #### [Reasons](#Reasons)

 | Properties | Type | Nullable | Description |
 | ---------- | ---- | -------- | ----------- |
 | reason_text | string |  no  |  |
 | show_text_area | boolean |  no  |  |
 | feedback_type | string |  no  |  |
 | flow | string |  no  |  |
 | reason_id | number |  no  |  |
 | priority | number |  no  |  |

---

 #### [ShipmentStatus](#ShipmentStatus)

 | Properties | Type | Nullable | Description |
 | ---------- | ---- | -------- | ----------- |
 | title | string |  no  |  |
 | hex_code | string |  no  |  |

---

 #### [ShipmentUserInfo](#ShipmentUserInfo)

 | Properties | Type | Nullable | Description |
 | ---------- | ---- | -------- | ----------- |
 | gender | string |  no  |  |
 | mobile | string |  no  |  |
 | first_name | string |  no  |  |
 | last_name | string |  no  |  |

---

 #### [Shipments](#Shipments)

 | Properties | Type | Nullable | Description |
 | ---------- | ---- | -------- | ----------- |
 | order_id | string |  no  |  |
 | breakup_values | [[BreakupValues](#BreakupValues)] |  no  |  |
 | track_url | string |  no  |  |
 | traking_no | string |  no  |  |
 | tracking_details | [[TrackingDetails](#TrackingDetails)] |  no  |  |
 | beneficiary_details | boolean |  no  |  |
 | can_return | boolean |  no  |  |
 | prices | [Prices](#Prices) |  no  |  |
 | need_help_url | string |  no  |  |
 | shipment_id | string |  no  |  |
 | total_bags | number |  no  |  |
 | delivery_address | [DeliveryAddress](#DeliveryAddress) |  no  |  |
 | invoice | [Invoice](#Invoice) |  no  |  |
 | comment | string |  no  |  |
 | order_type | string |  no  |  |
 | promise | [Promise](#Promise) |  no  |  |
 | fulfilling_store | [FulfillingStore](#FulfillingStore) |  no  |  |
 | bags | [[Bags](#Bags)] |  no  |  |
 | can_cancel | boolean |  no  |  |
 | payment | [ShipmentPayment](#ShipmentPayment) |  no  |  |
 | shipment_created_at | string |  no  |  |
 | shipment_status | [ShipmentStatus](#ShipmentStatus) |  no  |  |
 | user_info | [ShipmentUserInfo](#ShipmentUserInfo) |  no  |  |
 | size_info | string |  no  |  |
 | total_details | [ShipmentTotalDetails](#ShipmentTotalDetails) |  no  |  |

---

 #### [ShipmentTotalDetails](#ShipmentTotalDetails)

 | Properties | Type | Nullable | Description |
 | ---------- | ---- | -------- | ----------- |
 | total_price | number |  no  |  |
 | sizes | number |  no  |  |
 | pieces | number |  no  |  |

---

 #### [ShipmentPayment](#ShipmentPayment)

 | Properties | Type | Nullable | Description |
 | ---------- | ---- | -------- | ----------- |
 | logo | string |  no  |  |
 | mode | string |  no  |  |
 | status | string |  no  |  |

---

 #### [Track](#Track)

 | Properties | Type | Nullable | Description |
 | ---------- | ---- | -------- | ----------- |
 | awb | string |  no  |  |
 | updated_at | string |  no  |  |
 | last_location_recieved_at | string |  no  |  |
 | reason | string |  no  |  |
 | shipment_type | string |  no  |  |
 | status | string |  no  |  |
 | updated_time | string |  no  |  |
 | account_name | string |  no  |  |

---

 #### [TrackingDetails](#TrackingDetails)

 | Properties | Type | Nullable | Description |
 | ---------- | ---- | -------- | ----------- |
 | is_current | boolean |  no  |  |
 | status | string |  no  |  |
 | time | string |  no  |  |
 | is_passed | boolean |  no  |  |

---

 #### [UserInfo](#UserInfo)

 | Properties | Type | Nullable | Description |
 | ---------- | ---- | -------- | ----------- |
 | gender | string |  no  |  |
 | mobile | string |  no  |  |
 | name | string |  no  |  |
 | email | string |  no  |  |

---

 #### [ApefaceApiError](#ApefaceApiError)

 | Properties | Type | Nullable | Description |
 | ---------- | ---- | -------- | ----------- |
 | message | string |  no  |  |

---


text:
---
layout: docs
title:  "Arguments"
position: 3
---

# Argument Types

In the [guide](/usage.html), we specified the type of an option's argument like so:

```scala mdoc:to-string
import com.monovore.decline._
import java.nio.file.Path

val path = Opts.option[Path]("input", "Path to the input file.")
```

This does two different things for us:

- It specifies a _parsing function_ -- when the user passes a string as an argument, `decline` will try and
  interpret it as a path and report an error if it can't.
- It specifies a default 'metavar' -- the `<path>` text you can see in the output above. This helps the user
  understand what sort of input your program expects in that position.

This information is provided by the `com.monovore.decline.Argument` [type class](https://typelevel.org/cats/typeclasses.html).
`decline` provides instances for many commonly used standard-library types: strings, numbers, paths, URIs...

## `java.time` support

`decline` has built-in support for the `java.time` library introduced in Java 8,
including argument instances for `Duration`, `ZonedDateTime`, `ZoneId`, `Instant`, and others.
You'll need to pull these in with an explicit import:

```scala mdoc:to-string
import java.time._
import com.monovore.decline.time._

val fromDate = Opts.option[LocalDate]("fromDate", help = "Local date from where start looking at data")
val timeout = Opts.option[Duration]("timeout", help = "Operation timeout")
```

By default, this parses using the standard ISO 8601 formats.
If you'd like to use a custom time format,
`decline` also provides `Argument` builders that take a `java.time.format.DateTimeFormatter`.
For example, you can define a custom parse for a `LocalDate` by calling `localDateWithFormatter`:

```scala mdoc:to-string
import java.time.format.DateTimeFormatter
import com.monovore.decline.time.localDateWithFormatter

val myDateArg: Argument[LocalDate] = localDateWithFormatter(
  DateTimeFormatter.ofPattern("dd/MM/yy")
)
```

In general, any date or time type should have a `xWithFormatter` method available.

## `refined` support

`decline` has support for [refined types](https://github.com/fthomas/refined) via the `decline-refined` module.
Refined types add an extra layer of safety by decorating standard types with predicates that get validated
automatically at compile time.
While command line arguments can't be validated at compile time,
refined argument types' runtime validation can still prevent
the introduction of invalid values by the user.

To make use of `decline-refined`, add the following to your `build.sbt`:

```scala
libraryDependencies += "com.monovore" %% "decline-refined" % "@DECLINE_VERSION@"
```

As an example, let's define a simple refined type and use it as a command-line argument.

```scala mdoc:to-string
import eu.timepit.refined.api.Refined
import eu.timepit.refined.numeric.Positive
import com.monovore.decline.refined._

type PosInt = Int Refined Positive

val lines = Command("lines", "Parse a positive number of lines.") {
  Opts.argument[PosInt]("count")
}
```

We can see that positive numbers will parse correctly, but anything zero or below will fail:

```scala mdoc:to-string
lines.parse(Seq("10"))
lines.parse(Seq("0"))
```

## `enumeratum` Support

> *NB: as of version 2.1 and the move to Scala 3,
> `enumeratum` support [has been dropped](https://github.com/bkirwi/decline/issues/260).
> If you're still using `enumeratum` for Scala 2,
> you may wish to stick with either an older version or reimplement...
> implementing `Argument` for `EnumEntry` is typically straightforward.*

`decline` also supports [enumeratum](https://github.com/lloydmeta/enumeratum) via the `decline-enumeratum` module.
Enumeratum provides a powerful Scala-idiomatic and Java-friendly implementation of enums.

To make use of the `enumeratum` support, add the following to your `build.sbt`:

```scala
libraryDependencies += "com.monovore" %% "decline-enumeratum" % "@DECLINE_VERSION@"
```

As an example,
we'll define a plain enumeration as required by `enumeratum`,
and use it as a command-line argument:

```scala
import _root_.enumeratum._
import com.monovore.decline.enumeratum._

sealed trait Color extends EnumEntry with EnumEntry.Lowercase

object Color extends Enum[Color] {
  case object Red extends Color
  case object Green extends Color
  case object Blue extends Color

  val values = findValues
}

val color = Command("color", "Return the chosen color.") {
  Opts.argument[Color]()
}
```

This parser should successfully read in `red`, `green`, or `blue`, and fail on anything else.
(NB: parsers are case sensitive!)

```scala
color.parse(Seq("red"))

color.parse(Seq("black"))

color.parse(Seq("Red"))
```

`enumeratum` also supports _value enums_, which are enumerations that are based on a value different than the actual
enum value name. Here's the same enum type as before, but backed by an integer:

```scala
import _root_.enumeratum.values._
import com.monovore.decline.enumeratum._

sealed abstract class IntColor(val value: Int) extends IntEnumEntry

object IntColor extends IntEnum[IntColor] {
  case object Red extends IntColor(0)
  case object Green extends IntColor(1)
  case object Blue extends IntColor(2)

  val values = findValues
}

val intColor = Command("int-color", "Shows the chosen color") {
  Opts.argument[IntColor]()
}
```

Value parsers expect the underlying enum value.
Our new `IntEnum` parser will fail on anything but `0`, `1`, or `2`.

```scala
intColor.parse(Seq("0"))

intColor.parse(Seq("red"))

intColor.parse(Seq("8"))
```

## Defining Your Own

In some cases, you'll want to take a command-line argument that doesn't quite map to some provided type.
Say you have the following key-value config type:

```scala mdoc:to-string
case class Config(key: String, value: String)
```

You can define an option that collects a list of configs, by specifying a
custom metavar and adding additional validation and parsing logic:

```scala mdoc:to-string
import cats.data.Validated

Opts.option[String]("config", "Specify an additional config.", metavar = "key:value")
  .mapValidated { string =>
    string.split(":", 2) match {
      case Array(key, value) => Validated.valid(Config(key, value))
      case _ => Validated.invalidNel(s"Invalid key:value pair: $string")
    }
  }
```

For most cases, this works perfectly well! For larger applications, though --
where many different options, subcommands or programs might want to use this
same basic config type -- doing this sort of thing each time is verbose and
error-prone.

It's easy enough to bundle the metavar and parsing logic together in an `Argument` instance:

```scala mdoc:to-string
implicit val configArgument: Argument[Config] = new Argument[Config] {

  def read(string: String) = {
    string.split(":", 2) match {
      case Array(key, value) => Validated.valid(Config(key, value))
      case _ => Validated.invalidNel(s"Invalid key:value pair: $string")
    }
  }

  def defaultMetavar = "key:value"
}
```

...and then defining new options that take configs becomes trivial:

```scala mdoc:to-string
Opts.option[Config]("config", "Specify an additional config.")
```

## Missing Instances

In a few cases, `decline` has intentionally _not_ defined an `Argument` instance for a particular type -- since there
are better ways to achieve the same effect. Some examples:

- `Boolean`: supporting `Boolean` arguments like `Opts.option[Boolean]("verbose", ???)` would lead to command-line usage like
  `my-command --verbose true`... but users of other POSIX-ish command line tools would expect `my-command --verbose`.
  You can get that more idiomatic style with `Opts.flag("verbose", ???).orFalse`; consider using that instead!
- `java.io.File`, `java.net.URL`: these types are mostly superseded by better alternatives (`java.nio.file.Path` and
  `java.net.URI`, respectively), and they support easy conversions to the older types to interoperate with existing code.
- `List[A]`: you might expect to be able to define a `Opts.option[List[String]](...)` to parse a comma-separated list of
  strings, like `--exclude foo,bar`. This ends up a little bit tricky in the general case: either you can't parse strings
  that contain commas, or you need some "escaping" mechanism, neither of which is particularly pleasant or idiomatic for
  users. Instead, consider using the plural methods like `Opts.options` or `Opts.arguments` to accumulate a list,
  like `--exclude foo --exclude bar`. (This is also easier to use programatically!)

repository: bkirwi/decline

gha_language: Scala

repo_name: bkirwi/decline


text:
World
================================
The BARK-world models a simultaneous-move game where all agents generate a behavior given a cloned world state at a specific time. All agents are moved according to their specified behavior models for a fixed time period `delta_time` and the validity of the resulting world state is checked. In principle, the `World` class is defined as

```cpp
class World {
    public:
	void Step(float delta_time);
    private:
	MapInterface map_interface_;
	AgentMap agents_;
	ObjectMap objects_;
	double world_time_;

}
```

The most important functions in the `World` class are listed below.

```eval_rst
  .. cpp:function:: void Step(float delta_time)
  The `Step` function loops through all agents, creates a cloned world and then calls the `Move` function of each agent.
  The Move function in combination with the Step function integrates the main functionality of BARK.
```

```eval_rst
  .. cpp:function:: inline World *World::Clone() const

  Returns a cloned world of the current world.
```

## ObservedWorld
The `ObservedWorld` is derived from the (protected) `World`. Furthermore, it offers additional functionality in order to increase its usability in the planning modules.
In the future, perturbations and other effects could be modeled. For example, the ego agent only having a partial world-view.

```cpp
class ObservedWorld : protected World {
 public:
    ObservedWorld(const World& world, const AgentId& ego_agent_id) :
      World(world),
      ego_agent_id_(ego_agent_id) {}
    ~ObservedWorld() {}
    double get_world_time() const { return World::get_world_time(); }
    const LocalMap& get_local_map() const {
      return *World::get_agent(ego_agent_id_)->get_local_map();
    }
    AgentPtr get_ego_agent() const {
      return World::get_agent(ego_agent_id_);
    }
    MapInterfacePtr get_map() const { return World::get_map(); }
    State current_ego_state() const {
      return World::get_agents()[ego_agent_id_]->get_current_state();
    }
    Point2d get_ego_point() const {
      State ego_state = current_ego_state();
      return Point2d(ego_state(X_POSITION), ego_state(Y_POSITION));
    }

 private:
    AgentId ego_agent_id_;
};
```

## Agents & Objects
All objects are static with a fixed state and 2D geometry. An agent is a dynamic object functioning as a container for the behavioral-, execution- and dynamic-model as described [here](agent_components.md). The agent class provides a `Move` function taking care of the necessary calls to generate a behavior and to check its feasibility. The agent tracks its movements in the `state_action_history_`. The goal of an agent is initially specified during instantiation using the `goal_lane_id`. Moreover, the `World` class manages all objects and agents based on IDs.

```cpp
	class Agent {
	public:
		 void Move(const float &dt, const ObservedWorld &observed_world);
	private:
		BehaviorModel behavior_model_;
		ExecutionModel execution_model_;
		DynamicModel	dynamic_model_;

		StateActionHistory state_action_history_;
	}
```

```eval_rst
  .. cpp:function:: void Move(const float &dt, const ObservedWorld &observed_world)

  The function calls the above-described models sequentially and updates the `state_action_history_`.
```

## OpenDriveMap
The `OpenDriveMap` class implements the specifications provided by the [OpenDRIVE 1.4 Format](http://www.opendrive.org/download.html). This allows an easy parsing and integration of maps available in the OpenDrive format.
Furthermore, it is additionally used as a data-container to store the map in memory.

## MapInterface
Provides an interface to the `OpenDriveMap` in order to speed up the search and it additionally also implements a routing functionality.
Therefore, it utilizes an `R-Tree` in order to find the nearest map objects, such as lanes. Furthermore, all lanes are being saved and connected in a graph.

```cpp
class MapInterface {
	public:
		bool interface_from_opendrive(const OpenDriveMapPtr& open_drive_map);
		bool FindNearestLanes(const modules::geometry::Point2d& point,
                                       const unsigned& num_lanes,
                                       std::vector<opendrive::LanePtr>& lanes);
		std::pair< std::vector<LanePtr>, std::vector<LanePtr> >
			ComputeLaneBoundariesHorizon(const LaneId& startid, const LaneId& goalid);

	private:
	       OpenDriveMapPtr open_drive_map_;
	  	RoadgraphPtr roadgraph_;
	  	rtree_lane rtree_lane_;
}
```

```eval_rst
  .. cpp:function:: std::pair< std::vector<LanePtr>, std::vector<LanePtr> > ComputeLaneBoundariesHorizon(const LaneId& startid, const LaneId& goalid)

  Generates a route using boost-graph (the LaneGraph) and returns the left-, right-boundary as well as the centerline.
```

```eval_rst
  .. cpp:function:: bool FindNearestLanes(const modules::geometry::Point2d& point, const unsigned& num_lanes, std::vector<opendrive::LanePtr>& lanes)

  A function that returns the nearest lanes for a given point.
```

Based on the Roadgraph-interface, the LocalMap searches a valid route for an agent given its `goal_lane_id`. It then and concatenates the lane geometry to 2D lines which can easily be used in the behavior generation models.

```cpp
class LocalMap {
	public:
		bool generate(Point2d point,
			      LaneId goal_lane_id,
			      double horizon = numeric_double_limits::max());

		Line get_inner_line() const { return inner_line_; }
		Line get_outer_line() const { return outer_line_; }
		Line get_center_line() const { return center_line_; }
	private:
		MapInterfacePtr map_interface_;

}
```

repository: heumchri/bark

repo_name: heumchri/bark


text:
# holiday_jp-go

[![GoDoc](https://godoc.org/github.com/holiday-jp/holiday_jp-go?status.svg)](https://godoc.org/github.com/holiday-jp/holiday_jp-go) [![test](https://github.com/holiday-jp/holiday_jp-go/workflows/test/badge.svg)](https://github.com/holiday-jp/holiday_jp-go/actions)

🎌 Japanese holiday for Go

## Requirements
* go 1.9 or later

## Installing

```bash
$ go get github.com/holiday-jp/holiday_jp-go
```

## Example

```go
import "github.com/holiday-jp/holiday_jp-go"

if holiday.IsHoliday(time.Now()) {
    fmt.Println("today is holiday!")
}
```


text:
# hsd - Coins
Getting coin information via API.

*Coin stands for UTXO*

You need to enable index-address in order to lookup coins by address.

You can also enable index-tx to lookup transactions by txid.

Launch the hsd daemon with these arguments:

hsd --daemon --index-address=true --index-tx=true

These index arguments cannot be changed once hsd has been started for the first time, without resyncing the node.

## Get coin by Outpoint

This API call is always available regardless indexing options.

```javascript
let hash, index;
```

```shell--vars
hash='7d142b878b7894fb916280d0bee0b5c4f8970e1adbc9d1a2e9057a0b8187b709';
index=0;
```

```shell--curl
curl http://x:api-key@<IP_ADDRESS>:14037/coin/$hash/$index
```

```shell--cli
hsd-cli coin $hash $index
```

```javascript
const {NodeClient} = require('hs-client');
const {Network} = require('hsd');
const network = Network.get('regtest');

const clientOptions = {
  port: network.rpcPort,
  apiKey: 'api-key'
}

const client = new NodeClient(clientOptions);

(async () => {
  const result = await client.getCoin(hash, index);
  console.log(result);
})();
```

> The above command returns JSON structured like this:

```json
{
  "version": 0,
  "height": 0,
  "value":<PHONE_NUMBER>,
  "address": "rs1q7q3h4chglps004u3yn79z0cp9ed24rfrhvrxnx",
  "covenant": {
    "type": 0,
    "action": "NONE",
    "items": []
  },
  "coinbase": true,
  "hash": "9553240e6f711271cfccf9407c9348996e61cb3bd39adbc2ec258ff940ff22c6",
  "index": 0
}
```

Get coin by outpoint (hash and index). Returns coin in hsd coin JSON format.
`value` is always expressed in subunits.

### HTTP Request
`GET /coin/:hash/:index`

### URL Parameters
Parameter | Description
--------- | -----------
:hash     | Hash of tx
:index    | Output's index in tx

## Get coins by address

```javascript
let address;
```

```shell--vars
address='rs1qpu06wprkwleh579mureghcasjhu9uwge6pltn5';
```

```shell--curl
curl http://x:api-key@<IP_ADDRESS>:14037/coin/address/$address
```

```shell--cli
hsd-cli coin $address
```

```javascript
const {NodeClient} = require('hs-client');
const {Network} = require('hsd');
const network = Network.get('regtest');

const clientOptions = {
  port: network.rpcPort,
  apiKey: 'api-key'
}

const client = new NodeClient(clientOptions);

(async () => {
  const result = await client.getCoinsByAddress(address);
  console.log(result);
})();
```

> The above command returns JSON structured like this:

```json
[
  {
    "version": 0,
    "height": 69,
    "value":<PHONE_NUMBER>,
    "address": "rs1qpu06wprkwleh579mureghcasjhu9uwge6pltn5",
    "covenant": {
      "type": 0,
      "action": "NONE",
      "items": []
    },
    "coinbase": true,
    "hash": "fcc1f0656b5e6a0856abf21424579b87c30bc30b89a3c3925923052cb636d80b",
    "index": 0
  },
  {
    "version": 0,
    "height": 74,
    "value":<PHONE_NUMBER>,
    "address": "rs1qpu06wprkwleh579mureghcasjhu9uwge6pltn5",
    "covenant": {
      "type": 0,
      "action": "NONE",
      "items": []
    },
    "coinbase": true,
    "hash": "ffaab95b75c3db650191920a69915e480ced19a8f58cba867382fc8163654299",
    "index": 0
  }
]
```

Get coin objects array by address.

### HTTP Request
`GET /coin/address/:address`

### URL Parameters
Parameter | Description
--------- | -----------
:address  | handshake address

## Get coins by addresses

WARNING: this API call is being considered for deprecation. It is known to cause
node lockup, due to CPU exhaustion, if there are a large number of addresses queried
or a large number of results found.

```javascript
let address0, address1;
```

```shell--vars
address0='rs1qpu06wprkwleh579mureghcasjhu9uwge6pltn5';
address1='rs1qcxuurryemelaj64k6rswn8x9aa8nd9nafa47ag';
```

```shell--curl
curl http://x:api-key@<IP_ADDRESS>:14037/coin/address \
  -H 'Content-Type: application/json' \
  -X POST \
  --data '{ "addresses":[ "'$address0'", "'$address1'" ]}'
```

```shell--cli
No CLI Option.
```

```javascript
const {NodeClient} = require('hs-client');
const {Network} = require('hsd');
const network = Network.get('regtest');

const clientOptions = {
  port: network.rpcPort,
  apiKey: 'api-key'
}

const client = new NodeClient(clientOptions);

(async () => {
  const result = await client.getCoinsByAddresses([address0, address1]);
  console.log(result);
})().catch((err) => {
  console.error(err.stack);
});
```

> The above command returns JSON structured like this:

```json
[
  {
    "version": 0,
    "height": 69,
    "value":<PHONE_NUMBER>,
    "address": "rs1qcxuurryemelaj64k6rswn8x9aa8nd9nafa47ag",
    "covenant": {
      "type": 0,
      "action": "NONE",
      "items": []
    },
    "coinbase": true,
    "hash": "fcc1f0656b5e6a0856abf21424579b87c30bc30b89a3c3925923052cb636d80b",
    "index": 0
  },
  {
    "version": 0,
    "height": 74,
    "value":<PHONE_NUMBER>,
    "address": "rs1qpu06wprkwleh579mureghcasjhu9uwge6pltn5",
    "covenant": {
      "type": 0,
      "action": "NONE",
      "items": []
    },
    "coinbase": true,
    "hash": "ffaab95b75c3db650191920a69915e480ced19a8f58cba867382fc8163654299",
    "index": 0
  }
]
```

Get coins by addresses, returns array of coin objects.

### HTTP Request
`POST /coin/address`

### POST Parameters (JSON)
Parameter | Description
--------- | -----------
addresses | List of handshake addresses

gha_language: JavaScript