text:
# Little Chen Bot

Telegram bot that allows you to fetch images using iqdb and google.

## Dependencies

`libwebp` — Allows to convert WebP images to PNG.
`imagemagick` — Allows to transform and create images.
`fonts-roboto` — Font for images.
`nodejs` — Tokenless Google Translate.
`ffmpeg` — For audio converting.

## Building and Running

Run `sbt run` to run bot and `sbt proguard:proguard` to build a standalone jar file.

### Build Configuration

Build configuration is stored in `build.conf`.

Available properties:

* `solib.os` — List of supported OS (list of String values)
* `solib.arch` — List of supported architectures (list of String values)

With both `solib.os` and `solid.arch` properties provided, the final jar file will contain only `*.so` libraries for specified OS and architectures.

Example configuration:

```properties
solib {
    os = [
        "Linux"
    ]
    arch = [
        "x86_64",
        "armv7"
    ]
}
```

## Configuration

You should create `littlechenbot.conf` in the project directory.

Available properties:

* `bot.token` — Telegram API token (`String`, required)
* `bot.owner` — Bot owner ID to log errors (`Long`)
* `bot.workspace` — Chat ID for bot's internal storage (`Long`)
* `bot.chats` — List of allowed chats (list of `(id: Long, alias: String)`)
* `bot.chatsAnyPrivate` — Allows to reply to all private chats (`Boolean`)
* `bot.chatsAnyGroup` — Allows to reply to all group chats (`Boolean`)
* `bot.proxy.host` — Proxy host (`String`)
* `bot.proxy.port` — Proxy port (`Int`)
* `bot.proxy.type` — Proxy type: http, socks, direct (`String`)
* `bot.proxy.restart` — Command to restart proxy (list of `String`)
* `bot.proxy.whitelist` — Proxy will not be used for these hosts (list of `String`)
* `bot.binaries.dwebp` — Path to WebP decompresser binary (`String`)
* `bot.binaries.ffmpeg` — Path to FFmpeg binary (`String`)
* `bot.binaries.magick` — Path to ImageMagick binary (`String`)
* `bot.binaries.node` — Path to Node.js binary (`String`)

A `bot.workspace` parameter allows to save some data using chat messages. A special chat should be created for a bot where it will send messages and obtain them later. It's possible in Telegtam to create a group and leave it then leaving only a bot in the chat.

Example configuration:

```properties
bot {
    token = "385946732:Jsi19If0si1_dj8AojOS9N5dhsJc8jJ7S98"
    chatsAnyPrivate = true
    chats = [
        {
            id =<PHONE_NUMBER>5,
            alias = "chat1"
        },
        {
            id = -4759243795,
            alias = "chat2"
        }
    ]
    proxy = {
        host = "localhost"
        port = 9050
        type = "socks"
        restart = [ "/usr/bin/systemctl" "restart" "tor" ]
    }
}
```

repository: kitsunyan/Little-Chen-Bot

repo_name: kitsunyan/Little-Chen-Bot


text:
# piDisplay
2 Digit, 7 Segment LED Display Controller Software for the Raspberry Pi. A module for Node.js.

This is a beta version of piDisplay. Everything works correctly as is, but I plan on updating it with a lot more features in the coming weeks and months. This module can display numbers and some letters on a 7 segment, 2 digit LED display that is connected to a Raspberry Pi.

# Sample Images

## Scrolling Text Across Display
![Scrolling Text Across Display](https://monoclecollective.com/projects/pi-display/hotlink-ok/scroller.gif "Scrolling Text Across Display")

## Counting Up on the Display
![Counting Up on the Display](https://monoclecollective.com/projects/pi-display/hotlink-ok/countup.gif "Counting Up on the Display")

## Counting Down on the Display
![Counting Down on the Display](https://monoclecollective.com/projects/pi-display/hotlink-ok/countdown.gif "Counting Down on the Display")

# Pin Layout/Configuration

The model of LED display I am using is a Kingbright DA03-11GWA, and the pinout is shown in the image below. For the full tech sheet, [see here](http://www.kingbrightusa.com/images/catalog/SPEC/DA03-11GWA.pdf).
![LED Display Pin Layout](https://monoclecollective.com/projects/pi-display/hotlink-ok/pin-layout.png "LED Display Pin Layout")

As you can see the display uses two pins for common cathodes, seven pins for the LEDs themselves, and pin 2 is not connected. If you do not have the same display, that's fine, just be sure it's common cathode and not common anode, and that it has two common cathode pins and seven pins for the LED segments of the digits. You'll also need to remap the pins manually if your different display does not match the pinout of the display above.

This is how the display's pins are mapped out on the R-Pi's GPIO pins. There wasn't much rhyme or reason to this, and you can feel free to change the defaults if you would like, which I will detail below. All pins are listed by their physical pin number.

| LED Pin | R-Pi Pin |
| ------- | -------- |
| 5 | 13 |
| 10 | 15 |
| 9 | 18 |
| 7 | 19 |
| 1 | 21 |
| 8 | 22 |
| 3 | 23 |
| 6 | 24 |
| 4 | 26 |

# Installation

```
npm install pi-display
```

Need help with installation? [See here](https://www.npmjs.com/package/pi-display/tutorial).

# Usage

```javascript
// Don't forget the extra parentheses to call the constructor function!
var piDisplay = require("pi-display")();

// Displays E7 on the LED display.
piDisplay.displayChars("E7");

// Displays 85.
piDisplay.displayChars(85);

// Scrolls the given string across the display. It looks more natural to scroll
// if you have spaces at either end of the string, but they are not mandatory.
// The second argument is the milliseconds to display each character.
piDisplay.scrollChars(" HI HELLO<PHONE_NUMBER> ", 400);
```

# API

## Methods

| Method | Argument(s) | Description |
| ------ | --------- | ----------- |
| `constructor()` | `object` ledPins, `object` cathodePins | Used to construct the piDisplay object. Pass in two objects as described in the properties section. Both arguments are optional. See properties for more information. |
| `displayChars()` | `string`\|`number` chars | Displays one to two static characters on the display. Accepts a string or number (0 to 99). Can be updated very rapidly (without needing to use the `clearDisplay()` method) in a loop or through some other means. |
| `scrollChars()` | `string` sentence, `number` speed | Displays the given sentence in a scrolling style across the LED display, moving one character at a time. The scrolling speed is specified in milliseconds. If no speed is specified, the default `400` is used. |
| `count()` | `string` upOrDown, `number` speed | Counts one-by-one either up or down on the display from 0 to 99. Use the string `'up'` or `'down'` to specify if the method should count up or down. The speed at which each new number is displayed is specified in milliseconds. If no speed is specified, the default `200` is used. |
| `clearDisplay()` | none | Completely clears the display (turns off all the LEDs) and stops any method that is currently executing. |

## Properties

These properties can only be reassigned at startup. See constructor method for more information.

| Property | Default Value | Description |
| -------- | ------------- | ----------- |
| `ledPins` | `object` {"top": 23, "topLeft": 26, "topRight": 18, "middle": 21, "bottomLeft": 19, "bottomRight": 22, "bottom": 24} | Which physical pin number is matched to which segment of the LED. |
| `cathodePins` | `object` {"digitOne": 15, "digitTwo": 13} | The physical pin that controls which digit is turned off when set to HIGH. |

# Credits

I'd like to give a huge thanks to drogon for his excellent [Wiring Pi](http://wiringpi.com/) library, Soarez for making the [original Node.js bindings](https://github.com/Soarez/node-wiring-pi) for Wiring Pi, and eugeneware for enhancing Soarez's work on the [newer Node.js bindings](https://github.com/eugeneware/wiring-pi).

license: MIT

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
Each round, the plant should grow a certain amount (or fail to grow).

## Application should have:
- `Plant` class has methods for allowing the plant to grow.

- There are `Water()`, `Feed()` and `GiveSunshine()` methods to grow and make your plant happy.

- There are `NoSun()`, `Windstorm()`, `WeedsGrow()` and `EatPlant()` methods, which cause a trouble for your plant.

- A trouble event happens randomly but every time you take care of your plant.

- It's sad but when `EatPlant()` method is called, the game will be over.

## Setup/Installation Requirements

1. Clone this repo:
```
$ git clone https://github.com/misakimichy/grow-your-plant.git
```

2. Go into the repo and run this application:
```
$ dotnet run
```

## Known Bugs
* No known bugs at this time.

## Support and contact details
<EMAIL_ADDRESS>
## Technologies Used
_Git, GitHub, C# and .NET Core

## License
Copyright © 2019 under the MIT License

repository: misakimichy/grow-your-plant

repo_name: misakimichy/grow-your-plant


text:
# MTASA MAP IMAGES
Map images were made using orthographic projection matrix.

## Resolution
- 1024px, 1536px, 2048px, 4096px, 8192px, 10240px, 20480px

**Recommended for making an in-game minimap: 2048px or less**

## Maps
### Default
- Daytime, with shadows.

![Default map](https://i.imgur.com/dAV1yEf.jpg)

### Noshadow
- Daytime, without shadows.

![Noshadow map](https://i.imgur.com/OD2vR66.jpg)

### Night
- Nighttime, with shadows.

![Night map](https://i.imgur.com/jE2bwoA.jpg)

repository: Niventill/mtasa-map-images

repo_name: Niventill/mtasa-map-images


text:
# Make a program that has a function called write(), which takes any text as a parameter and displays a message with adaptable size.

Ex:
write('Hello, World!')
Output:
~~~ ~~~~~~
 Hello World!
~~~~~~~~~

## Example in Python

### code

``` python
[put your code here]
```

### output

```
[put the output of your code here]
```

## Next

- [Example in python 096](../../096/python)
- **Example in python 097**
- [Example in python 098](../../098/python)
- [List of exercises](../..)


text:
Pattern: Use of `Kernel#open`

Issue: -

## Description

`Kernel#open` enables not only file access but also process invocation by prefixing a pipe symbol (e.g., `open("| ls")`).  It may lead to
a serious security risk by using variable input to the argument of `Kernel#open`. It would be better to use `File.open` or `IO.popen`
explicitly.

## Examples

```ruby
# bad
open(something)

# good
File.open(something)
IO.popen(something)
```

## Further Reading

* [RuboCop - Security/Open](https://docs.rubocop.org/rubocop/cops_security.html#securityopen)

repository: Adroiti/docs-for-code-review-tools

repo_name: Adroiti/docs-for-code-review-tools


text:
# Simple-Fretchet-and-Hausdorff-Distance-measure-for-timeseries-data-in-Java

There were no good tools for this online so I decided to create them.  The reason I needed these functions was to use them with timeseries data and these functions reflect that.  It should be fairly straight forward to make these functions more dynamic to process traditional data structured in cartisan coordinates and if you need help with that then drop me a line.

A simple use case has been proved in the main class.

The calculation for Hausdorff distance is:

![Hausdorff Distance](https://github.com/bertmiller/Simple-Fretchet-and-Hausdorff-Distance-measure-for-timeseries-data-in-Java/blob/master/HausdorffDistanceCalculation.png)

The calculation for Fretchet Distance is:

![Fretchet Distance](https://github.com/bertmiller/Simple-Fretchet-and-Hausdorff-Distance-measure-for-timeseries-data-in-Java/blob/master/FretchetDistanceCalculation.png)

Read more about Hausdorff distance and Fretchet distance below:
https://en.wikipedia.org/wiki/Hausdorff_distance

https://en.wikipedia.org/wiki/Fr%C3%A9chet_distance


text:
{
  "shortTitle": "State Senator",
  "title": "Maryland State Senator",
  "type": "primary-list",
  "districts": 47,
  "slug": "state-senate",
  "weight": 6,
  "showDistrictsTable": true,
  "mapFile": "/json/senatorial-districts.json"
}

The Maryland State Senate has 47 districts, each represented by a single state senator. To see the candidates running in your district, select the appropriate link below. To find out what district you live in, click the search icon in the map below and enter your address or visit the Maryland State Archives [district finder][el].

[el]: http://mdelect.net

gha_language: JavaScript


text:
This is a project implementing the network model of of electrically coupled cerebellar Golgi cells, as described in Vervaeke et al.
**Rapid Desynchronization of an Electrically Coupled Interneuron Network
with Sparse Excitatory Synaptic Input**, [Neuron 2010](http://www.sciencedirect.com/science/article/pii/S089662731000512X).

See http://www.opensourcebrain.org/projects/vervaekeetalgolgicellnetwork
for more details.

![2cells](https://raw.githubusercontent.com/OpenSourceBrain/VervaekeEtAl-GolgiCellNetwork/master/neuroConstruct/images/medium.png)

The Golgi cell model is based on the abstract cell model in [Solinas et al., Frontiers in Neuroscience 2007](http://www.opensourcebrain.org/projects/4).

[![Continuous build using OMV](https://github.com/OpenSourceBrain/VervaekeEtAl-GolgiCellNetwork/actions/workflows/omv-ci.yml/badge.svg)](https://github.com/OpenSourceBrain/VervaekeEtAl-GolgiCellNetwork/actions/workflows/omv-ci.yml)

[![DOI](https://www.zenodo.org/badge/4960822.svg)](https://www.zenodo.org/badge/latestdoi/4960822)

### Reusing this model

The code in this repository is provided under the terms of the [software license](LICENSE) included with it. If you use this model in your research, we respectfully ask you to cite the references outlined in the [CITATION](CITATION.md) file.


text:
---
data:
  title: "Documentation & Guides"
  description: Welcome to drift's documentation. This site shows you what drift can do and how to use it.
template: layouts/docs/list
---

## Welcome to drift

Drift is a reactive persistence library for Dart and Flutter applications. It's built on top
of database libraries like [the sqlite3 package](https://pub.dev/packages/sqlite3), [sqflite](https://pub.dev/packages/sqflite) or [sql.js](https://github.com/sql-js/sql.js/)
and provides additional features, like:

- __Type safety__: Instead of writing sql queries manually and parsing the `List<Map<String, dynamic>>` that they
return, drift turns rows into objects of your choice.
- __Stream queries__: Drift lets you "watch" your queries with zero additional effort. Any query can be turned into
 an auto-updating stream that emits new items when the underlying data changes.
- __Fluent queries__: Drift generates a Dart api that you can use to write queries and automatically get their results.
 Keep an updated list of all users with `select(users).watch()`. That's it! No sql to write, no rows to parse.
- __Typesafe sql__: If you prefer to write sql, that's fine! Drift has an sql parser and analyzer built in. It can parse
  your queries at compile time, figure out what columns they're going to return and generate Dart code to represent your
  rows.
- __Migration utils__: Drift makes writing migrations easier thanks to utility functions like `.createAllTables()`.
 You don't need to manually write your `CREATE TABLE` statements and keep them updated.

And much more! Drift validates data before inserting it, so you can get helpful error messages instead of just an
sql error code. Of course, it supports transactions. And DAOs. And efficient batched insert statements. The list goes on.

Check out these in-depth articles to learn about drift and how to use its features.

repository: rodydavis/moor

gha_language: Dart

gha_license_id: MIT

repo_name: rodydavis/moor


text:
# TerraformDeploy_Aws

Repo designed to display basic understanding of Infrastructure as Code (IaC) using Terraform to deploy EC2 resources on AWS Cloud.

## Comands:

terraform init

terraform plan

terraform apply

terraform destroy

branch_name: refs/heads/main


text:
# Game of Life

[Conway's Game of Life](https://en.wikipedia.org/wiki/Conway%27s_Game_of_Life) in C++ built on top of the [Raylib](https://www.raylib.com/) library.

## Installation

- VS 2019 or higher
- `raylib` library

repository: martycagas/game-of-life

repo_name: martycagas/game-of-life


text:
Note-O-Rama 🎉

  ![badge](https://img.shields.io/badge/license-ISC-brightgreen)

  ## 👇  Description  👇
---

  A simple note-taking application using nodejs leveraging express as server-side.

  ## Table of Contents
  - [Description](#--description--)
  - [Installation Instructions 📣](#installation-instructions-)
  - [Usage 🖱](#usage-)
  - [Contributors 🧑🤝🧑](#contributors-)
  - [Screenshots 📷](#screenshots-)
  - [Questions ❔](#questions-)
  - [License ©](#license-)

  ## Installation Instructions 📣
---

  Clone the repo if you want.  If you do so, navigate to the local repo directory and run ```npm install``` in the terminal to install dependencies.

  ## Usage 🖱
---

*You can simply go try out the app [HERE](https://gentle-sierra-10975.herokuapp.com/) !!*
```

https://gentle-sierra-10975.herokuapp.com/

```

  Take Notes. Upon saving them, they will be sent to the server and stored for later. There is no login so kinda seems like you would only use this for educational purposes.

  ### More Specifically

1. Open Terminal and run
   ```
   node server.js
   ```

2. Open web browser and navigate to localhost:3000 (or <IP_ADDRESS>:3000)
3. Click "Get Started"
4. Give the note a title and a body, then  in the rop right corner.
5. To create a new note, click on the  icon
6. View your notes on the left-hand side.
7. Click the red  to delete the note

  ## Contributors 🧑🤝🧑
---
  Peter Roto

  ## Screenshots 📷
---

  |  Desktop Welcome                                       | Note Taking Initial Screen                             | Note Taking Mid Note                                   | Mobile (Responsiveness)                               |
  |:------------------------------------------------------:|:------------------------------------------------------:|:------------------------------------------------------:|:-----------------------------------------------------:|
  |  ||||
  |                                                        |                                                        |                                                        |                                                       |
  |                                                        |                                                        |                                                        |                                                       |

  ## Questions ❔

---

  You can email me if you REALLY want to, or submit an issue to this repo.

  :octocat: Find me on GitHub: [PROTO133](https://github.com/PROTO133)

  📬 Email me with any questions<EMAIL_ADDRESS>/>

  ## License ![badge](https://img.shields.io/badge/license-ISC-brightgreen)
---

  This application is covered by  the ISC License license.

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

  This README was generated with [writemeREADME](https://github.com/proto133/writemeREADME)


text:
# pykssm
*Copyright (c) 2016, Angelo Falchetti*

Simple and flexible library to do kernel state-space modelling (KSSM).

This technique allows the user to estimate the transition function of
a nonlinear state-space model without supervision, i.e. only by looking
at the output observations of the system, with no access to the internal
state; using an appropriate parametrization in the reproducing kernel
hilbert space.

Based on the work of Tobar, Djurić and Mandic, "Unsupervised State-Space
Modelling Using Reproducing Kernels", IEEE Transactions in Signal Processing,
2015.
If you've found the code useful for your own work, please cite the paper.

repository: afalchetti/pykssm

repo_name: afalchetti/pykssm


text:
# Core

The Core class is inherited by all other classes within `py-ews`.  This class controls logging as well as parsing of EWS SOAP request responses.

```eval_rst
.. autoclass:: pyews.core.core.Core
   :members:
   :undoc-members:
```

repository: swimlane/pyews

gha_language: Python

repo_name: swimlane/pyews


text:
---
title: "Deepstream maintenance mode"
description: Deepstream is entering maintenance mode
blogImage: /images/elton/elton-crying.png
---

I have some sad news to share today. After joining deepstream around 5 years ago I'm stepping down as the active core maintainer. Given there hasn't been any other core contributors for the last couple of years this means deepstream as a project will be purely reliant on community activity to stay up to date and for bug fixes.

The reason why I decided to make this statement instead of just quietly stopping my involvement is because adopting core stack technology is an expensive and difficult process, and I would rather have potential adopters have a clear indication about the current state of the project when making that decision. I have spent the last few months gathering information, mainly via trying to [assess the usage of this project in the wider world](https://github.com/deepstreamIO/deepstream.io/issues/1049) and [contribution callouts](https://github.com/deepstreamIO/deepstream.io/issues/1030), both with very limited results.

I will still be merging in PRs and doing releases, however I will no longer be active within the communication channels or github issues, fixing bugs or answering questions. Will contain my activity to just making sure fixes can find their way in while the deepstream community figures out how to move forward.

If your interested in owning part of this project please let me know via github.

Contributors willing to do the following will help this project progress forward:

- Improve documentation. Either adding guides, tutorials or fixing issues.
- Improve the website itself. It's in react and gatsby.
- Own and improve connectors and plugins. They are minimal in code but keeping track of dependencies and testing against latest versions of the database and caches is required for security and to remain relevant.
- SDKs
- Custom plugins
- Most importantly, [stating your using deepstream](https://forms.gle/8mtPrGe1y5q3KweR7). The more users we can publicly say we have the more likely people will contribute.

I would like to use this opportunity to thank everyone for their time and effort adopting deepstream, and for the huge support we had during our deepstreamHub era. This was quite the journey, and I really hope to see realtime techs boundries push on going forwards.

gha_language: TypeScript


text:
---
hrs_structure:
  division: '1'
  volume: '4'
  title: '13'
  chapter: 201H
  section: 201H-16
type: hrs_section
tags:
  - Government
menu:
  hrs:
    identifier: HRS_0201H-0016
    parent: HRS0201H
    name: 201H-16 Administration of federal programs
weight: 12085
title: Administration of federal programs
full_title: 201H-16 Administration of federal programs
---
**[§201H-16] Administration of federal programs.** (a) The corporation may carry out federal programs designated to be carried out by a housing finance or housing development entity.

(b) The corporation shall adopt necessary rules in accordance with chapter 91, including the establishment and collection of reasonable fees for administering the program, to carry out any federal program in subsection (a).

(c) All fees collected for administering the program may be deposited into an appropriate special fund of the corporation and may be used to cover the administrative expenses of the corporation. [L 2005, c 196, pt of §20; am L 2006, c 180, §15]

repository: SamMade/BlueAndKrabby

repo_name: SamMade/BlueAndKrabby


text:
## zipkin Docker images
This directory contains assets used to build and release Zipkin's Docker images.

## Production images
The only Zipkin production images built here:
* openzipkin/zipkin: The core server image that hosts the Zipkin UI, Api and Collector features.
  * Mirrored as ghcr.io/openzipkin/zipkin
* openzipkin/zipkin-slim: The stripped server image that hosts the Zipkin UI and Api features, but only supports in-memory or Elasticsearch storage with HTTP or gRPC span collectors.
  * Mirrored as ghcr.io/openzipkin/zipkin-slim

## Testing images

We also provide a number images that are not for production, rather to simplify demos and
integration tests. We designed these to be small and start easily. We did this by re-using the same
base layer `openzipkin/zipkin`, and setting up schema where relevant.

* [ghcr.io/openzipkin/zipkin-cassandra](test-images/zipkin-cassandra/README.md) - runs Cassandra initialized with Zipkin's schema
* [ghcr.io/openzipkin/zipkin-elasticsearch6](test-images/zipkin-elasticsearch6/README.md) - runs Elasticsearch 6.x
* [ghcr.io/openzipkin/zipkin-elasticsearch7](test-images/zipkin-elasticsearch7/README.md) - runs Elasticsearch 7.x
* [ghcr.io/openzipkin/zipkin-kafka](test-images/zipkin-kafka/README.md) - runs both Kafka+ZooKeeper
* [ghcr.io/openzipkin/zipkin-mysql](test-images/zipkin-mysql/README.md) - runs MySQL initialized with Zipkin's schema
* [ghcr.io/openzipkin/zipkin-ui](test-images/zipkin-ui/README.md) - serves the (Lens) UI directly with NGINX

## Getting started

Zipkin has no dependencies, for example you can run an in-memory zipkin server like so:

```bash
# Note: this is mirrored as ghcr.io/openzipkin/zipkin-slim
$ docker run -d -p 9411:9411 openzipkin/zipkin-slim
```

See the ui at (docker ip):9411

In the UI - click zipkin-server, then click "Find Traces".

We also provide [example compose files](examples/README.md) that integrate collectors and storage,
such as Kafka or Elasticsearch.

## Configuration
Configuration is via environment variables, defined by [zipkin-server](https://github.com/openzipkin/zipkin/blob/master/zipkin-server/README.md). Notably, you'll want to look at the `STORAGE_TYPE` environment variables, which
include "cassandra", "mysql" and "elasticsearch".

Note: the `openzipkin/zipkin-slim` image only supports "elasticsearch" storage. To use other storage types, you must use the main image `openzipkin/zipkin`.

When in Docker, the following environment variables also apply

* `JAVA_OPTS`: Use to set java arguments, such as heap size or trust store location.
  * By default, `openzipkin/zipkin` sets max heap to 64m while `openzipkin/zipkin-slim` 32m
* `STORAGE_PORT_9042_TCP_ADDR` -- A Cassandra node listening on port 9042. This
  environment variable is typically set by linking a container running
  `zipkin-cassandra` as "storage" when you start the container.
* `STORAGE_PORT_3306_TCP_ADDR` -- A MySQL node listening on port 3306. This
  environment variable is typically set by linking a container running
  `zipkin-mysql` as "storage" when you start the container.
* `STORAGE_PORT_9200_TCP_ADDR` -- An Elasticsearch node listening on port 9200. This
  environment variable is typically set by linking a container running
  `zipkin-elasticsearch` as "storage" when you start the container. This is ignored
  when `ES_HOSTS` or `ES_AWS_DOMAIN` are set.
* `KAFKA_PORT_2181_TCP_ADDR` -- A zookeeper node listening on port 2181. This
  environment variable is typically set by linking a container running
  `zipkin-kafka` as "kafka" when you start the container.

For example, to increase heap size, set `JAVA_OPTS` as shown in our [docker-compose](examples/docker-compose.yml) file:
```yaml
    environment:
      - JAVA_OPTS=-Xms128m -Xmx128m -XX:+ExitOnOutOfMemoryError
```

For example, to add debug logging, set `command` as shown in our [docker-compose](examples/docker-compose.yml) file:
```yaml
    command: --logging.level.zipkin2=DEBUG
```

## Runtime user
The `openzipkin/zipkin` and `openzipkin/zipkin-slim` images run under a nologin
user named 'zipkin' with a home directory of '/zipkin'. As this is Alpine Linux
image, you won't find many utilities installed, but you can browse contents
with a shell like below:

```bash
$ docker run -it --rm --entrypoint /bin/sh openzipkin/zipkin
/zipkin $ ls
BOOT-INF  META-INF  org       run.sh
```

## Notes

### Container links
If using Docker's deprecated container links, you need to set env variables
accordingly.

Ex. If your link name is "storage" for an Elasticsearch container:
```
  ES_HOSTS=http://$STORAGE_PORT_9200_TCP_ADDR:9200
```

The above is mentioned only for historical reasons. The OpenZipkin community
do not support Docker's deprecated container links.

### MySQL
If using an external MySQL server or image, ensure schema and other parameters match the [docs](https://github.com/openzipkin/zipkin/tree/master/zipkin-storage/mysql-v1#applying-the-schema).

## Building images

To build `openzipkin/zipkin:test`, from the top-level of the repository, run:
```bash
$ build-bin/docker/docker_build openzipkin/zipkin:test
```

If you want the slim distribution (openzipkin/zipkin-slim:test), run:
```bash
$ DOCKER_TARGET=zipkin-slim build-bin/docker/docker_build openzipkin/zipkin-slim:test
```

repository: lwllvyb/zipkin

gha_language: Java

repo_name: lwllvyb/zipkin


text:
# Graphis sundarbanensis Jagadeesh & G. P. Sinha SPECIES

#### Status
ACCEPTED

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

#### Published in
in Jagadeesh Ram, Sinha & Singh, Lichenologist 39(3): 231 (2007)

#### Original name
Graphis sundarbanensis Jagadeesh & G. P. Sinha

### Remarks
null

repository: mdoering/backbone

repo_name: mdoering/backbone


text:
---
title: Carl Fisher charters the City
tags:
  - Dec 1920
---

Carl Fisher charters the City of Miami for a "stag" party of big shots.

Newspapers: **Daily Miami Metropolis, The Miami Metropolis (daily), The Daily Metropolis or Miami Daily Metropolis**

Page: **1**, Section: **B**


text:
# MLP_Ball

I've created this project using Unity3D. My motivation was to study about Machine Learning, after about 2 weeks of learning the essential mathematics, and a week of reading about Multi Layer Perceptrons, this project came to life.

## What's This About

My goal with this project was to write a Neural Network, that will tilt the plane, so that the ball will move towards the green square, in the center of that plane. The NN input layer receives the X/Z coordinates of the red ball, and X/Z coordinates of the green square, and in return, in the output layer, we receive X/Z rotation of the plane.

## How To Even...

In this section, I'll guide you through the process of setting up this project, so you can view it for yourself.

### Prerequisites

To open this project, it's required of you to have Unity3D installed.

* [Unity3D](https://store.unity.com/) ver. 2018.1.6f1 preferably, although it should work on a newer version.

In order to use Unity3D, you need to register your account with them.

### Installing

* Start off by downloading, and installing Unity3D from the link above.
* While Unity3D is installing, download the project by clicking the green "Clone or download" button, and select "Download Zip".
* Open up Unity3D when it's done installing, and log into your account.
* After that click on "Open" button, and navigate to where the "Machines gotta learn" folder is, select it, and click "Select folder" button to open project.

### Post Installation

After you're done with the installation process, if all you see under "Hierarchy" window is "Directional Light" and "Main Camera", don't panic. In the "Project" window, navigate to Assets > Scenes, and double click the "GameScene.unity". Now you should be able to just press the "Play" button, and play with the project in game window.

## License

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

## Acknowledgments

* To shuffle a list i've used an algorithm found in this [Archive](https://web.archive.org/web/20150801085341/http://blog.thijssen.ch/2010/02/when-random-is-too-consistent.html).
* Propably not the best task for a simple MLP, but hey, it works.

gha_language: C#


text:
---
layout: default
---

# 1994-04-30 - Different remailer software

## Header Data

From: Urban Nilsson<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: 411e5971d26956737da5203b5610ad874ea4412b7cb3e39eeea7445c0b1b2bc8

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1994-04-30 06:20:58 UTC

Raw Date: Fri, 29 Apr 94 23:20:58 PDT

## Raw message

```
{% raw  %}From: Urban Nilsson<EMAIL_ADDRESS>Date: Fri, 29 Apr 94 23:20:58 PDT
To<EMAIL_ADDRESS>Subject: Different remailer software
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

I've just taken a quick look at soda.berkeley.edu's remailers.
There's several of them, and if I'm now to install one of them,
what are their strengths/weaknesses? Should I choose hal's
remailer? Or maybe Nate's? Or hh-remailer? Sameer's anon-
remailer? The INDEX file doesn't say anything about what
differs one remailer from the next, just who wrote it...
Help me out, please!

Urban Nilsson                     | Use 'finger' for PGP2.3a public key.
<EMAIL_ADDRESS>        |-------------------------------------
Chalmers University of Technology |A person is just as big as the things
Gothenburg, Sweden                |that makes him angry.

{% endraw %}
```

## Thread

+ Return to [April 1994](/archive/1994/04)

+ Return to "[Sameer <sameer@soda.berkeley.edu>](/authors/sameer_sameer_at_soda_berkeley_edu_)"
+ Return to "[Urban Nilsson <d7urban@dtek.chalmers.se>](/authors/urban_nilsson_d7urban_at_dtek_chalmers_se_)"

+ 1994-04-30 (Fri, 29 Apr 94 23:20:58 PDT) - Different remailer software - _Urban Nilsson<EMAIL_ADDRESS>  + 1994-04-30 (Sat, 30 Apr 94 00:45:13 PDT) - [Re: Different remailer software](/archive/1994/04/5c171f9c74bf6b79e1b466583be07e5943d43713b6a0ad680b9aab6eab18e38f) - _Sameer<EMAIL_ADDRESS>


text:
## note
This is for osm_base which projection is 3857

#

```console
node index.js
```16-produce-osm
Trial with prototype16 code (produce)

## install
```console
git clone git@github.com:ubukawa/16-produce-osm
cd 16-produce-osm
npm install
cat config/example.hjson
vi config/default.hjson
```

## run
```console
node index.js
```

license: Unlicense


text:
# Kubernets Config Selector

When you have a lot of Kubernets clusters, manage configs files is a hard task. This tool will help you change between these files easier.

# Requirements

To execute que k8s-config-selector, please install Python libraries using the following command:

```bash
pip3 install --user -r ./requirements.txt
```

# Running

To make easier to run, it's recommended create a symbolic to /usr/local/bin. After that, you just need type the command without parameters.

```bash
sudo ln -sf ./k8s-config-selector /usr/local/bin/k8s-config-selector
k8s-config-selector
```

repository: hpettenuci/operation

gha_language: Shell

repo_name: hpettenuci/operation


text:
[![npm version](https://badge.fury.io/js/react-flow-editor.svg)](https://badge.fury.io/js/react-flow-editor)
[![Downloads](https://img.shields.io/npm/dt/react-flow-editor.svg)](https://www.npmjs.com/package/react-flow-editor)
[![GitHub issues](https://img.shields.io/github/issues/lochbrunner/react-flow-editor.svg)](https://github.com/lochbrunner/react-flow-editor/issues)
![David](https://img.shields.io/david/lochbrunner/react-flow-editor.svg)
![David](https://img.shields.io/david/dev/lochbrunner/react-flow-editor.svg)
![lib](https://github.com/lochbrunner/react-flow-editor/workflows/lib/badge.svg)
![examples](https://github.com/lochbrunner/react-flow-editor/workflows/examples/badge.svg)

# Graph editor

An ui library for creating flow based editors with react and typescript/javascript.

![Screen Video](./docs/screen.gif)

Try the [demo](https://lochbrunner.github.io/react-flow-editor/simple) in your browser.

If you are interested in *redux* dive into the [example](./example/redux/) or try the more advanced [demo](https://lochbrunner.github.io/react-flow-editor/redux/index.html).

## Getting started

```typescript
import * as ReactDOM from 'react-dom';
import { Editor, Node, Config} from 'react-flow-editor';

// Create the initial graph
const nodes: Node[] = [
    {
        id: 'Node 1',
        name: 'First Node',
        payload: { h1: 'hello' },
        inputs: [{
            connection: [], name: 'input 1'
        }],
        outputs: []
}];

// Renders the body of each node
function resolver(data: any): JSX.Element {
    if (data.type === '') return <h2 />;
    return (
        <p>{data.payload.h1}</p>
    );
}

const config: Config = {
    resolver,
    connectionType: 'bezier',
    grid: true,
    demoMode: true,
};

ReactDOM.render(
    <div>
        <Editor config={config} nodes={nodes} />
    </div>,
    document.getElementById('root')
);

```

See [example](./example/) for usage.

## Side effects

* Before creating new nodes, the node under the cursor is a direct child of `document.body`.
* In order to decouple editor and menu components they use `window.onStartCreatingNewNode` to communicate.

## API

### Configuration

The config interface looks as follow

```typescript
export interface Config {
    resolver: (payload: any) => JSX.Element;
    connectionValidator?: (output: { nodeId: string, port: number }, input: { nodeId: string, port: number }) => boolean;
    onChanged?: (node: ChangeAction) => void;
    connectionType?: 'bezier' | 'linear';
    grid?: boolean | { size: number };
    connectionAnchorsLength?: number;
    direction?: 'ew' | 'we';
    demoMode?: boolean;
}
```

| Property                  | Description                                                                                |
| ------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
| `resolver`                | A function returning a React component which gets placed into the node                                                                       |
| `connectionValidator`     | A function which evaluates if a possible connection might be valid or not                                                                    |
| `onChanged`               | A callback which gets called when the flow graph changed                                                                                |
| `connectionType`          | The geometry type of the connection lines between the nodes                                                                                |
| `grid`                    | Specifies if the grid should be rendered or not (Default is `true`). Optional specifies distances between the lines (`size`). Default is 18. |
| `connectionAnchorsLength` | Specifies the langth of the anker when using `bezier` as `connectionType`.                                                                   |
| `direction`               | Specifies the orientation of the input and output ports. Default is `we`.                                                                    |
| `demoMode`                | If this set to true, the Editor takes care of updating the nodes in the props. Be carful using this in production.                           |

### Nodes

A node is specified by the following interface

```typescript
export interface Node {
  name: string;
  type: string;
  id: string;
  inputs: InputPort[];
  outputs: OutputPort[];
  payload?: any;
  position?: Vector2d;
  properties?: {display: 'stacked' | 'only-dots'};
  classNames?: string[];
  style: Style;
}
```

For now `InputPort` and `OutputPort` are identically to the `Port` interface:

```typescript
export interface Port {
  name: string;
  connection?: Connection|Connection[];
  payload?: any;
  renderer?: (connection: Port) => JSX.Element;
}
```

```typescript
export interface Connection {
  nodeId: string;
  port: number;
  classNames?: string[];
  notes?: string;
}
```

### Themes

By default we recommend to import the default theme with

```sass
@import "react-flow-editor/dist/default-theme.scss";
```

But you can change the style of all components by coping that file and adjust its values.

### Postcss support

When using postcss generated class names just forward them with

```ts
import * as style from './style.scss';

// ...

const config: Config = {
    resolver,
    connectionType: 'bezier',
    grid: true,
    demoMode: true,
    direction: 'we',
    style
};
// ...
```

See [Example](./example/postcss).

## Roadmap

* Editing the title of the node
* Grouping nodes (similar to *Blender*)
* Optimize hooking
* Fix zooming and scrolling

## Contributing

This library is very young. So please consider that it might have some bugs, but I will try to fix them, when they get reported.

If you have any problems or miss an important feature:

**Feel free to create a PR or report an issue!**

repository: ryzbaka/react-flow-editor

repo_name: ryzbaka/react-flow-editor


text:
Knight Online Log Reader
==============================
Knight Online client creates log.klg but its encrypted with some algortihm. This simple software simply decodes it and outputs to stdout. It is quite fast.

![](doc.png)

Install
----------------
* install node.js
* type in terminal `npm i ko-klg-reader -g`

Usage
-----------------
* type in terminal `klgread log.klg`

Tips
----------------

You may create decrypted file by simply typing;

```sh
klgread log.klg > log.decrypt.klg
```

repository: javrasya/ko-klg-reader

repo_name: javrasya/ko-klg-reader


text:
[![MIT License][license-shield]][license-url]
[![LinkedIn][linkedin-shield]][linkedin-url]

Currency Converter

    An awesome Currency Converter build in React, that also shows the currency value in Bitcoin.

    Report Bug

  Table of Contents

      About The Project

Built With

      Getting Started

Prerequisites

Installation

Usage

License

Contact

Acknowledgements

## About The Project

There are lots of currency converters out there, yet little that convert your currency to another and bitcoin at the same time.

This project is the result of a code challenge. It does not include full unit-test coverage or performance optimization. Just examples of unit-tests as a confrontation piece.

The design of the project is based on [this dribbble shot](https://dribbble.com/shots/6008455-Platora-Ui-Design/attachments/1291353?mode=media).

### Built With

This project is primarily build with
* [React](https://reactjs.org/)

## Getting Started

To get a local copy up and running follow these simple example steps.

### Prerequisites

This is an example of how to list things you need to use the software and how to install them.
* npm
  ```sh
  npm install npm@latest -g
  ```
* yarn
  ```sh
  npm install yarn -g
  ```

### Installation

1. Get a free API Key at [https://coinlayer.com/](https://coinlayer.com/)
2. Clone the repo
   ```sh
   git clone https://gitlab.com/larsamsterdam/react-currency-converter.git
   ```
3. Install NPM packages
   ```sh
   yarn
   ```
4. Create `.env` file in root and Enter your API KEY in `.env`
   ```TEXT
   REACT_APP_CRYPTO_API_KEY='YOUR ACCESS KEY HERE'
   ```

## Usage

In the project directory, you can run:

### `yarn start`

Runs the app in the development mode.\
Open [http://localhost:3000](http://localhost:3000) to view it in the browser.

The page will reload if you make edits.\
You will also see any lint errors in the console.

### `yarn test`

Launches the test runner in the interactive watch mode.\
See the section about [running tests](https://facebook.github.io/create-react-app/docs/running-tests) for more information.

### `yarn build`

Builds the app for production to the `build` folder.\
It correctly bundles React in production mode and optimizes the build for the best performance.

The build is minified and the filenames include the hashes.\
Your app is ready to be deployed!

## License

Distributed under the MIT License. See `LICENSE` for more information.

## Contact

Lars Straathof - [Lars.Amsterdam](https://lars.amsterdam) -<EMAIL_ADDRESS>
Project Link: [https://gitlab.com/larsamsterdam/react-currency-converter](https://gitlab.com/larsamsterdam/react-currency-converter)

## Acknowledgements
* [Img Shields](https://shields.io)
* [create-react-app](https://create-react-app.dev/)
* [Currency Flags](https://github.com/transferwise/currency-flags)
* [Currency Data](https://gist.github.com/Fluidbyte/2973986)
* [Design Inspiration](https://dribbble.com/shots/6008455-Platora-Ui-Design/attachments/1291353?mode=media)

[license-shield]: https://img.shields.io/github/license/othneildrew/Best-README-Template.svg?style=for-the-badge
[license-url]: https://gitlab.com/larsamsterdam/react-currency-converter/-/blob/master/LICENSE
[linkedin-shield]: https://img.shields.io/badge/-LinkedIn-black.svg?style=for-the-badge&logo=linkedin&colorB=555
[linkedin-url]: https://www.linkedin.com/in/lars-straathof/

repository: lhstraathof/currency-converter

repo_name: lhstraathof/currency-converter


text:
---
title: Hierarchical Data
page_title: FileManager - Data Binding to Hierarchical Data
description: Data Binding the FileManager for Blazor to hierarchical data.
slug: filemanager-data-binding-hierarchical-data
tags: telerik,blazor,filemanager,data,bind,databind,databinding,hierarchical
published: True
position: 2
---

# FileManager Data Binding to Hierarchical Data

This article explains how to bind the FileManager for Blazor to hierarchical data. Before continuing, make sure you are familiar with the [FileManager data binding basics]({%slug filemanager-data-binding-overview%}).

Hierarchical data means that the collection of child items is provided in a field of its parent's model:

* The `Items` field contains a collection of all children icluding sub-folders and files. They will be rendered in the [Preview Pane]({%slug filemanager-preview-pane%}) when the parent folder is selected.

* The `Directories` field contains a collection of the subolders of a directory. They will be rendered in the TreeView navigation pane. If there are `Directories` for a specific folder it will have an expand icon. The `HasDirectories` field can override this, however, but it is not required for hierarchical data binding.

This approach of providing items lets you gather separate collections of data that may even come from different sources.

>caption Example of hierarchical data binding

````CSHTML
@using System.IO

<TelerikFileManager Data="@Data"
                    Height="400px"
                    @bind-Path="@DirectoryPath"
                    IdField="MyModelId"
                    NameField="Name"
                    SizeField="Size"
                    PathField="Path"
                    ExtensionField="Extension"
                    IsDirectoryField="IsDirectory"
                    HasDirectoriesField="HasDirectories"
                    DirectoriesField="MyDirectories"
                    ItemsField="Items"
                    DateCreatedField="DateCreated"
                    DateCreatedUtcField="DateCreatedUtc"
                    DateModifiedField="DateModified"
                    DateModifiedUtcField="DateModifiedUtc"/>

@code {
    public List<HierarchicalFileEntry> Data = new List<HierarchicalFileEntry>();
    public string DirectoryPath { get; set; } = string.Empty;

    // fetch the FileManager data
    protected override async Task OnInitializedAsync()
    {
        Data = await GetHierarchicalFileEntries();
    }

    // a model to bind the FileManager. Should usually be in its own separate location.
    public class HierarchicalFileEntry
    {
        public string MyModelId { get; set; }
        public string Name { get; set; }
        public long Size { get; set; }
        public string Path { get; set; }
        public string Extension { get; set; }
        public bool IsDirectory { get; set; }
        public bool HasDirectories { get; set; }
        public DateTime DateCreated { get; set; }
        public DateTime DateCreatedUtc { get; set; }
        public DateTime DateModified { get; set; }
        public DateTime DateModifiedUtc { get; set; }
        public List<HierarchicalFileEntry> MyDirectories { get; set; }
        public List<HierarchicalFileEntry> Items { get; set; }
    }

    // the next lines are hardcoded data generation so you can explore the FileManager freely

    async Task<List<HierarchicalFileEntry>> GetHierarchicalFileEntries()
    {
        var root = new HierarchicalFileEntry()
            {
                MyModelId = "1",
                Name = "Work Files",
                IsDirectory = true,
                HasDirectories = true,
                DateCreated = new DateTime(2022, 1, 2),
                DateCreatedUtc = new DateTime(2022, 1, 2),
                DateModified = new DateTime(2022, 2, 3),
                DateModifiedUtc = new DateTime(2022, 2, 3),
                Path = Path.Combine("Work Files"),
                Size = 3 * 1024 * 1024,
            };

        var Documents = new HierarchicalFileEntry()
            {
                MyModelId = "2",
                Name = "Documents",
                IsDirectory = true,
                DateCreated = new DateTime(2022, 1, 2),
                DateCreatedUtc = new DateTime(2022, 1, 2),
                DateModified = new DateTime(2022, 2, 3),
                DateModifiedUtc = new DateTime(2022, 2, 3),
                Path = Path.Combine(root.Path, "Documents"),
                Size = 1024 * 1024
            };

        var specification = new HierarchicalFileEntry()
            {
                MyModelId = "3",
                Name = "Specification",
                IsDirectory = false,
                Extension = ".docx",
                DateCreated = new DateTime(2022, 1, 5),
                DateCreatedUtc = new DateTime(2022, 1, 5),
                DateModified = new DateTime(2022, 2, 3),
                DateModifiedUtc = new DateTime(2022, 2, 3),
                Path = Path.Combine(Documents.Path, "Specification.docx"),
                Size = 462 * 1024
            };

        var report = new HierarchicalFileEntry()
            {
                MyModelId = "4",
                Name = "Report",
                IsDirectory = false,
                Extension = ".xlsx",
                DateCreated = new DateTime(2022, 1, 20),
                DateCreatedUtc = new DateTime(2022, 1, 20),
                DateModified = new DateTime(2022, 1, 25),
                DateModifiedUtc = new DateTime(2022, 1, 25),
                Path = Path.Combine(Documents.Path, "Report.xlsx"),
                Size = 538 * 1024
            };

        var Images = new HierarchicalFileEntry()
            {
                MyModelId = "5",
                Name = "Images",
                IsDirectory = true,
                DateCreated = new DateTime(2022, 1, 2),
                DateCreatedUtc = new DateTime(2022, 1, 2),
                DateModified = new DateTime(2022, 2, 3),
                DateModifiedUtc = new DateTime(2022, 2, 3),
                Path = Path.Combine(root.Path, "Images"),
                Size = 2 * 1024 * 1024
            };

        var dashboardDesign = new HierarchicalFileEntry()
            {
                MyModelId = "6",
                Name = "Dashboard",
                IsDirectory = false,
                Extension = ".png",
                DateCreated = new DateTime(2022, 1, 10),
                DateCreatedUtc = new DateTime(2022, 1, 10),
                DateModified = new DateTime(2022, 2, 13),
                DateModifiedUtc = new DateTime(2022, 2, 13),
                Path = Path.Combine(Images.Path, "Dashboard.png"),
                Size = 1024
            };

        var gridDesign = new HierarchicalFileEntry()
            {
                MyModelId = "7",
                Name = "Design",
                IsDirectory = false,
                Extension = ".png",
                DateCreated = new DateTime(2022, 1, 12),
                DateCreatedUtc = new DateTime(2022, 1, 12),
                DateModified = new DateTime(2022, 2, 13),
                DateModifiedUtc = new DateTime(2022, 2, 13),
                Path = Path.Combine(Images.Path, "Design.png"),
                Size = 1024
            };

        Documents.Items = new List<HierarchicalFileEntry>() { specification, report };
        Images.Items = new List<HierarchicalFileEntry>() { dashboardDesign, gridDesign };
        root.MyDirectories = new List<HierarchicalFileEntry>() { Documents, Images };
        root.Items = new List<HierarchicalFileEntry>() { Documents, Images };

        List<HierarchicalFileEntry> files = new List<HierarchicalFileEntry>() { root };

        return await Task.FromResult(files);
    }
}
````

## See Also

* [FileManager Data Binding Basics]({%slug filemanager-data-binding-overview%})
* [Binding to Flat Data]({%slug filemanager-data-binding-flat-data%})
* [Live Demo: FileManager Hierarchical Data](https://demos.telerik.com/blazor-ui/filemanager/hierarchical-data)
* [Live Demo: FileManager Flat Data](https://demos.telerik.com/blazor-ui/filemanager/flat-data)

repository: telerik/blazor-docs

repo_name: telerik/blazor-docs


text:
# CMpExampleNPMModule
Example NPM module for build pipe line that allows access to AppConfig information from environment variables.

This is a minimal implementation to allow a simple build pipe line to be created and the resulting npm package to be referenced by another project, in this case app1 in the CMpExampleApp1 repository. It provides a small class, `AppConfig` that inspects the environment variables to generate a valid URL for invoking the example Api.

## Local Testing ##
To test locally, assuming nodejs and npm are installed, checkout the repository from Github and execute the following:

```
npm install
npm test
```

## Build Pipeline ##
The corresponding example build pipeline project is in the `CMpDevEnvironment` repository as `/terraform/build/npm1`. The pipeline currently needs to be stored within the `CMpDevEnvironment` repository because it requires access to various Terraform modules.

branch_name: refs/heads/develop


text:
# 1198. Find Smallest Common Element in All Rows

Difficulty: Medium

https://leetcode.com/problems/find-smallest-common-element-in-all-rows/

Given a matrix mat where every row is sorted in increasing order, return the smallest common element in all rows.

If there is no common element, return -1.

**Example 1:**
```
Input: mat = [[1,2,3,4,5],[2,4,5,8,10],[3,5,7,9,11],[1,3,5,7,9]]
Output: 5
```

**Constraints:**

* 1 <= mat.length, mat[i].length <= 500
* 1 <= mat[i][j] <= 10^4
* mat[i] is sorted in increasing order.

url: https://raw.githubusercontent.com/jiadaizhao/LeetCode/4ddea0a532fe7c5d053ffbd6870174ec99fc2d60/1101-1200/1198-Find Smallest Common Element in All Rows/README.md

repository: jiadaizhao/LeetCode

repo_name: jiadaizhao/LeetCode


text:
# debug-here: a rust-gdb hook, inspired by pdb.set_trace()

### The Problem

Debuggers are a great way to examine the state of a program
you are trying to understand, but actually beginning to use
one can have a bit of ceremony involved. You have to figure
out the name of the executable you care about. This can be
harder than it might initially seem if you are running
your program through several layers of scripts that someone else
wrote, or even that you wrote. Once you've got your executable
name you have to start it with `rust-gdb exe` (if you use a wrapper
script, you have to arrange for your script to do so). Now that
you've started your program under gdb you have to set your break
point. `b filename.rs:lineno` works if the code has been statically
linked (fortunately it usually has in rust), but you might have to
first do `b main; run; b filename.rs:lineno; c` instead. Now you
are ready to debug. It's not that much work, but I find myself
doing it a fair amount, so it can get annoying.

One alternative is to arrange for your program to enter some sort
of sleep or looping state, rummage around for the PID on the command
line, then attach with `gdb -pid`. Usually this ends up being a bit
more work (again, not much work, but enough to be annoying), so people
only do it if it is not convenient to launch the program in question
from the terminal.

### Isn't Python Slick?

Python is my goto scripting language, and by far my favorite thing
about the language is `pdb`, the debugger that lives in its standard
library. My development workflow for python involves writing the
script up to the point where I no longer know the APIs that I need
to use, then dropping a `pdb.set_trace()` call into my code and
running it. Python automatically drops me into a full REPL with all
the program state to that point just lying around. I poke around for
a bit, then write the next chunk of code. You might call this debugger
driven development. When I'm debugging python I do something similar
by inserting `pdb.set_trace()` directly into my code wherever something
seems interesting. It's the single most ergonomic language or ecosystem
feature that I've ever used.

### Making getting to the debugger easier in rust

`rust-gdb` isn't yet powerful enough to support the sort of debugger
driven development that I love to use in Python, but it's not that
hard to reduce the amount of effort required to enter a debugger.
This crate just automates the process of convincing your program to
wait around for a debugger to attach to it. Entering the debugger should
be just as easy as writing a `println!` statement. This crate makes it
so.

### What about visual debuggers?

Some people love visual debuggers, and if you are one of them thats great!
`Right click > Add breakpoint` is pretty fast. If you are a visual debugger
kind of person, this crate probably isn't for you. Personally, I've never
used a visual gdb wrapper that I was able to fully trust. I've even had
enough bad experiences with TUI mode that I now prefer just the plain old
command line interface.

## Usage

First, you need the `debug-here` gdb wrapper installed. `xterm` does not
let you pass extra arguments to the program you invoke as your shell, so
`debug-here-gdb-wrapper` will arrange for `rust-gdb` to execute all the
right gdb commands.

```
cargo install debug-here-gdb-wrapper
```

Now you can add debug-here to the dependencies of a crate you want to
work on.

```
debug-here = "0.1"
```

Drop the usual `extern crate debug_here;` somewhere in your
`lib.rs` or `main.rs`, then place `#[macro_use] debug_here;`
in the module you want to debug and just write `debug_here!()`
wherever you want to get dropped into the debugger. When your
program reaches that point for the first time, it will launch
an `xterm` window with `rust-gdb` attached to your process
right after the `debug_here!()` macro. You can poke around
and start stepping through your program. If you reach another
`debug_here!()` macro invocation, you don't have to worry about
more gdb terminals spawing left and right. `debug_here!()` only
fires once per program.

## An Example: Bad Factorials

I have a very important rust program called `debug-me` which computes
the factorial of 5. Or at least its supposed to. Right now it is
telling me that the factorial of 5 is 0, which doesn't seem right.
Here is my `main.rs`.

```rust
fn factorial(n: usize) -> usize {
    let mut res = 1;
    for i in 0..n {
        res *= i;
    }
    res
}

fn main() {
    println!("The factorial of 5 is {}!", factorial(5));
}
```

You can probably see the problem, but I can't because I'm helpless without
a debugger. In order to figure out what is going on, I'm going to pull
in debug-here to help me out. First, I'll make sure that the debug-here
gdb shim is installed with `cargo install debug-here-gdb-wrapper`.
Now, I'll add debug-here to my factorial crate's `Cargo.toml`.

```
[dependencies]
debug-here = "0.1"
```

And I'll add the line

```
#[macro_use] extern crate debug_here;
```

to my source file. Now it looks like this:

```rust
#[macro_use] extern crate debug_here;

fn factorial(n: usize) -> usize {
    let mut res = 1;
    for i in 0..n {
        res *= i;
    }
    res
}

fn main() {
    println!("The factorial of 5 is {}!", factorial(5));
}
```

My loop is definitely counting up and multiplying the result variable
by bigger and bigger numbers. I feel like it should work, but I'm
going to step through the loop a few times to see what's going on.
Time to set my breakpoint with debug-here.

```rust
#[macro_use] extern crate debug_here;

fn factorial(n: usize) -> usize {
    let mut res = 1;
    debug_here!();
    for i in 0..n {
        res *= i;
    }
    res
}

fn main() {
    println!("The factorial of 5 is {}!", factorial(5));
}
```

As easy as `println!`! Now I run my program with `cargo run`.
An xterm window pops up with a gdb shell that says:

```
debug_me::factorial (n=5) at debug-me/src/main.rs:6
6           for i in 0..n {
(gdb)
```

Looking at my source code, it seems like `res` is an interesting
variable to keep track of, so I'll ask gdb to keep me informed.

```
(gdb) disp res
1: res = 1
```

Now, I'll step through the loop a few times.

```
(gdb) n
7               res *= i;
1: res = 1
(gdb) n
6           for i in 0..n {
1: res = 0
(gdb) n
7               res *= i;
1: res = 0
```

It looks like `res` went to 0 in the first loop iteration. Looking back
at the source, I can see that this is because the counter starts at 0. I'll
quit out of the debugger and fix it.

If you want to play with this example yourself, you can just clone the
repo at `https://github.com/ethanpailes/debug-here` and run the following
commands:

```
 > cargo install debug-here-gdb-wrapper # if you haven't already done so
 > cd debug-here/debug-me
 > cargo run
```

You should see an xterm pop up with a rust-gdb shell ready to go. There
is another bug in the factorial routine. Try debugging it with
rust-gdb.

## Platforms

Right now debug-here only works on linux with rust-gdb. There might
be support for macOS and rust-lldb in the future. Windows support
is a bit less likely because I don't understand the moving pieces
as well, but that could change.

repository: passchaos/debug-here

repo_name: passchaos/debug-here


text:
# Node Base

*Base code for a Node.JS Server*

Features:
* Express Setup
* JWT Setup
* Basic Login Endpoints
* Database Abstraction Layer
  * MongoDB base layer
  * Elastic base layer
  * MySQL base layer
  * PostgreSQL base layer
* Mocha tests for database layers

To Run:
* Clone repository
* Start database (Set up for MongoDB)
* Run `yarn` to install dependencies
* Run `yarn start` to start development server

Note:
* This is not production ready code
* Database layers are not fully built
* Further security must be built out
* If running with the MySQL DB layer, I ran `ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY 'password’;` in the MySQL client


text:
# Hardware

![BoardScheme](https://github.com/fedepaj/tappo/blob/assets/baord_overview.jpg)

## Sensor and actuators
* Sensors:
    * ultrasonic range finder sr04: to determine the distance between the water and the neck of the tank.

    * switch: detects when the cap is placed/removed. The one chosen is [this](http://smparts.com/product_info.php?cPath=2_602&products_id=6689) and it is placed in the circuit like [this](https://killerrobotics.files.wordpress.com/2015/09/lever-switch_bb.png).

* Actuators:
    * piezo buzzer: makes a pretty annoying sound;

    * led: is surely a visual cue but could really be switched by a NO relay.

## Misc
* Case: holds the sensors together and makes it a perfect lid for a 43mm 30L plastic tank that will be filled with 15mm tubing.
* Shield: gives order to the messy cables

## Some device's pictures

![Board pics](https://github.com/fedepaj/tappo/blob/assets/board_tappo.jpg)

repository: fedepaj/tappo

repo_name: fedepaj/tappo


text:
---
summary: Multi-backend storage module (WIP)
labels:
- NeedDocs
- Stage-Alpha
...

Introduction
============

This module attemtps to provide a storage driver that is really multiple
storage drivers. This could be used for storage error tolerance or
caching of data in a faster storage driver.

Configuration
=============

An example:

``` {.lua}
storage = "multi"
storage_multi_policy = "all"
storage_multi = {
    "memory",
    "internal",
    "sql"
}
```

Here data would be first read from or written to [mod\_storage\_memory],
then internal storage, then SQL storage. For reads, the first successful
read will be used. For writes, it depends on the `storage_multi_policy`
option. If set to `"all"`, then all storage backends must report success
for the write to be considered successful. Other options are `"one"` and
`"majority"`.

repository: chrisballinger/prosody-modules

extension: markdown

repo_name: chrisballinger/prosody-modules


text:
# online-library
Online books library by laravel and vuejs

## Requirements:

- PHP >= 7.1.3
- OpenSSL PHP Extension
- PDO PHP Extension
- Mbstring PHP Extension
- Tokenizer PHP Extension
- XML PHP Extension
- Ctype PHP Extension
- JSON PHP Extension
- BCMath PHP Extension

- nodejs >= 8.10 and npm >= 5.6.0

### for correct installation
- npm install
- npm run production
- add correct params for .env file (please have a look at .env.example)
- make sure you have read/write access to /storage folder (subfolders and files)
- composer install
- php artisan migrate
- php artisan passport:install
- (only if need) php artisan key:generate

### Note
- for local development you can run server by "**php artisan serve**" command


text:
# TciaApiV3ClientPython
The Cancer Imaging Archive API Version 3  Client in Python with Requests

For more information about restful API visit:
    https://wiki.cancerimagingarchive.net/display/Public/TCIA+Programmatic+Interface+%28REST+API%29+Usage+Guide

# Requires:
    * Python 2.7.* (https://python.org)
    * Requests (http://docs.python-requests.org/en/latest/)

 Written for the latest version of the The Cancer Imaging Archive API (Version 3) as of 4/30/2015

# Install Requests

 To install requests use the command:

    python -m pip install requests


text:
# R for Stata users

## Background

This material is developed by [Gwamaka Charles Mwamwaja](https://www.linkedin.com/in/gwamakacharles/) as an introduction to R Statistical Package for [Virtuality](). It builds upon knowledge of Stata to explore features of R with impact evaluation applications in mind. It also assumes some degree of familiarity with DIME's [coding practices](https://dimewiki.worldbank.org/wiki/Stata_Coding_Practices).

## Training content

[01 - Introduction to R](https://raw.githack.com/GwamakaCharles/r-training/main/Presentations/01-intro-to-R.html)

- Introduction to RStudio, R syntax, objects and classes. Designed for a 1h30m session.

Formats:

- [.html](https://raw.githack.com/GwamakaCharles/r-training/main/Presentations/01-intro-to-R.html)
- [.pdf](https://raw.githack.com/GwamakaCharles/r-training/main/Presentations/01-intro-to-R.pdf)
- [.Rmd](https://raw.githack.com/GwamakaCharles/r-training/main/Presentations/01-intro-to-R.Rmd)

[02 - Data processing](https://raw.githack.com/GwamakaCharles/r-training/main/Presentations/02-data-processing.html)

- Basic functions for processing data. Designed for a 1h30m session.

Formats:

- [.html](https://raw.githack.com/GwamakaCharles/r-training/main/Presentations/02-data-processing.html)
- [.pdf](https://raw.githack.com/GwamakaCharles/r-training/main/Presentations/02-data-processing.pdf)
- [.Rmd](https://raw.githack.com/GwamakaCharles/r-training/main/Presentations/02-data-processing.Rmd)

[03 - Data visualization](https://raw.githack.com/GwamakaCharles/r-training/main/Presentations/03-data-visualization.html)

- An introduction to creating and export graphs in ggplot2. Designed for a 1h30m session.

Formats:

- [.html](https://raw.githack.com/GwamakaCharles/r-training/main/Presentations/03-data-visualization.html)
- [.pdf](https://raw.githack.com/GwamakaCharles/r-training/main/Presentations/03-data-visualization.pdf)
- [.Rmd](https://raw.githack.com/GwamakaCharles/r-training/main/Presentations/03-data-visualization.Rmd)

[04 - Descriptive analysis](https://raw.githack.com/GwamakaCharles/r-training/main/Presentations/04-descriptive-analysis.html)

- How to create and export descriptive statistics table in R. Designed for a 1h30m session.

Formats:

- [.html](https://raw.githack.com/GwamakaCharles/r-training/main/Presentations/04-descriptive-analysis.html)
- [.pdf](https://raw.githack.com/GwamakaCharles/r-training/main/Presentations/04-descriptive-analysis.pdf)
- [.Rmd](https://raw.githack.com/GwamakaCharles/r-training/main/Presentations/04-descriptive-analysis.Rmd)

[05 - Geospatial data](https://raw.githack.com/GwamakaCharles/r-training/main/Presentations/05-spatial-data.html)

- An overview of R resources on GIS. Designed for a 1h30m session.

Formats:

- [.html](https://raw.githack.com/GwamakaCharles/r-training/main/Presentations/05-spatial-data.html)
- [.pdf](https://raw.githack.com/GwamakaCharles/r-training/main/Presentations/05-spatial-data.pdf)
- [.Rmd](https://raw.githack.com/GwamakaCharles/r-training/main/Presentations/05-spatial-data.Rmd)

[06 - R programming practices](https://raw.githack.com/GwamakaCharles/r-training/main/Presentations/06-R-programming-practices.html)

- Uses and R master script to explore code organization, loops, custom functions and if statements. Designed for a 1h30m session.

Formats:

- [.html](https://raw.githack.com/GwamakaCharles/r-training/main/Presentations/06-R-programming-practices.html)
- [.pdf](https://raw.githack.com/GwamakaCharles/r-training/main/Presentations/06-R-programming-practices.pdf)
- [.Rmd](https://raw.githack.com/GwamakaCharles/r-training/main/Presentations/06-R-programming-practices.Rmd)

## License

This material is developed under MIT license. See http://adampritchard.mit-license.org/ or see [the `LICENSE` file](https://github.com/worldbank/ietoolkit/blob/master/LICENSE) for details.

## Main Contact

Gwamaka C. Mwamwaja<EMAIL_ADDRESS>
## Authors

- Gwamaka Charles Mwamwaja
- Luiza Cardoso de Andrade
- Robert A. Marty
- Leonardo Teixeira Viotti
- Rony Rodriguez-Ramirez
- Luis Eduardo San Martin

repository: GwamakaCharles/r-training

repo_name: GwamakaCharles/r-training


text:
# SLA (Service License Agreement)

## [Availability](https://en.wikipedia.org/wiki/High_availability)

- Uptime Percentage
  - two nines (99%) - downtime of 3.65d
  - two nines five(99.5%) - downtime of 1.83d
  - five nines (99.999%) - downtime of 5.26 minutes
    - performance-sensitive industries like finance and ecommerce
  - six nines (99.9999%) - downtime 31.56 seconds a year
  - \*\* most of the downtime is spent on recover/repair
- Time to alert in advance before a shutdown / maintenance

## Responsiveness

- Total time to execute a request.
  - AVG + Max
  - Per type of request
- Maximum number of errors(500 internal)

## Other Points in the Agreement

- Refund
  - Credit per each percentage of responsiveness/Uptime violation

## SLA enforcement

- Most of the times the API side - more to loss.
- In cases when the API is so critical, the client side too


text:
<!-- dx-header -->
# St. Jude cis-X

Search for activating regulatory variants in the tumor genome
<!-- /dx-header -->

Activating regular variants usually cause the cis-activation of target genes.
To find cis-activated genes, allelic specific/imbalance expressions (ASE) and
outlier high expression (OHE) signals are used. Variants in the same
topologically associated domains with the candidates can then be searched,
including structural variants (SV), copy number aberrations (CNA), and single
nucleotide variations (SNV) and insertion/deletions (indel).

A transcription factor binding analysis is also done, using motifs from
[HOCOMOCO] v10 models.

cis-X currently only works with hg19 (GRCh37).

[HOCOMOCO]: http://hocomoco11.autosome.ru/

## Inputs

  * `sample-id`: The sample ID. This is primarily used as the prefix for the
    filenames of the results.

  * `results-dir`: The output directory. See "[Outputs](#outputs)" for the
    resulting files.

  * `markers`: A list of single nucleotide markers. This is a tab-delimited
    file with the following columns:

      * `Chr`: chromosome name for the marker
      * `Pos`: genomic start location for the marker
      * `Chr_Allele`: reference allele
      * `Alternative_Allele`: alternative allele
      * `reference_tumor_count`: reference allele count in the tumor genome
      * `alternative_tumor_count`: alternative allele count in the tumor genome
      * `reference_normal_count`: reference allele count in the matched normal genome
      * `alternative_normal_count`: alternative count in the matched normal genome

    This file can be generated with Bambino.

  * `cnv-loh`: CNV/LOH regions. It contains all the genomic regions carrying
    copy number variations (CNV) or loss of heterozygosity (LOH), which will be
    filtered out during analysis.

    This is a tab-delimited file in the bed format. It must have at least the
    following three columns:

      * `chrom`: chromosome name
      * `loc.start`: genomic start location
      * `loc.end`: genomic end location

    If no CNV/LOH are in the genome under analysis, a file with no rows (but
    including headers) can be provided.

    This file can be generated with CONSERTING.

  * `bam`: The RNA-Seq BAM file aligned to hg19 (GRCh37). The index file is
    expected to be in the same directory with the same name and extension
    `.bai`, e.g, `/path/to/SJ001_D1.bam` and `/path/to/SJ001_D1.bam.bai`.

    StrongArm or STAR can be used for RNA-Seq alignment.

  * `fpkm-matrix`: A gene expression table. This is a tab-delimited file
    containing gene level expressions for the tumor under analysis. The
    expressions are in FPKM (fragments per kilobase of transcript per million
    mapped reads).

      * `GeneID`: gene [Ensembl] ID
      * `GeneName`: gene symbol
      * `Type`: [transcript type](https://www.gencodegenes.org/gencode_biotypes.html)
      * `Status`: transcript status (must be `KNOWN`, `NOVEL`, or `PUTATIVE`)
      * `Chr`: chromosome name
      * `Start` genomic start location
      * `End`: genomic end location
      * [SampleID...]: FPKM for the given sample

    This file can can be generated with the output of HTseq-count
    preprocessed through `src/other/mergeData_geneName.pl`. The data must be
    able to match values in the given gene specific reference expression
    matrices (see [cis-X ref-exp]) generated from a larger cohort.

  * `snv-indel`: Somatic SNV/indels. This is a tab-delimited file containing
    somatic sequence mutations present in the genome under analysis. It includes
    both single nucleotide variants (SNV) and small insertion/deletions (indel).
    The file must have the following columns:

      * `chr`: chromosome name
      * `pos`: genomic start location
      * `ref`: reference allele genotype
      * `mutant`: mutant allele genotype
      * `type`: mutation type (either `snv` or `indel`)

    Note that the coordinate used for an indel is after the inserted sequence.

    If no SNV/indels are in the sample under analysis, a file with no rows
    (but including headers) can be provided.

    This file can can be created with Bambino and then preprocessed using the
    steps taken in "[The genetic basis of early T-cell precursor acute lymphoblastic leukaemia][22237106]".

  * `sv` Somatic SVs. This is a tab-delimited file containing somatic-acquired
    structural variants (SV) in the cancer genome. The file must have the
    following columns:

      * `chrA`: chromosome name of the left breakpoint
      * `posA`: genomic location of the left breakpoint
      * `ortA`: strand orientation of the left breakpoint
      * `chrB`: chromosome name of the right breakpoint
      * `posB`: genomic location of the right breakpoint
      * `ortB`: strand orientation of the right breakpoint

    Strand orientations are denoted with a `+` for a sense or coding strand
    and `-` for a antisense or non-coding strand.

    If no somatic SVs are in the sample under analysis, a file with no rows (but
    including headers) can be provided.

    This file can be generated by CREST.

  * `cna` Somatic CNV. This is a tab-delimited file containing the genomic
    regions with somatic-acquired copy number aberrations (CNA) in the cancer
    genome.

      * `chr`: chromosome name
      * `start`: genomic start location
      * `end`: genomic end location
      * `logR`: log2 ratio

    If no somatic CNVs are in the sample under analysis, a file with no rows
    (but including headers) can be provided.

    This file can be generating by CONSERTING.

  * `disease`: The disease name.

  * `cnv_loh_action`: The behavior when handling markers in CNV/LOH regions. Can
    be either `keep` or `drop`.

  * `min_coverage_wgs`: The minimum coverage in WGS to be included in the
    analysis.

  * `min_coverage_rna_seq`: The minimum coverage in RNA-seq to be included in
    the analysis.

  * `fpkm_threshold_candidate`: The FPKM threshold for the nomination of a
    cis-activated candidate.

  * `user_annotation`: Annotations for the candidate SNV/indels in BED format.

  * `chr_string`: Whether the names in the reference sequence dictionary are
    prefixed with "chr".

  * `tad_info`: TAD information defining the regulatory territory used in
    noncoding variant analysis.

[cis-X ref-exp]: https://github.com/stjude/cis-x/tree/master/src/ref-exp
[22237106]: https://www.ncbi.nlm.nih.gov/pubmed/22237106

## Outputs

  * `*.cisActivated.candidates.txt`: cis-activated candidates in the tumor
    genome under analysis.

      * `gene`: gene accession number ([RefSeq] ID)
      * `gsym`: gene symbol
      * `chrom`: chromosome name
      * `strand`: strand orientation
      * `start`: genomic start location
      * `end`: genomic end location
      * `cdsStartStat`: coding sequence (CDS) start status
      * `cdsEndStat`: coding sequence (CDS) end status
      * `markers`: number of heterozygous markers in this gene
      * `ase_markers`: number of heterozygous markers showing allelic specific expressions (ASE)
      * `average_ai_all`: average B-allele frequency (BAF) difference between RNA and DNA for all heterozygous markers
      * `average_ai_ase`: average BAF difference between RNA and DNA for ASE markers
      * `pval_all_markers`: p-value for each marker in the ASE test
      * `pval_ase_markers`: p-value for ASE markers in the ASE test
      * `ai_all_markers`: BAF difference between RNA and DNA for all heterozygrous markers
      * `ai_ase_markers`: BAF difference between RNA and DNA for ASE markers
      * `comb.pval`: combined p-value for the ASE test
      * `mean.delta`: average BAF difference between RNA and DNA for all markers
      * `rawp`: raw p-value for the ASE test
      * `Bonferroni`: adjusted p-value for the ASE test (single-step Bonferroni)
      * `ABH`: adjusted p-value for the ASE test (Benjamini-Hochberg)
      * `FPKM`: FPKM value
      * `loo.source`: which reference expression matrix was used in the outlier high expression (OHE) test
      * `loo.cohort.size`: number of cases in the reference expression matrix for this gene
      * `loo.pval`: p-value of the OHE test
      * `loo.rank`: rank of the case under analysis among the reference cases
      * `imprinting.status`: imprinting status of the gene
      * `candidate.group`: status of the gene, combining both ASE and outlier tests
      * `description`: status of the gene in COSMIC database

    Strand orientations are denoted with a `+` for a sense or coding strand
    and `-` for a antisense or non-coding strand.

    Coding sequence status is typically one of "none" (not specified), "unk"
    (unknown), "incmpl" (incomplete), or "cmpl" (complete).

  * `*.sv.candidates.txt`: Structural variant candidates predicted as the
    causal for the cis-activated genes in the regulatory territory.

      * `left.candidate.inTAD`: cis-activated candidate near the left breakpoint
      * `right.candidate.inTAD`: cis-activated candidate near the right breakpoint
      * `chrA`: chromosome name of the left breakpoint
      * `posA`: genomic location of the left breakpoint
      * `ortA`: strand orientation of the left breakpoint
      * `chrB`: chromosome name of the right breakpoint
      * `posB`: genomic location of the right breakpoint
      * `ortB`: strand orientation of the right breakpoint
      * `type`: type of translocation

  * `*.cna.candidates.txt`: Copy number aberrations predicted as the causal
    for the cis-activated genes in the regulatory territory.

      * `candidate.inTAD`: cis-activated candidate by the CNA
      * `chr`: chromosome name
      * `start`: genomic start position
      * `end`: genomic end location
      * `logR`: log ratio of the CNA

  * `*.snvindel.candidates.txt`: SNV/indel candidates predicted as functional
    and predicted transcription factors. The mutations are also annotated for
    known regulatory elements reported by the [NIH Roadmap Epigenomics Project]
    by collecting 111 cell lines.

      * `chrom`: chromosome name
      * `pos`: genomic start position
      * `ref`: reference allele genotype
      * `mut`: mutant allele genotype
      * `type`: mutation type (either `snv` or `indel`)
      * `target`: cis-activated candidate
      * `dist`: distance between the mutation and transcription start sites of the target gene
      * `tf`: transcription factors predicted to have the binding motif introduced by the mutation
      * `EpiRoadmap_enhancer`: enhancer regions that overlap with the mutation (from the [NIH Roadmap Epigenomics Project])
      * `EpiRoadmap_promoter`: promoter regions that overlap with the mutation (from the [NIH Roadmap Epigenomics Project])
      * `EpiRoadmap_dyadic`: dyadic regions that overlap with the mutation (from the [NIH Roadmap Epigenomics Project])
      * `User_Annot`: annotation from the user-provided BED file

  * `*.OHE.results.txt`: Raw results for outlier high expression test.

      * `Gene`: gene symbol
      * `fpkm.raw`: FPKM value
      * `size.bi`: number of cases in the bi-allelic reference cohort
      * `p.bi`: p-value in the outlier test using the bi-allelic reference cohort
      * `rank.bi`: rank of the expression level in the case under analysis compared to the bi-allelic reference cohort
      * `size.cohort`: number of cases in the entire reference cohort
      * `p.cohort`: p-value in the outlier test using the entire reference cohort
      * `rank.cohort`: rank of the expression level in the case under analysis compared to the entire reference cohort
      * `size.white`: number of cases in the whitelist reference cohort
      * `p.white`: p-value in the outlier test using the whitelist reference cohort
      * `rank.white`: rank of the expression level in the case under analysis compared to the whitelist reference cohort
      * `tscore.white`: t-score representing if the gene showed outlier expresssion using the whitelist reference cohort
      * `tscore.perc.white`: percentage of the t-score compared to the null distribution

  * `*.ase.gene.model.fdr.txt`: Raw results for gene level allelic specific
    expression test.

      * `gene`: gene accession number ([RefSeq] ID)
      * `gsym`: gene symbol
      * `chrom`: chromosome name
      * `strand`: strand orientation
      * `start`: genomic start location
      * `end`: genomic end location
      * `cdsStartStat`: coding sequence (CDS) start status
      * `cdsEndStat`: coding sequence (CDS) end status
      * `markers`: number of heterozygous markers in this gene
      * `ase_markers`: number of heterozygous markers showing allelic specific expressions (ASE)
      * `average_ai_all`: average B-allele frequency (BAF) difference between RNA and DNA for all heterozygous markers
      * `average_ai_ase`: average BAF difference between RNA and DNA for ASE markers
      * `pval_all_markers`: p-value for each marker in the ASE test
      * `pval_ase_markers`: p-value for ASE markers in the ASE test
      * `ai_all_markers`: BAF difference between RNA and DNA for all heterozygrous markers
      * `ai_ase_markers`: BAF difference between RNA and DNA for ASE markers
      * `comb.pval`: combined p-value for the ASE test
      * `mean.delta`: average BAF difference between RNA and DNA for all markers
      * `rawp`: raw p-value for the ASE test
      * `Bonferroni`: adjusted p-value for the ASE test (single-step Bonferroni)
      * `ABH`: adjusted p-value for the ASE test (Benjamini-Hochberg)

    Strand orientations are denoted with a `+` for a sense or coding strand
    and `-` for a antisense or non-coding strand.

    Coding sequence status is typically one of "none" (not specified), "unk"
    (unknown), "incmpl" (incomplete), or "cmpl" (complete).

  * `*.ase.combine.WGS.RNAseq.goodmarkers.binom.txt`: Raw results for single
    marker based allelic specific expression test.

      * `chrom`: chromosome name
      * `pos`: genomic start position
      * `ref`: reference allele genotype
      * `mut`: non-reference allele genotype
      * `cvg_wgs`: coverage of the marker from the whole genome sequence (WGS)
      * `mut_freq_wgs`: non-reference allele fraction in the WGS
      * `cvg_rna`: coverage of the marker from the RNA-seq
      * `mut_freq_rna`: non-reference allele fraction in the RNA-seq
      * `ref.1`: read count of the reference allele in the RNA-seq
      * `var`: read count of the non-reference allele in the RNA-seq
      * `pvalue`: p-value from the binomial test
      * `delta.abs`: absolute difference of the non-reference allele fraction between the WGS and RNA-seq

[Ensembl]: http://www.ensembl.org/
[NIH Roadmap Epigenomics Project]: https://egg2.wustl.edu/roadmap/web_portal/index.html
[RefSeq]: https://www.ncbi.nlm.nih.gov/refseq/

repository: jligm-hash/cis-x

repo_name: jligm-hash/cis-x


text:
---
title: 'Glossary'
metaTitle: 'Glossary'
metaDescription: 'Glossary'
---

> [The version currently viewed is the result of machine-translated Chinese Simplified and manual proofreading.If there is any mistranslation in the document, please click here to submit your translation proposal.](https://crwd.in/newbeclaptrap)

Reading the glossary of this project will give you a better understanding of the concepts related to this project.


text:
EZAMQP
======

Ezamqp is a library that lets you handle your message broker connection through AMQP protocol easily.

Main features
-------------

    * Automatically reconnects to message broker if connection is lost.
    * Handles channels and queues without additional development effort.
    * Lets you easily use JSON based request / response format.
    * Supports RPC and events messaging.


text:
---
title: Bookmarks for september 18th through october 9th
slug: web-combing-18-oct
date: 2013-10-13
notoc: true
noread: true
socialsharing: true
categories:
- Links

---
These are my links for September 18th through October 9th:

  - [Rewild the Child][monbiot] - Reading this I realise how lucky I was to grow up where children roamed about freely and at a time when there was still plenty of nature to be found not far from the back door.

  - [The Internet Is a Surveillance State][schneier] - "Maintaining privacy on the Internet is nearly impossible. If you forget even once to enable your protections, or click on the wrong link, or type the wrong thing, you've permanently attached your name to whatever anonymous service you're using."

  - [Top 10 Excuses Why We're Still Addicted to Supermarkets][permaculturenews] - I am against much of the damage wrought by supermarkets, yet I am guilty of many of these excuses from time to time. Good reminder to stay vigilant.

[monbiot]: http://www.monbiot.com/2013/10/07/rewild-the-child/
[permaculturenews]: http://permaculturenews.org/2013/09/18/top-10-excuses-why-were-still-addicted-to-supermarkets/
[schneier]: https://www.schneier.com/essay-418.html

filename: Bookmarks_for_september_ 2.md