text:
# Remitano Ruby API Client

Feel free to fork, modify & redistribute under the MIT license.

## Installation

Add this line to your application's Gemfile:
```
gem 'remitano'
```
Then execute:
```
bundle install
```
Or install it yourself as:
```
gem install remitano
```

## Usage
### Create API Key

Visit https://remitano.com/settings/api_key to create API key.

### Get Authentiator secret

Visit https://remitano.com/settings/authenticator to get your authenticator secret.

Note: This is needed to perform actions which need 2FA authentication like withdrawals, otherwise, you won't need it.
### Setup Remitano client

```ruby
Remitano::Client.default_key = YOUR_API_KEY
Remitano::Client.default_secret = YOUR_API_SECRET
Remitano::Client.default_authenticator_secret = YOUR_AUTHENTICATOR_SECRET
Remitano::Client.default # => the default client
```
or
```ruby
client = Remitano::Client.new(
  key: YOUR_API_KEY,
  secret: YOUR_API_SECRET,
  authenticator_secret: YOUR_AUTHENTICATOR_SECRET,
)

```
### Payment gateway
Visit https://developers.remitano.com/api-explorer - Merchant section for more information.
#### Charges
##### Get charge with remitano id
```ruby
client.merchant_charges.get(id)
```
##### Create charge
1. With coin currency
Note: For now, we only support `usdt` as the price coin currency.
```ruby
client.merchant_charges.create(
  coin_currency: "usdt",
  coin_amount: 10.99,
  cancelled_or_completed_callback_url: "https://example.com/payments/callback?id=example", # optional
  description: "Example charge" # optional
)
```
2. With fiat currency
Note: We support fiat currency of 56 countries that Remitano are supporting, i.e., `USD`, `AUD`. (You could find entire list in our [developer docs](https://developers.remitano.com/docs/getting-started/getting-started)).
```ruby
client.merchant_charges.create(
  fiat_currency: "AUD",
  fiat_amount: 10.99,
  cancelled_or_completed_callback_url: "https://example.com/payments/callback?id=example", # optional
  description: "Example charge" # optional
)
```

##### Get paginated charge list
```ruby
client.merchant_charges.list(
  status: "completed", # optional
  page: 2, # optional
  per_page: 25 # optional
)
```

#### Withdrawals
##### Get withdrawal with remitano id
```ruby
client.merchant_withdrawals.get(id)
```
##### Create withdrawal
1. Withdraw to external coin address
```ruby
client.merchant_withdrawals.create(
  merchant_withdrawal_ref: "akh9r1h29e1", # your withdrawal_ref, we won't process withdrawal if the same ref is submitted before
  coin_currency: "xrp",
  coin_amount: 10.99,
  receiver_pay_fee: true, # defines who will be charged for the withdrawal fee
  cancelled_or_completed_callback_url: "http://sample.com/123/callback", # optional
  coin_address: "rLpumSZQNJ6Cve7hfQcdkG9rJbJhkSV8AD0",
  destination_tag:<PHONE_NUMBER> # optional, required when coin_currency is xrp
)
```
2. Withdraw to other remitano account
```ruby
client.merchant_withdrawals.create(
  merchant_withdrawal_ref: "akh9r1h29e1", # your withdrawal_ref, we won't process withdrawal if the same ref is submitted before
  coin_currency: "xrp",
  coin_amount: 10.99,
  receiver_pay_fee: true,
  cancelled_or_completed_callback_url: "http://sample.com/123/callback",
  remitano_username: "receiver123",
  remitano_phone_number: "+234 1 123 4567"
)
```
##### Get paginated withdrawal list
```ruby
client.merchant_withdrawals.list(
  status: "completed", # optional
  page: 2, # optional
  per_page: 25 # optional
)
```

#### Callbacks
##### Charges
Whenever a charge is changed to completed or cancelled in our system:
- we will send a POST request to `charge.cancelled_or_completed_callback_url` with `remitano_id` param.
- if user is still on our site, we will also redirect user to `object.cancelled_or_completed_callback_url` with `remitano_id` param (GET request).

After receiving these callbacks, you could call `client.merchant_charges.get(params[:remitano_id])` to get the updated information and process accordingly.

##### Withdrawals
Whenever a withdrawal is changed to completed or cancelled in our system:
- we will send a POST request to `withdrawal.cancelled_or_completed_callback_url` with `remitano_id` param.

After receiving these callbacks, you could call `client.merchant_withdrawals.get(params[:remitano_id])` to get the updated information and process accordingly.

### Errors
When receiving non 200-299 http code, a Remitano::Client::Request::RequestError will be raised.

### Sandbox testing
We have a Testnet at https://remidemo.com.

You could register an account there, then submit a request at [this google form](https://forms.gle/jvJyWPBNwTWfowSm9) with your Remidemo username, so we could help to setup your testing account as a merchant.

After that, you could start your sandbox testing by setting `ENV["REMITANO_SANDBOX"]` to `"true"`.

## Contributing

1. Fork it
2. Create your feature branch (`git checkout -b
my-new-feature`)
3. Commit your changes (`git commit -am 'Add some feature'`)
4. Push to the branch (`git push origin my-new-feature`)
5. Create new Pull Request

repository: remitano/remitano-ruby

gha_language: Ruby

repo_name: remitano/remitano-ruby


text:
## Php Express
This project is a light weight version of the popular expressjs Nodejs framework.

### Requirements
This is a LAMP or WAMP project, written for PHP 7.
- Composer is required.
- Npm and Nodejs are required for tests.
- Mod rewrite must be enabled.
- Mysql is required. Currently only Mysql is supported.

### Installation
Please read the requirements section first as this section will direct you to use some of the pre-requisites.
1. Clone the directory using `git clone https://github.com/pete-mann/php-express.git`
2. Install dependencies with Composer, `cd php-express && composer install`
3. If you wish to using system tests, it is necessary to install the npm dependencies. From the project root `cd tests/system && npm install`

### About
While this is similar to Expressjs, this project does not attempt to do everything that Expressjs does. For example regex
route matching is currently not supported, however named params are.

The project is designed for Apache with mod_rewrite support required. NGINX support is not included, but that could be
added if required.

### Composer
This project requires composer for autoloading and loading some dependencies such as:
- Firebase JWT

### Tests
Some tests have been written using PHPUnit, Mocha and Chai. The following testing:
- Performance testing will be written using Apache Bench (AB).
- System testing will be written using Mocha and Chai.
- Integration testing will be written using PHPUnit 7.
- Unit testing will be written using PHPUnit 7.

### Test Guides

#### Performance Test Guide
Performance testing can be executed by running the `tests/performance/performanceTest.sh` file.

#### System Test Guide
System testing can be conducted from the `tests/system` directory by issuing `npm test`. This will run every `*.test.js`
file in the `tests/system` directory.

#### Integration Test Guide
Integration tests can be conducted using PHPUnit from the `tests/integration` directory.

#### Unit Test Guide
Unit testing can be conducted using PHPUnit from the `tests/unit` directory.

### TODO
- Include JSON schema validation of request body data, see [php-json-schema](https://github.com/swaggest/php-json-schema)
- Write Swagger documentation including schemas for each endpoint.
- Try to use Swagger schemas in testing and validation.

### Example usage
This example usage is included in the `/api/index.php` file and is presented here for the benfit of readers.
```
require __DIR__ . "/../vendor/autoload.php";

use \ExpressPHP\core\App;
use \ExpressPHP\core\Request;
use \ExpressPHP\core\Response;
use \ExpressPHP\middlewares\JWT;
use \ExpressPHP\controllers\CtrlAuth;
use \ExpressPHP\controllers\CtrlClient;
use \ExpressPHP\controllers\CtrlProject;
use \ExpressPHP\controllers\CtrlWorkCode;
use \ExpressPHP\controllers\CtrlActivity;

$app = new App();
$ctrlAuth = new CtrlAuth();
$ctrlClient = new CtrlClient();
$ctrlProject = new CtrlProject();
$ctrlWorkCode = new CtrlWorkCode();
$ctrlActivity = new CtrlActivity();
$jwt = new JWT();

/**
 * Specify a callable method of a class like this so as to use a controller to handle the request. This approach will
 * keep this file small
 */

// Auth
$app->post('/auth', [$ctrlAuth, 'auth']);

// Client
$app->middleware($jwt)->get('/client', [$ctrlClient, 'index']);
$app->middleware($jwt)->get('/client/:clientId', [$ctrlClient, 'show']);
$app->middleware($jwt)->post('/client', [$ctrlClient, 'update']);

// Project
$app->middleware($jwt)->get('/client/:clientId/project', [$ctrlProject, 'getClientProjects']);
$app->middleware($jwt)->get('/client/:clientId/project/:projectId', [$ctrlProject, 'show']);
$app->middleware($jwt)->post('/client/:clientId/project/:projectId', [$ctrlProject, 'update']);

// WorkCode
$app->middleware($jwt)->get('/client/:clientId/project/:projectId/workcode', [$ctrlWorkCode, 'getClientProjectWorkCode']);
$app->middleware($jwt)->get('/client/:clientId/project/:projectId/workcode/:workCodeId', [$ctrlWorkCode, 'show']);
$app->middleware($jwt)->post('/client/:clientId/project/:projectId/workcode/:workCodeId', [$ctrlWorkCode, 'update']);

// Activity
$app->middleware($jwt)->get('/client/:clientId/project/:projectId/workcode/:workCodeId/activity', [$ctrlActivity, 'getClientProjectWorkCodeActivities']);
$app->middleware($jwt)->get('/client/:clientId/project/:projectId/workcode/:workCodeId/activity/:activityId', [$ctrlActivity, 'show']);
$app->middleware($jwt)->post('/client/:clientId/project/:projectId/workcode/:workCodeId/activity/:activityId', [$ctrlActivity, 'update']);

/**
 * The otherwise method is used to handle un-matched requests, this endpoint returns a 404 error
 */
$app->otherwise(function(Request $req, Response $res) {
    $res->send(404, [
        'title' => 'Are you lost? ¿Estas perdido? Es-tu perdu?',
        'message' => "No endpoint was found matching the request path of: {$req->getPath()}"
    ]);
});
```

repository: pete-mann/php-express

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: pete-mann/php-express


text:
# Faction C2 Console

This is the web interface for Faction C2. It is built using [Vue](https://vuejs.org/)

## Installing and Running
This is installed by default through the stanard [Faction Install Process](https://www.factionc2.com/docs/#installing-faction). You should only have to manually install this if you'd like to modify it.

To install this manually:

1. Clone the repo
2. `npm install`
3. `npm run serve`

This will start up a development server running the console

By default, in a development environment, the console expects to be able to contact the API at http://localhost:5000/api/v1/, which means you'll have to run the API locally. If you'd like to change this behavior, edit the `.env.development` file.

repository: Static-Flow/Console

repo_name: Static-Flow/Console


text:
# Crux.Structs

Library providing structures representing objects from the [Discord API](https://discordapp.com/developers) and a few [utility](lib/structs/util.ex) functions.

## Useful links

 - [Documentation](https://hexdocs.pm/crux_structs/0.2.0/)
 - [Github](https://github.com/SpaceEEC/crux_structs/)
 - [Changelog](https://github.com/SpaceEEC/crux_structs/releases/tag/0.2.0/)
 - [Umbrella Development Documentation](https://crux.randomly.space/)

## Installation

The library can be installed by adding `crux_structs` to your list of dependencies in `mix.exs`:

```elixir
def deps do
  [
    {:crux_structs, "~> 0.2.0"}
  ]
end
```

license: MIT

gha_license_id: MIT


text:
## How to PDF text search API in JavaScript using ByteScout Cloud API Server

### Step-by-step tutorial on how to PDF text search API in JavaScript

We made thousands of pre-made source code pieces for easy implementation in your own programming projects. ByteScout Cloud API Server is API server that is ready to use and can be installed and deployed in less than 30 minutes on your own Windows server or server in a cloud. It can save data and files on your local server-based file storage or in Amazon AWS S3 storage. Data is processed solely on the API server and is powered by ByteScout engine, no cloud services or Internet connection is required for data processing. and you can use it to PDF text search API with JavaScript.

Want to save time? You will save a lot of time on writing and testing code as you may just take the JavaScript code from ByteScout Cloud API Server for PDF text search API below and use it in your application. This JavaScript sample code is all you need for your app. Just copy and paste the code, add references (if needs to) and you are all set! Complete and detailed tutorials and documentation are available along with installed ByteScout Cloud API Server if you'd like to learn more about the topic and the details of the API.

ByteScout Cloud API Server free trial version is available on our website. JavaScript and other programming languages are supported.

## Get In Touch

[Click here to get in touch](https://bytescout.zendesk.com/hc/en-us/requests/new?subject=ByteScout%20Cloud%20API%20Server%20Question)

or send email to [support@bytescout.com](mailto:support@bytescout.com?subject=ByteScout%20Cloud%20API%20Server%20Question)

## Free Trial Download

[Get Your 60 Day Free Trial](https://bytescout.com/download/web-installer?utm_source=github-readme)

## Web API (On-demand version)

[Get your free API key](https://pdf.co/documentation/api?utm_source=github-readme)

## API Documentation and References

[Explore ByteScout Cloud API Server Documentation](https://bytescout.com/documentation/index.html?utm_source=github-readme)

[Explore Web API Documentation](https://pdf.co/documentation/api?utm_source=github-readme)

[Check Free Training Sessions for ByteScout%20Cloud%20API%20Server](https://academy.bytescout.com/)

## Video Review

[https://www.youtube.com/watch?v=NEwNs2b9YN8](https://www.youtube.com/watch?v=NEwNs2b9YN8)

url: https://raw.githubusercontent.com/repohoarder/ByteScout-SDK-SourceCode/32dd9367cebb66e3aa16bd803798c026d7dfeed5/Cloud API Server/PDF Text Search API/JavaScript/PDF Text Search from File (Node js)/README.md

repository: repohoarder/ByteScout-SDK-SourceCode

repo_name: repohoarder/ByteScout-SDK-SourceCode


text:
---
layout: post
title: Standardization ado for Stata
date: 2015-08-06 16:00:00
description: Standardization ado for Stata
---

I often want to standardize my variables before using them in models. Especially if a variable either is heavily right-skewed then I like to log standardize the variable; e.g. number of protesters) or the coefficient of variable is uninterpretable anyways (then I tend to follow Gelman's (2008) approach; e.g. age and age^2 which results in very small coefficients in a regression). So far I generated such standardizations myself, e.g.:
```bash
gen log_protesters=log(protesters+1)
```
However, since I tend to be lazy and try to minimize the amount of syntax I produce, I programmed a small program called standard2 which creates three new variables for each variable specified after the command `standard2`:
```bash
standard2 variable1 variable2
```
It will then create three new variables for each variable specified, e.g. for variable1: std2_variable1 (variable1 standardized by 2 std. dev.); mc_variable1 (variable1 mean centered); log_variable1=log(variable1+1)).

The program can be downloaded as an stata ado file [here]({{ site.baseurl }}/assets/code/emdb.ado). You will need to unpack the .zip and copy the ado into your stata ado file directory (find a how to do: here).

gha_language: JavaScript


text:
# TradeTracker for Magento® 2

The TradeTracker Connect extension makes it effortless to connect your Magento® 2 catalog with the TradeTracker platform.

## Installation
To make the integration process as easy as possible for you, we have developed various plugins for your webshop software package.
This is the manual for installing the Magento® 2 Plugin.
Before you start up the installation process, we recommend that you make a backup of your webshop files, as well as the database.

There are 2 different methods to install the Magento® 2 extension.
1.	Install by using Composer
2.	Install by using the Magento® Marketplace (coming soon)
----
### Installation using Composer ###
Magento® 2 use the Composer to manage the module package and the library. Composer is a dependency manager for PHP. Composer declare the libraries your project depends on and it will manage (install/update) them for you.

Check if your server has composer installed by running the following command:
```
composer –v
```
If your server doesn’t have composer installed, you can easily install it by using this manual: https://getcomposer.org/doc/00-intro.md

Step-by-step to install the Magento® 2 extension through Composer:

1.	Connect to your server running Magento® 2 using SSH or other method (make sure you have access to the command line).
2.	Locate your Magento® 2 project root.
3.	Install the Magento® 2 extension through composer and wait till it's completed:
```
composer require tradetracker-com/magento2
```
4.	Once completed run the Magento® module enable command:
```
bin/magento module:enable TradeTracker_Connect
```
5.	After that run the Magento® upgrade and clean the caches:
```
php bin/magento setup:upgrade
php bin/magento cache:flush
```
6.  If Magento® is running in production mode you also need to redeploy the static content:
```
php bin/magento setup:static-content:deploy
```
7.  After the installation: Go to your Magento® admin portal and open _Stores_ > _Configuration_ > _Tradetracker_.
----
### Installation using the Magento® Marketplace ###
Available Soon

## Compatibility
The module has a minimum requirement of Magento 2.3 and PHP 7.1 and is tested on Magento version 2.3.x & 2.4.x.

branch_name: refs/heads/main


text:
# Go Calculator
A simple web application in Go which accepts math problems via the URL and returns the response in JSON.

---

By default, HTTP server runs on port 8080.

There are four endpoints, one for each basic math operation:
- `add`
- `subtract`
- `multiply`
- `divide`

All endpoints accept GET requests with two query string parameters: `x` and `y`.

Results are cached for 1 minute.

## How to run
`go run main.go`

## Run tests
`go test`

## Request

| Operation      | Example |
| ----------- | ----------- |
| add      | http://localhost:8080/add?x=2&y=2       |
| subtract   | http://localhost:8080/subtract?x=7&y=4 |
| multiply   | http://localhost:8080/multiply?x=6&y=5 |
| divide   | http://localhost:8080/divide?x=9&y=3 |

## Response
The HTTP server returns JSON response containing following fields:
- `action` - requested math operation
- `x` - first number for math operation
- `y` - second number for math operation
- `answer` - result of math operation
- `cached` - is cached result returned

Example:
```json
{
    "action": "divide",
    "answer": 3,
    "x": 9,
    "y": 3,
    "cached": true
}
```

# Test with curl
Request:
```
curl "http://localhost:8080/add?x=4&y=3"
```
Response:
```json
{"action":"add","answer":7,"x":4,"y":3,"cached":true}
```

# Dockerize web application
```
docker build -t calcserver .
docker run -p 8080:8080 calcserver
```

repository: slaven/go-calculator

repo_name: slaven/go-calculator


text:
# Svelte Datatable

## Contents

[Information](#information)
[Features](#features)
[Requirements](#requirements)
[Installation](#installation)
[Basic Usage](#basic-usage)
[Advanced Usage](#advanced-usage)

## Information

This project was created by the [Svelte REPL](https://svelte.technology/repl).

Data Table component was converted to Svelte from [MicroDroid/vue-materialize-datatable](https://github.com/MicroDroid/vue-materialize-datatable) project.

Paginate component was converted to Svelte from [https://github.com/lokyoung/vuejs-paginate](https://github.com/lokyoung/vuejs-paginate) project.

[See demo here at Heroku(slow)](https://safe-springs-35306.herokuapp.com/)

## Features
 - Sorting, with numerical sorting
 - Pagination - Client & Server Side
 - Fuzzy searching
 - Excel export
 - Printing
 - Custom topbar buttons
 - Flexible data-from-row extractor
 - Follows the Material Design spec
 - Limited support for IE 11(need Object.assign polyfill)

## Requirements
 - [`materialize-css`](https://www.npmjs.com/package/materialize-css) (and **NOT** any other MD library!)
 - Svelte

## Installation
```bash
yarn add svelte-datatable
# or
npm i svelte-datatable
```

There are currently some known issues with dependencies, so if you run into any problems, install `svelte-datatable` from this git repository with:

```bash
yarn add svelte-datatable@https://github.com/Kiho/svelte-datatable.git
```

## Basic Usage

```javascript
<script>
import { DataTable } from 'svelte-datatable'

// define some columns
let columns = [{
  label: "ID",    // "Pretty" column name
  field: "id",    // Field name from row object
  numeric: true,  // Affects sorting
  html: false     // Escapes output if false.
}, ..., ];

// define some rows of data
let rows = [{
  id: 'SomeValue' // This will match the column above and print a value in it
}, ..., ]
</script>

<!-- Import the materialize css/js here -->

<DataTable
  {columns}
  {rows}
/>
```

## Advanced Usage

This section is under construction - the best place to look for clues about advanced usage for this library is the `src/DataTable.svelte` file, which has a lot of `export let` statements. They should give you an idea about which props are available and what you can use them for.

repository: flex-dapps/svelte-datatable

gha_language: HTML

repo_name: flex-dapps/svelte-datatable


text:
---
layout: post
title: "Find IP of Network Share Host"
date: 2017-07-24 08:27
comments: true
categories:
---

Finding the IP address of a device on your network is generally an easy thing to do. This isn't always the case when the device is a network device or share using mDNS, also known as Bonjour on OSX.

If you know the network name of the device, you can use the `dscacheutil` to query the device and get it's IP address.

```
dscacheutil -q host -a name [network name].local
```

For example, I have a NAS on my network but the nas requires an older display connector that I generally don't keep around. Unfortunately it lives on a network to which we don't control the IP space. When the IP of the device changes, its not been so easy to find it's address. This is what I used to find it's IP.

```
$ dscacheutil -q host -a name storjnas.local
name: storjnas.local
ip_address: <IP_ADDRESS>
ip_address: <IP_ADDRESS>
```

repository: phutchins/octopress

extension: markdown

repo_name: phutchins/octopress


text:
# deadPix3l.github.io

A mostly useless blog about nothing. and everything. but mostly code.
A place where I can post what I want. A place where I can build a profile for myself, ramble about anything,
post all those rants I'm tired of repeating, and share my adventures (or lack there of.)

### Pull requests
Most unbecoming of a blog, I am open to suggestions, format changes, new features, and yes, even posts.
If you have features, revisions to current posts, or new posts that you think are interesting,
please submit a pull request. Please cite yourself as the author in any new posts.
I dont expect anybody will actually do this (because why not make your own blog?),
but I will review all pull requests.

### Acknowledgements
This blog was made using Github Pages and the Monochrome theme from "The Review Index."
A few minor modifications have been made to the theme, including slimming down a lot of the code,
and post-specific color changing headers, among other things.

#### License
Released under [MIT License](license.md).


text:
# hello, friend

this repo includes shell scripts that will help you deploy a few different types of static projects to an AWS S3 bucket.

**requirements**

- ruby, something recent pls (2.0.x, 2.1.x, etc)
- [s3_website gem](https://github.com/laurilehmijoki/s3_website)
- [git-crypt](https://github.com/AGWA/git-crypt)
- a project of one of the types i've covered
- your project is in a git repo

repository: slothelle/tinkerbot

repo_name: slothelle/tinkerbot


text:
# Interpreter for X
Interpreter for a functional programming language X written using a functional programing language "Racket". X supports higher order function and lexical scoping using closure. This X interpreter expects a Abstract Syntax Tree created from parsing a program written in X.

## How to Run
Load the files in [Dr.Racket](https://racket-lang.org/download/) and click run.

Read more from my [blog-post](http://www.saifulabu.me/2017/12/writing-and-interpreter-for-x-in-racket.html)


text:
# Primitive Types

- Primitive values aren't object, and have no methods\*
- Six primitive types in JS:
  - null
  - underfined
  - boolean
  - number
  - string
  - symbol ES2015: the name of the symbol is equal to it's value
- Everything else extends from: Object
- Object is mutable values, everything else is immutable
- Auto-Boxing
  - When cnecessary, primitive types are "wrapped" by identically-named Objects, and then back to their primitive types again.

# Declaration:

- var declarations **ARE** hoisted, and **ARE NOT** block-scoped, belong to the function or global scope they're defined in
- let declarations **ARE NOT** hoisted, and **ARE** block-scoped, belong to the block scope they're defined in
- const declarations **ARE NOT** hoisted, re-assignment is not allowed, does NOT mean "immutable value"
- Recommended practice: for mutable values, use with Object.freeze

|          | var      | let   | const |
| -------- | -------- | ----- | ----- |
| Reassign | ✅       | ✅    |
| Scope    | function | block | block |
| hoisted  | ✅😫     |

# Type Conversion

- The + operator, when used with strings, converts all other operands to strings
  30 + 7; // 37 '37' + 7; // '377' '37' - 7; // 30
- the unary + operator converts the operand to a Number
  (+ '37'); // 37 (+ false); // 0

# Explict Typing:

- let x:number = 33;
- let input = document.querySelector('input#name_field') as HTMLInputElement;
- let input = <HTMLInputElement>document.querySelector('input#name_field'); // doesn't mix well with JSX

- function login(username: string, password: string) : User {}
- const login = (username: string, password: string) : User => {}

# Type Systems & Tupe Equivalence

- Nominal Type Systems & Structural Type Systems

# Class

- Enums, number of members Object.keys(Suit).length / 2

* Array, Tuples, Type Aliases, Getter & Setter
* Function


text:
# SpectrumImageAnalysisPy
Python code to analyze 3D spectrum images obtained with electron energy loss spectroscopy or cathodoluminscence. Routines include navigation of the 3D dataset and extraction of either spectra or energy selected maps, Richardson-Lucy deconvolution of EELS data, spectrum and image alignment.

Documentation branch

Please reference as:

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

If using Richardson-Lucy deconvolution algorithm, please reference the following for this:

E. P. Bellido, D. Rossouw, and G. A. Botton, “Toward 10 meV Electron Energy-Loss Spectroscopy Resolution for Plasmonics,” Microscopy and Microanalysis, vol. 20, no. 03, pp. 767–778, Jun. 2014.
DOI: 10.1017/S1431927614000609

The code can be used by cloning the git repository and, if desired, adding the files to the system's Python Path to allow import of the different options in the library. The code can be run through interactive Python commands in a terminal or notebook, or through Python scripting.

repository: icbicket/SpectrumImageAnalysisPy

repo_name: icbicket/SpectrumImageAnalysisPy


text:
# Tortuga Chain

Tortuga Chain is based around the concept of database-reflection. Rather than using mapping files, it interrogates the database for its schema. Then it generates the SQL based the intersection between the tables and classes.

## Supported Databases

Full support is offered for:

* SQL Server
* MySQL
* PostgreSQL
* SQLite
* Microsoft Access (.NET Framework Only

Chain also supports any database that offers an ADO.NET provider, but without the database reflection and SQL generation capabilities.

ADO.NET requires the writing of SQL, which is often database specific.

## Libraries

Full Database Reflection Support

* SQL Server:
  * Using System.Data.SqlClient [Tortuga.Chain.SqlServer](https://www.nuget.org/packages/Tortuga.Chain.SqlServer)
  * Using Microsoft.Data.SqlClient [Tortuga.Chain.SqlServer.MDS](https://www.nuget.org/packages/Tortuga.Chain.SqlServer.MDS)
  * Using OleDB  [Tortuga.Chain.SqlServer.OleDb](https://www.nuget.org/packages/Tortuga.Chain.SqlServer.OleDb)
* SQLite: [Tortuga.Chain.SQLite](https://www.nuget.org/packages/Tortuga.Chain.SQLite)
* PostgreSql: [Tortuga.Chain.PostgreSql](https://www.nuget.org/packages/Tortuga.Chain.PostgreSql)
* Access: [Tortuga.Chain.Access](https://www.nuget.org/packages/Tortuga.Chain.Access)
* MySql: [Tortuga.Chain.MySql](https://www.nuget.org/packages/Tortuga.Chain.MySql)

Result-set Mapping Only

* Odbc: [Tortuga.Chain.Odbc](https://www.nuget.org/packages/Tortuga.Chain.Odbc)
* OleDb: [Tortuga.Chain.OleDb](https://www.nuget.org/packages/Tortuga.Chain.OleDb)
* Other: [Tortuga.Chain.Core](https://www.nuget.org/packages/Tortuga.Chain.Core)

## Setup

Chain internally handles connections using a thread-safe `DataSource` object. Normally only one `DataSource` is created per connection string so that database schema can be cached.

    PrimaryDataSource = new SqlServerDataSource(connectionString);

## Documentation and Tutorials

* [Quick Start](https://docevaad.github.io/Chain/Introduction.htm)
* [Primary Documentation](https://docevaad.github.io/Chain/)

## Bug Reporting

Issues should be logged in the [docevaad/Chain repository](https://github.com/docevaad/Chain/issues).

## Licensing

Tortuga Chain is offered under the [MIT License](https://github.com/docevaad/Chain/blob/master/License.txt).

license: Unlicense

repository: mikependon/DotNet-ORM-Cookbook

gha_license_id: Unlicense

repo_name: mikependon/DotNet-ORM-Cookbook


text:
[![Build Status](https://secure.travis-ci.org/deepdancer/deepdancer.png)](http://travis-ci.org/deepdancer/deepdancer)

**Looking for the [documentation](https://deepdancer.github.io/deepdancer-documentation/)**?

Intentions
===

A dependency injections system that:

* Requires only a light configuration
* Fallbacks to loading a module when a key is not declared
* Has its dependencies declared inside the modules (to reduce the probability
to miss an update)
* Support the overriding of the dependencies (for the purpose of testing)
* In my usecase, most if not all of my dependencies are named according to the
path of the module they contain. So far you should be able to name your
dependencies the way you want.

http://xkcd.com/927/

Similar project: https://github.com/nicocube/knit

repository: deepdancer/deepdancer

repo_name: deepdancer/deepdancer


text:
![CI](https://github.com/LesnyRumcajs/grpc_bench/workflows/CI/badge.svg)

One repo to finally have a clear, objective gRPC benchmark with code for everyone to verify and improve.

Contributions are most welcome!

# Prerequisites
Linux or MacOS with Docker. Keep in mind that the results on MacOS may not be that reliable, Docker for Mac runs on a VM.

# Running benchmark
To build the test images, run: `./build.sh` . You need them to run the benchmarks.

To run all the benchmarks, run: `./bench.sh` . They will be run sequentially.

To run a single benchmark, run: `./run_single_bench.sh <BENCHMARK_NAME>` .

To clean-up the test images, run: `./clean.sh` .

## Configuring the benchmark
Test duration is governed by environmental variable `GRPC_BENCHMARK_DURATION`. Defaults to `30s`.

The maximum number of cpus used by server is governed by the environmental variable `GRPC_SERVER_CPUS`. Defaults to `1`.

Which tests to run is governed by a regex in `GRPC_BENCHMARK_SELECT`, for example `rust` or `(kotlin|java)`. Defaults to all tests.

# Results
You can find our sample results in the [Wiki](https://github.com/LesnyRumcajs/grpc_bench/wiki). Be sure to run the benchmarks yourself if you have sufficient hardware, especially for multi-core scenarios.


text:
---
layout: default
---

# 1998-11-03 - Re: VANGUARD:  An Election About Nothing? (fwd)

## Header Data

From: Bill Stewart<EMAIL_ADDRESS>To: Eric Murray<EMAIL_ADDRESS>Message Hash: 47d37b104aab01fea606dab2ef52d3d3ffd641da067c0b00f580b6ea5a04db8c

Message ID<EMAIL_ADDRESS>Reply To<EMAIL_ADDRESS>UTC Datetime: 1998-11-03 23:58:22 UTC

Raw Date: Wed, 4 Nov 1998 07:58:22 +0800

## Raw message

```
{% raw  %}From: Bill Stewart<EMAIL_ADDRESS>Date: Wed, 4 Nov 1998 07:58:22 +0800
To: Eric Murray<EMAIL_ADDRESS>Subject: Re: VANGUARD:  An Election About Nothing? (fwd)
In-Reply-To<EMAIL_ADDRESS>Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

At 09:00 AM 11/3/98 -0800, Eric Murray wrote:
>The Natural Law people are so wierd that it's very tempting to vote for them,

One reason their rhetoric looks so weird is because it's avoiding
coming straight out and saying "Our plan for fixing society is to have
the government fund teaching of Transcendental Meditation(r) to everybody,
and once everybody is doing TM, they'll all be healthier, better behaved,
and will do things in accordance with The Laws Of Nature As Taught By
the Maharishi Mahesh Yogi, so the problems of the world will all fix themselves."
Meanwhile, of course, they describe their national health plans as using
"Proven Scientific Principles" (TM having been proven to fix everything)
and their education plans using similar obfuscatory rhetoric.
(On the other hand, I haven't heard them saying that the TM-Siddhi program
will let them replace the Air Force with levitation yet;
they tend to take the view that calmness and niceness will scientifically
reduce the need to shoot people, which I can't fault them for too much...)

It's basically a wimpier version of traditional Western moral reformers
pushing the view that if government gets rid of Sin, society will work better,
but getting rid of ignorance is usually a "kinder, gentler" process,
not that you want to tell the ignorant what you're doing,
because they may think that offering fruit and flowers to a guru's picture
and chanting the name of a fire-god while breathing quietly
is not only a strange way to fix ignorance but is an inappropriate thing
for governments to spend their money on, especially in the name of Science.

Most of the Natural Law Party candidates I've talked to, except when
they're on direct meditation-revenue-enhancement topics, tend to be
reasonable folks, somewhere in the liberal-to-libertarian range,
thinking the government should mostly let people do what they want,
which will naturally lead to calmness and niceness as they follow
natural law, and a lot of the TM folks, especially around
Maharishi University in Iowa, have gone into business for themselves,
so they prefer lower government interference and red tape.

On the other hand, like any small party trying to get enough candidates
to run full slates for office, some of their folks really are flakes :-)
I like to believe that Libertarians do better on that score,
but we've got our share as well, and the only real way out of it
is to grow large enough that the supply of people willing to run
includes enough competent people.

On the other hand, it's still tempting to see about putting Frank Zappa
on the ballot.  He is a bit metabolically challenged these days,
but it wouldn't bother him much, and he's still be a better candidate
than most live Democrats or Republicans.
				Thanks!
					Bill
Bill Stewart<EMAIL_ADDRESS>PGP Fingerprint D454 E202 CBC8 40BF  3C85 B884 0ABE 4639

{% endraw %}
```

## Thread

+ Return to [November 1998](/archive/1998/11)

+ Return to "[Bill Stewart <bill.stewart@pobox.com>](/authors/bill_stewart_bill_stewart_at_pobox_com_)"
+ Return to "[Eric Murray <ericm@lne.com>](/authors/eric_murray_ericm_at_lne_com_)"
+ Return to "[Jim Choate <ravage@einstein.ssz.com>](/authors/jim_choate_ravage_at_einstein_ssz_com_)"

+ 1998-11-03 (Tue, 3 Nov 1998 22:13:44 +0800) - [VANGUARD:  An Election About Nothing? (fwd)](/archive/1998/11/2d371519bda74946a2a051fdc6bba2692b9e555338acd795de28980f6038757d) - _Jim Choate<EMAIL_ADDRESS>  + 1998-11-03 (Wed, 4 Nov 1998 01:55:43 +0800) - [Re: VANGUARD:  An Election About Nothing? (fwd)](/archive/1998/11/b07d4997c6d8e0fa58c365409d3862936c9993e9ad4234cb37f16359d9d5a71b) - _Eric Murray<EMAIL_ADDRESS>  + 1998-11-03 (Wed, 4 Nov 1998 07:58:22 +0800) - Re: VANGUARD:  An Election About Nothing? (fwd) - _Bill Stewart<EMAIL_ADDRESS>


text:
# Baseline solutions for the MLHEP-2020 muon identification challenge

[`Baseline - simple.ipynb`](https://github.com/yandexdataschool/IDAO-2018-muon-id/blob/master/Baseline%20-%20simple.ipynb) contains a naive xgboost solution

`scoring.py` contains an implementation of the quality metric

`utils.py` contains data reading and jagged arrays processing utilities


text:
### tuktu.social.generators.FacebookGenerator
Gets posts containing keywords or from specific users from a given time interval.

  * **nodes** *(type: array)* `[Optional]`
  - Optionally specify on which nodes to run and how many instances you want on each node.

    * **[UNNAMED]** *(type: object)* `[Required]`

      * **type** *(type: string)* `[Required]`
      - The type of node handler, one of SingleNode, SomeNodes, AllNodes (leave empty for local execution)

      * **nodes** *(type: string)* `[Required]`
      - The nodes to use for this node handler type

      * **instances** *(type: int)* `[Optional, default = 1]`
      - The amount of instances per node of this handler type

  * **result** *(type: string)* `[Required]`

  * **stop_on_error** *(type: boolean)* `[Optional, default = true]`
  - If set to false, Tuktu will not kill the flow on data error.

  * **config** *(type: object)* `[Required]`

    * **credentials** *(type: object)* `[Required]`

      * **access_token** *(type: string)* `[Required]`
      - The token to access Facebook's API with.

    * **filters** *(type: object)* `[Required]`

      * **users** *(type: array)* `[Optional]`
      - The users (given by their Facebook user id) from which to get everything from their feed, independently from keywords above.

        * **[UNNAMED]** *(type: string)* `[Required]`
        - Facebook user id.

    * **update_time** *(type: long)* `[Optional, default = 5]`
    - Time in seconds between requests, if applicable.

    * **interval** *(type: object)* `[Optional]`
    - Time interval to collect data for.

      * **start** *(type: long)* `[Optional]`
      - Timestamp of start time of time interval to collect data for. Can be left empty. If a start-time is given, everything from that time on will be fetched. If it is omitted the current time is assumed.

      * **end** *(type: long)* `[Optional]`
      - Timestamp of end time of time interval to collect data for. Can be left empty. If an end-time is given, everything until that time will be fetched. If it is omitted, no end time is assumed and everything will be fetched perpetually.

repository: dmassart/Tuktu

repo_name: dmassart/Tuktu


text:
# gitChangelog

[![GitHub release](https://img.shields.io/github/v/release/DigiLive/gitChangelog)](https://github.com/DigiLive/gitChangelog/releases)
[![License](https://img.shields.io/badge/License-BSD%203--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)
[![Codacy Badge](https://app.codacy.com/project/badge/Grade/7f0447563661494daac0c4fae4335ac0)](https://www.codacy.com/gh/DigiLive/gitChangelog/dashboard?utm_source=github.com&utm_medium=referral&utm_content=DigiLive/gitChangelog&utm_campaign=Badge_Grade)

Generate a changelog from git commits of the local repository.

This library parses information which is stored in a Git repository. From this
information, it generates a changelog which can be saved to a file. The
information is extracted from the branch which is currently checked out.

Take a look at this [example](CHANGELOG.md). It is the changelog of the
GitChangelog repository, build by this library.

If you have any questions, comments or ideas concerning this library, Please
consult the [Wiki](https://github.com/DigiLive/gitChangelog/wiki) at first.
Create a new [issue](https://github.com/DigiLive/gitChangelog/issues/new) if
your concerns remain unanswered.

## Features

### Main

* Markdown and Html renderers included.

* Choose included renderers or create your own.

* List Tags and their date.

* List unique commit titles per tag.

* List commit hashes per unique title (optional).

* Include commit titles (and hashes) of the HEAD revision (E.g. Unreleased
  changes).

### Other

* Use another local repository as information source.
* Set a tag range to limit the changelog.
* Filter titles by labels1.
* Set a custom title for the changelog (E.g. a header).
* Set a custom title for the HEAD revision (E.g. Next release version).
* Set a custom date for the HEAD revision (E.g. Next release date).
* Set a custom message to indicate there are no commits present.
* In- or exclude merge commits.
* Set an ordering key for sorting tags/releases2.
* Set the sort order of tags/releases.
* Set the sort order of titles.

1. A label is considered to be the first word of a commit title.

2. Using an invalid key will result in unlisted changes or when enabled, just
   the changes of the HEAD revision.

#### Markdown Renderer

* Define a custom format for Tag/Release lines.

* Define a custom format for title lines.

* Format hashes into links to the commit-view of the remote repository provider.

* Format issues into links to issue-tracker of the remote repository provider.

* Format issues into links to merge-request (aka pull-request) view of the
  remote repository provider.

#### Html Renderer

* Format hashes into links to the commit-view of the remote repository provider.

* Format issues into links to issue-tracker of the remote repository provider.

* Format issues into links to merge-request (aka pull-request) view of the
  remote repository provider.

## Installation

The preferred method is to install the library
with [Composer](http://getcomposer.org).

```sh
> composer require digilive/git-changelog:^2
```

Set the version constraint to a value which suits you best.
Alternatively you can download the latest release
from [GitHub](https://github.com/DigiLive/gitChangelog/releases).

## Minimal Example use

```php
<?php

use DigiLive\GitChangelog\Renderers\MarkDown;

// Use composer's auto loader.
$requiredFile = 'Path/To/vendor/autoload.php';

// Or include the library manually.
// $requiredFile = 'Path/To/MarkDown.php';

require_once $requiredFile;

// Instantiate the library's renderer.
$changelog = new MarkDown();
// Build and get the changelog with all options set to default.
$changelog->build();
$content = $changelog->get();
```

## Notes

* Some options can be changed directly by setting a public property.
  **(Setting a value of an invalid type, might result in unexpected results.)**

* Others have to be set by calling a method.

## Commit guidelines

In order to create a good changelog, you should follow the following guidelines:

* Commit messages **must** have a title line and may have body copy. These must
  be separated by a blank line.

* The title line **must not** exceed 50 characters.

* The title line should be capitalized and **must not** end in a period.

* The title line **must** be written in an imperative mood (Fix, not Fixed /
  Fixes etc.).

* The body copy **must** be wrapped at 72 columns.

* The body copy **must** only contain explanations as to what and why, never
  how. The latter belongs in documentation and implementation.

repository: DigiLive/gitChangelog

gha_language: PHP

repo_name: DigiLive/gitChangelog


text:
Title: Success Stories
license: https://www.apache.org/licenses/LICENSE-2.0

### Success Stories

#### [![Travellinck](../images/travellinck_logo.jpg)](https://travellinck.com)

The company that I used to work for, Travellinck (a corporate travel
integration and automation tool), uses River in production.

Since 2012, all long-running / reliable processes (e.g. Travel approval,
which has highly flexible rules and per-client integration requirements
into corporate ERP and accounting systems, etc) has been running on a
system that I led the development of. It is implemented according to the
Blackboard pattern, which provides enormous flexibility.

Persistent JavaSpace provides strong reliability in the face of client
and supplier outages, which happen surprisingly frequently. For example,
some of our clients would literally shut their ERP systems down for
backups twice a week, but urgent travel-related approvals happen 24
hours per day via various comms channels: E-mail, Mobile phone text
messages, and the web.

This is still going strong.

It was an interesting journey. River and Rio are wonderful technologies,
but we had our fair share of complexities with the Blackboard pattern
implementation (and how to reason about the resulting business
processes) and, more importantly, we had huge issues from time to time
with the JavaSpace implementation itself.

We started with Persistent Outrigger, and then moved to a port of Blitz
(which has been adapted to be provisioned as a Rio service). It took us
a long time to figure out how to configure Blitz, and how to remove all
"memory leaks" in our process - i.e. Entries that never get cleaned up
over time - to achieve a stable system.

But once stable, this has been running for years with basically no
maintenance

Dawid Loubser

#### [![Blazegraph](../images/blazegraph_logo.png)](https://www.blazegraph.com)
Blazegraph™ is a ultra high-performance graph database supporting Apache TinkerPop™ and RDF/SPARQL APIs.
It supports up to 50 Billion edges on a single machine.

#### [![GigaSapces](../images/gigaspaces_logo.png)](https://www.gigaspaces.com)
GigaSpaces provides the leading in-memory computing platform for fast data analytics and extreme transaction processing.

#### [![Sucden Financial Limited](../images/sucden_logo.jpg)](http://www.sucdenfinancial.com)

 Sucden Financial Limited develops
 its own futures and options trading system called STAR, built
 primarily on the Java and Jini (Apache River) technologies.

 The development of the system began when I joined Sucden almost ten
 years ago, beginning with connection to the Liffe derivatives
 exchange. It soon became the company’s primary trading system, and
 connectivity to the ICE and LME exchanges quickly followed.

 With many local and remote users and ever increasing trading volumes,
 the typically n-tier architecture was difficult to upgrade, suffered
 from problems with scalability and was very susceptible to
 communications failures between it and the exchange host systems.

 In 2006 we started a project to migrate to a service oriented
 architecture, specifically choosing Jini as a 100% Java solution. Jini
 had been around for a long time and I always thought it held great
 promise for our kinds of application, which needed very high
 throughput and fault tolerance – we (myself, Phil Harron and Hector
 Angel), were itching to use it for something useful. We hired IncaX
 consultants Phil Bishop and Nigel Warren to help us get going on the
 project. In 2007, Tom Hobbs and Ian Wood joined us and we began
 building all kinds of service management tools and infrastructure to
 encapsulate the complexities of Jini. A new kind of STAR was finally
 born early in 2009.

 Jini has allowed us to move all our business logic into services,
 allowing for superb scalability, redundant exchange connections, and
 fault tolerant patterns which enable us to upgrade and perform
 maintenance in a live scenario. The system can monitor itself and
 alert support staff of problems automatically.

 To visualize and manage the entire system, we built an application on
 the Netbeans platform
 where we can immediately see the interaction between services and generally monitor
 the health of the system as a whole. This is an ideal platform on
 which to present the Jini service UIs.

 We are looking forward to upgrading to the Apache River code in 2011
 and hope that the renewed efforts on this open source project will
 help to spread the word about this excellent technology far and wide."

Mark Phipps
Front Office Development Manager, Sucden Financial Limited.

#### Blitz
A performant, persistent implementation of the JavaSpaces API, which is much more suitable for enterprise-grade use
than the (in-memory only) reference implementation, Outrigger [see here](https://github.com/dancres/blitzjavaspaces).

A re-packaging of the Blitz project to build with Maven is available [here](https://github.com/DawidLoubser/blitz-javaspaces-modularised).
 It makes easy to provision a reliable, persistent JavaSpace with Rio.

#### Rio
[Rio](http://www.rio-project.org)  is an open source technology that provides a dynamic architecture for developing, deploying and managing distributed systems composed of services.

Rio turns a network of compute resources into a dynamic service, providing a policy based approach for fault detection and recovery, scalability and dynamic deployment. Key to the architecture are a set of dynamic capabilities and reliance on policy-based and SLA mechanisms.

Developing services for use with Rio is simple. Rio provides a non-intrusive model that removes the complexity surrounding service development and deployment.

Key features include:

  1. Dynamic architecture for distributed systems
  1. Built-in fault detection and recovery for your services
  1. Policy based SLA enforcement
  1. Support for external systems, encapsulate the control and monitoring of other frameworks
  1. Built-in support for Maven artifact resolution at deploy time
  1. Extensible service development & deployment support:
      1. POJOs
      1. Spring
      1. Maven based artifact resolution

#### JGDMS - Java Global Discovered Micro Services
The [github code](https://pfirmstone.github.io/JGDMS/) is forked off River trunk, just before the Ivy dependency build
changes and the 3.0 release was branched.

Additions include:

   * Atomic input validation for java serialization
   * IPv6 Multicast Discovery (registered with IANA)
   * TLSv1.2 cyphers with perfect forward secrecy, changes to security constraints, old strong cypers from
   2004 vintage now considered weak, unsafe cyphers have been removed
   * New registrar methods that allow authentication prior to proxy download and delayed unmarshalling, support
   added to ServiceDiscoveryManager without changing public API
   * Improved support for Java 9
   * com.sun.jini compatibility layer (deprecated) API based on Rio's usage
   * Work on Maven modular build is in progress

As soon as River community decides these improvements can be integrated back.

#### Jini Success Stories
 - Original Jini.org success stories, including:
     1. [European Patent Office, The Netherlands](http://www.epo.org/)
     1. [Magneti Marelli Motorsport, Italy](http://www.magnetimarelli.com/racing/racdwn.htm)
 - [Jan Newmarch's Guide to Jini Technologies](http://jan.newmarch.name/java/jini/tutorial/Overview.html#Success%20Stories) contains a section on Jini successes

repository: apache/river-site

repo_name: apache/river-site


text:
## InterText HYPH: Hyphenation

<!-- START doctoc generated TOC please keep comment here to allow auto update -->
<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->
**Table of Contents**  *generated with [DocToc](https://github.com/thlorenz/doctoc)*

- [InterText HYPH: Hyphenation](#intertext-hyph-hyphenation)

<!-- END doctoc generated TOC please keep comment here to allow auto update -->

Implemented with [`mnater/hyphenopoly`](https://github.com/mnater/Hyphenopoly).

* `INTERTEXT.HYPH.hyphenate = ( text ) ->`: return the text with soft hyphens (U+00ad) inserted. For
  languages other than US English, `INTERTEXT.HYPH.new_hyphenator = ( settings ) ->` may in a future version
  be used to obtain a custom hyphenation function.

* `INTERTEXT.HYPH.count_soft_hyphens = ( text ) ->`: Count occurances of U+00ad in `text`.

* `INTERTEXT.HYPH.reveal_hyphens = ( text, replacement = '-' ) ->`: Replace all soft hyphens with
  `replacement`.

repository: loveencounterflow/intertext

gha_language: CoffeeScript

repo_name: loveencounterflow/intertext


text:
# bash-music
CLI utility for playing an arbitrary mp3 anytime you run a bash function for the duration of the function call.

To use:
- download an mp3 (e.g., the Succession theme song or the Jeopardy track)
- update the `MUSIC_PATH` variable in the `setup.sh` file to the location of your downloaded file
- either `source` the file or add it to your `~/.bashrc`
- update the `WHITELIST` with whatever commands you prefer

*Note*: if you don't like seeing the terminated message, run `set +m` to suppress it

repository: cicdw/bash-music

repo_name: cicdw/bash-music


text:
## Notes on Julia

```
brew tap staticfloat/julia
brew install --HEAD --64bit julia
```

In `.emacs`:

```
(setq inferior-julia-program-name "/usr/local/bin/julia")
```

---

On linux, installed by downloading `.sh` file with "generic linux
binaries", extracted to `/usr/local/src`, and put symbolic link to
`/usr/local/src/julia-1.1.0/bin/julia` in `/usr/local/bin`

---

Installing packages:

```
Pkg.update()
Pkg.add("Distances")
Pkg.clone("https://github.com/sens/FaSTLMM.jl.git")
```

---

run script from within Julia:

```
include("lmmtest.jl")
```

---

To enable use in jupyter notbooks:

```
using Pkg
Pkg.add("IJulia")
```

repository: eikemq/ProgrammingNotes

gha_license_id: NOASSERTION

repo_name: eikemq/ProgrammingNotes


text:
### [CVE-2022-23764](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2022-23764)
![](https://img.shields.io/static/v1?label=Product&message=WebCube&color=blue)
![](https://img.shields.io/static/v1?label=Version&message=<IP_ADDRESS>%3C%<IP_ADDRESS>%20&color=brighgreen)
![](https://img.shields.io/static/v1?label=Vulnerability&message=CWE-346%20Origin%20Validation%20Error&color=brighgreen)

### Description

The vulnerability causing from insufficient verification procedures for downloaded files during WebCube update. Remote attackers can bypass this verification logic to update both digitally signed and unauthorized files, enabling remote code execution.

### POC

#### Reference
No PoCs from references.

#### Github
- https://github.com/karimhabush/cyberowl

repository: trickest/cve

repo_name: trickest/cve


text:
# data-collection-monitor #
Data collection for UCSB SNL servers.
```console
usage: snl-monitor [-h] [-s TIMESTEP] [-p]
                   [--pruning-frequency PRUNING_FREQUENCY]
                   [--pruning-threshold PRUNING_THRESHOLD]
                   db

positional arguments:
  db                    Location of the database where packet loss data will
                        be stored.

optional arguments:
  -h, --help            show this help message and exit
  -s TIMESTEP, --timestep TIMESTEP
                        How often to poll for new stats, in seconds.
  -p, --prune           Prune old entries from the database.
  --pruning-frequency PRUNING_FREQUENCY
                        How often to prune outdated records from the table, in
                        multiples of the timestep.
  --pruning-threshold PRUNING_THRESHOLD
                        Minimum age for records to be kept while pruning old
                        records, in seconds.
```

## Installation ##
The application is built using `setuptools`, `wheel`, and a build tool such as
`build`. After installing `build`, `setuptools`, and `wheel`, run:
```console
$ python3 -m pip install .
```
You will then be able to run the application as `snl-monitor`.

## Development ##
Set up for development with:

```console
$ python3 -m pip install -e .
```

## Dependencies ##
- [`psutil`](https://pypi.org/project/psutil/)

repository: SwiftWinds/data-collection-monitor

repo_name: SwiftWinds/data-collection-monitor


text:
# Transform-Console

A stream-based logger implemented as a transform to peek into arbitrary parts of complex stream pipelines.

## Installation

### Node.js

For *Node.js*, use `npm`:

````console
npm install transform-console
````

..then `require` Transform-Console:

````javascript
var TransformConsole = require('transform-console');
````

## Quick Example

````javascript
var myLogger = new TransformConsole({
	objectMode: true,
	console: {
		dataLogger: function(data) {
			console.log('myLogger -', data);
		},
		events: ['finish']
	}
});

myLogger.write({val: "testing"});
myLogger.write("testing");
myLogger.write([1, 2, 3]);

myLogger.end();
````

You will see the following logged to your console:

````javascript
myLogger - { val: "testing" }
myLogger - "testing"
myLogger - [1, 2, 3]
finish
````

## API

#### `TransformConsole(options)`

* `options` Standard stream options object that can also include an optional `console` object. See below for more on the `console` object.

##### options.console

`dataLogger` Function(chunk, encoding)

Specify to log the contents of `chunk` (Object, Buffer, or string).

`eventLogger` Function(name, eventData)

Specify to log the events specified in the `events` array.

`events` Array of strings

List of events to listen for and log.

## License - MIT

> Copyright (C) 2013 Jon-Carlos Rivera
>
> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
>
> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
>
> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

repository: imbcmdth/transform-console

repo_name: imbcmdth/transform-console


text:
# Download DeepMind's Kinetics

Download all videos from DeepMind's [Kinetics dataset](https://deepmind.com/research/open-source/open-source-datasets/kinetics/).
Moreover, you can use this library to extract **frames** and **sound track** from videos, generate metadata for training
and pack all sound tracks into a single **tfrecords** file for faster reading.

## Requirements

* Python >= 3.4
* youtube-dl
* ffmpeg
* gzip

Required Python packages are listed in **requirements.txt**.

## Usage

**WARNING:** Before you start any download from YouTube, please be sure, that you have checked [YouTube Terms Of Service](https://www.youtube.com/static?template=terms) and you are compliant. Especially check section 5.H.

**Download all videos**:
```
python download.py --all
```

**Download specific classes**:
```
python download.py --classes 'pole vault' 'blowing glass'
```

List all classes:
```
python list_classes.py
```

**Download specific categories**:

Categories are defined as described in **[1]**. However, 14 classes were not present
in any category, therefore, I added them under the category "custom".

```
python download.py --categories 'arts and crafts' cooking
```

List all categories and classes that belong to them:
```
python list_categories.py
```

**Extract frames from videos**:

Extracting frames from the video files is useful because loading mp4 files
during training is time-consuming. Additionally, current Neural Networks are
usually training on a small subset of video frames from each video making it wasteful to
load the whole video.

```
python videos_to_frames.py --all
```

The script uses VideoCapture from the **OpenCV** library. If you installed the library
using `pip install opencv-python` it will not work because video-related functionality
is not supported in this build ([see this stackoverflow question](https://stackoverflow.com/questions/21792909/cv2-videocapture-open-always-returns-false)).
You will need to build [OpenCV](https://github.com/opencv/opencv) with video-related functionality enabled to use this script.

**Extract sound tracks from videos**:

```
python videos_to_sound.py --all
```

**Create metadata**:

Although it would be ideal to have the whole dataset available, a fraction of videos has been delete from
YouTube since Kinetics was released. Furthermore, not all videos contain a sound track and frame extraction might fail for some videos.
For this reason, it is convenient to generate metadata that keep track of all successfully downloaded videos.

You can generate metadata for videos (.mp4 files), video frames or sound tracks. You will need to generate
metadata for sound tracks if you want to pack them into a tfrecords file (see below).

Generate metadata for videos:

```
python create_meta.py videos --sets 400 --save resources/kinetics_videos
```

Generate metadata for video frames:

```
python create_meta.py frames --sets 400 --save resources/kinetics_video_frames
```

Generate metadata for sound tracks:

```
python create_meta.py sound --sets 400 --save resources/kinetics_sound
```

The **--sets** switch dictates how many classes will be included in the metadata.
Example use case: we want to select the hyper-parameters of our neural networks on a small subset
of Kinetics (let's say 50 from the 400 classes) and then train the neural network on the whole
dataset. Therefore, we will call `python create_meta.py frames --sets 50 400 --save resources/kinetics_video_frames`
to generate metadata for 50 randomly chosen classes and for all 400 classes.

**Convert sound tracks into a tfrecords file**:

Loading mp3 files in Tensorflow (as of version 1.3.0) creates a severe bottleneck for the training speed.
It is convenient to pack all mp3 files into a single tfrecords file and load the tfrecords file during training.

Example:

```
python sound_to_tfrecords.py train resources/kinetics_sound_400_train.json resources/kinetics_sound_400_classes.json dataset/kinetics_400_train_sound.tfrecords
```

Note:

First, you will need to generate metadata for sound tracks.

**Other scripts**:

Download statistics (e.g. fraction of videos downloaded):

```
python download_stats.py
```

Video statistics (e.g. histogram of video resolutions):

```
python video_stats.py
```

## Download structure

The training and validation videos are downloaded into their individual directories.
Furthermore, a directory is created for each class.

Example:

```
dataset/train/blowing_glass
dataset/valid/blowing_glass
```

Test videos are all downloaded into a single directory because their classes are not known.

Example:

```
dataset/test
```

### File names and video format

The videos are all download in mp4. If a video isn't available in mp4, it's downloaded in
 the next best format and converted into mp4. All videos are downloaded with sound.

Videos' file names correspond to their YouTube IDs. All spaces in directory names are replaced with
underscores (e.g. blowing glass => blowing_glass).

## Contributors

* [Ondrej Biza](https://github.com/ondrejba)

## Acknowledgements

The sound to tfrecords script is based on [this tutorial](http://warmspringwinds.github.io/tensorflow/tf-slim/2016/12/21/tfrecords-guide/).

## References

* [[1] The Kinetics Human Action Video Dataset - W.Kay et al. (2017)](https://arxiv.org/abs/1705.06950)

repository: dennis-park-TRI/kinetics-downloader

repo_name: dennis-park-TRI/kinetics-downloader


text:
---
title: How does ServiceControl work?
summary: An overview of how ServiceControl collects and processes messages and data from an NServiceBus system
reviewed: 2022-10-19
---

ServiceControl is a background process that will collect and store data and make it available via an HTTP API to ServicePulse and ServiceControl.

NOTE: The ServiceControl HTTP API may change at any time. It is designed for use by ServicePulse and ServiceInsight only. The use of this HTTP API for other purposes is not supported.

## How ServiceControl receives data

For each ServiceControl service type (i.e. error, audit, and monitoring) there is different data available that must be provided by user-built NServiceBus endpoints.

```mermaid
graph LR
  subgraph Endpoints
    Error
    Plugins[Saga audit<br>Heartbeats<br>Custom checks]
    Audit
    Monitoring
  end

  Audit -- Audit<br>data --> AuditQ(Audit queue)
  AuditQ --> ServiceControlAudit[ServiceControl<br>audit instance]
  ServiceControlAudit --> AuditLog(Audit.Log<br>queue)
  ServiceControlAudit -. Integration<br>events .-> Watchers

  Plugins -- Plugin data --> SCQ
  Plugins -- SagaAudit<br>data --> AuditQ(Audit queue)
  SCQ(ServiceControl<br>queue) --> ServiceControlError

  Error -- Error<br>data --> ErrorQ(Error queue)
  ErrorQ --> ServiceControlError[ServiceControl<br>error instance]
  ServiceControlError --> ErrorLog(Error.Log<br>queue)
  ServiceControlError -. Integration<br>events .-> Watchers[Subscribers]

  Monitoring --> MonQ(Monitoring queue)
  MonQ --> ServiceControlMonitoring[Monitoring instance]

  classDef Endpoints fill:#00A3C4,stroke:#00729C,color:#FFFFFF
  classDef ServiceControlInstance fill:#A84198,stroke:#92117E,color:#FFFFFF,stroke-width:4px
  classDef Plugin fill:#00729C,stroke:#000,color:#ddd

  class ServiceControlError ServiceControlInstance
  class ServiceControlAudit ServiceControlInstance
  class ServiceControlMonitoring ServiceControlInstance
  class Watchers Endpoints
  class Plugins Plugin
  class Audit Plugin
  class Error Plugin
  class Monitoring Plugin
```

### Error instances

[Recoverability](/nservicebus/recoverability/) is an important feature in NServiceBus. It enables automatic retries and continuity within a system, as failed messages will be moved aside to allow other messages to be processed while the errors are investigated. Those error messages contain business data that must eventually be processed.

NServiceBus will move messages it cannot process to an [error queue](/nservicebus/recoverability/#fault-handling). This is where ServiceControl comes into play to consume these messages. ServiceControl will pick up the message and store it in an internal database. ServiceControl uses an embedded RavenDB instance for the internal database. After it is stored in the database, the message is made available to ServicePulse and ServiceInsight for visualization, retries, and other operations.

NOTE: It is recommended not to provide end-users with the ability to retry messages. The message could fail again and end up in ServiceControl once again. It could be even more problematic when many messages are retried during a peak in message processing. This will result in even more messages being processed by an endpoint, causing valid messages to be delayed even longer.

Find out more about [failed messages](/servicepulse/intro-failed-messages.md) in ServicePulse.

### Audit instances

To enable ServiceInsight to visualize the message flow through the system, it must have access to every message that has been successfully processed by the system. This requires endpoints to [enable auditing](/nservicebus/operations/auditing.md). ServiceControl consumes these messages and stores them in its internal database.

ServiceInsight will retrieve the data from ServiceControl via the HTTP API and use header information (added by NServiceBus during message processing) to figure out which message caused other messages to be sent, including which sagas were accessed when the [SagaAudit plugin](/nservicebus/sagas/saga-audit.md) is configured in an endpoint.

### Monitoring instances

For ServicePulse to report metrics on logical endpoints, endpoint instances and on specific messages, each endpoints needs to be [enabled to forward metrics](/monitoring/metrics/install-plugin.md) to ServiceControl. ServicePulse will then be able to retrieve the data from ServiceControl via the HTTP API.

## Forwarding

ServiceControl _consumes_ messages from the audit and error queues. That is, it removes all messages from those queues. If a copy of those messages is required for further processing, configure [audit forwarding](/servicecontrol/creating-config-file.md#transport-servicecontrolforwardauditmessages) and/or [error queue forwarding](/servicecontrol/creating-config-file.md#transport-servicecontrolforwarderrormessages).

gha_language: C#


text:
# Flapjack::Diner

[![Travis CI Status][id_travis_img]][id_travis_link]

[id_travis_link]: https://secure.travis-ci.org/#!/flpjck/flapjack-diner
[id_travis_img]: https://secure.travis-ci.org/flpjck/flapjack-diner.png

Access the API of a [Flapjack](http://flapjack-project.com/) system monitoring server.

## Installation

Add this line to your application's Gemfile:

    gem 'flapjack-diner', :git => 'git://github.com/flpjck/flapjack-diner.git'

And then execute:

    $ bundle

## Usage

Set the URI of the Flapjack server:

```ruby
Flapjack::Diner.base_uri('<IP_ADDRESS>:5000')
```

Optionally, set a logger to log requests & responses:

```ruby
Flapjack::Diner.logger = Logger.new("logs/flapjack_diner.log")
```

---

Return a list of monitored entities, and their statuses for all associated checks:

```ruby
Flapjack::Diner.entities
```

The data is returned as a JSON list where each element is an associative array representing an entity.

```
// ID     is an integer, to hold e.g. database id from an external system
// NAME   is a string
// STATUS is an associative array with the format returned from Flapjack::Diner.status(entity, check)
[{"id"     : ID,
  "name"   : NAME,
  "checks" : [STATUS, STATUS, ...]},
 {},
 ...]
```

---

Return a list of checks for an entity:

```ruby
Flapjack::Diner.checks('example.com')
```

The data is returned as a JSON list of strings, where each element is a check name for the provided entity.

```
// CHECK is a string, e.g. 'ssh', 'ping'
[CHECK, CHECK, ...]
```

---

Return the status for a check on an entity

```ruby
Flapjack::Diner.status('example.com', :check => 'ping')
```

The data is returned as a JSON associative array:

```
// CHECK is a string, e.g. 'ssh', 'ping'
// STATE is a string, one of 'critical', 'warning', 'ok', 'unknown'
// the TIMESTAMPs are integers representing UTC times for the named events
{"name" : CHECK,
 "state" : STATE,
 "in_unscheduled_maintenance" : BOOLEAN,
 "in_scheduled_maintenance" : BOOLEAN,
 "last_update" : TIMESTAMP,
 "last_problem_notification" : TIMESTAMP,
 "last_recovery_notification" : TIMESTAMP,
 "last_acknowledgement_notification" : TIMESTAMP}
 ```

---

Return the statuses for all checks on an entity

```ruby
Flapjack::Diner.status('example.com')
```

The data is returned as a JSON list of checks, where each element is an associative array with the format returned from Flapjack::Diner.status(entity, check)

```
// STATUS is an associative array with the format returned from Flapjack::Diner.status(entity, check)
[STATUS, STATUS, ...]
```

---

Return a list of scheduled maintenance periods for a check on an entity:

```ruby
# start time (Time object, optional)
# end time (Time object, optional)
Flapjack::Diner.scheduled_maintenances('example.com', :check => 'ping', :start_time => Time.local(2012, 08, 01), :end_time => Time.local(2012, 09, 01))
```

The data is returned as a JSON list of scheduled maintenance periods, with each element of the list being an associative array containing data about that maintenance period.

```
// the TIMESTAMPs are integers representing UTC times for the named events
// DURATION is an integer representing the length of the period in seconds
// SUMMARY is a string providing a description of the period, may be empty
[{"start_time" : TIMESTAMP,
  "duration" : DURATION,
  "summary" : SUMMARY,
  "end_time" : TIMESTAMP},
  {...},
  ...]
```

---

Return lists of scheduled maintenance periods for all checks on an entity:

```ruby
# start time (Time object, optional)
# end time (Time object, optional)
Flapjack::Diner.scheduled_maintenances('example.com', :start_time => Time.local(2012, 08, 01), :end_time => Time.local(2012, 09, 01))
```

The data is returned as a list of associative arrays, where each associative array represents the scheduled maintenance periods for a check under the entity :

```
// CHECK is a string, e.g. 'ssh', 'ping'
// SCHED_MAINT is an associative array with the same format as an individual element of the list returned from Flapjack::Diner.scheduled_maintenances(entity, check)
[{"check" : CHECK,
  "scheduled_maintenance" : [SCHED_MAINT, ...]
 },
 {"check" : CHECK,
  "scheduled_maintenance" : [SCHED_MAINT, ...]
 }]
```

---

Return a list of unscheduled maintenance periods for a check on an entity:

```ruby
# start time (Time object, optional)
# end time (Time object, optional)
Flapjack::Diner.unscheduled_maintenances('example.com', :check => 'ping', :start_time => Time.local(2012, 08, 01), :end_time => Time.local(2012, 09, 01))
```

The data is returned as a JSON list of unscheduled maintenance periods, with each element of the list being an associative array containing data about that maintenance period.

```
// the TIMESTAMPs are integers representing UTC times for the named events
// DURATION is an integer representing the length of the period in seconds
// SUMMARY is a string providing a description of the period, may be empty
[{"start_time" : TIMESTAMP,
  "duration" : DURATION,
  "summary" : SUMMARY,
  "end_time" : TIMESTAMP},
  {...},
  ...]
```

---

Return lists of unscheduled maintenance periods for all checks on an entity:

```ruby
# start time (Time object, optional)
# end time (Time object, optional)
Flapjack::Diner.unscheduled_maintenances('example.com', :start_time => Time.local(2012, 08, 01), :end_time => Time.local(2012, 09, 01))
```

The data is returned as a list of associative arrays, where each associative array represents the unscheduled maintenance periods for a check under the entity:

```
// CHECK is a string, e.g. 'ssh', 'ping'
// UNSCHED_MAINT is an associative array with the same format as an individual element of the list returned from Flapjack::Diner.unscheduled_maintenances(entity, check)
[{"check" : CHECK,
  "unscheduled_maintenance" : [UNSCHED_MAINT, ...]
 },
 {"check" : CHECK,
  "unscheduled_maintenance" : [UNSCHED_MAINT, ...]
 }]
```

---

Return a list of outages for a check on an entity (all times for which the check was failing):

```ruby
# start time (Time object, optional)
# end time (Time object, optional)
Flapjack::Diner.outages('example.com', :check => 'ping', :start_time => Time.local(2012, 08, 01), :end_time => Time.local(2012, 09, 01))
```

The data is returned as a JSON list of outage periods, with each element of the list being an associative array containing data about that outage period.

```
// STATE is a string, one of 'critical', 'warning', 'ok', 'unknown'
// the TIMESTAMPs are integers representing UTC times for the named events
// SUMMARY is a string providing a description of the period, may be empty
[{"state" : STATE,
  "start_time" : TIMESTAMP,
  "end_time" : TIMESTAMP,
  "summary" : SUMMARY},
  {...},
  ...]
```

---

Return lists of outages for all checks on an entity (all times for which said checks were failing):

```ruby
# start time (Time object, optional)
# end time (Time object, optional)
Flapjack::Diner.outages('example.com', :start_time => :start_time => Time.local(2012, 08, 01), :end_time => Time.local(2012, 09, 01))
```

The data is returned as a list of associative arrays, where each associative array represents the outages for a check under the entity:

```
// CHECK is a string, e.g. 'ssh', 'ping'
// OUTAGE is an associative array with the same format as an individual element of the list returned from Flapjack::Diner.outages(entity, check)
[{"check" : CHECK,
  "outages" : [OUTAGE, ...]
 },
 {"check" : CHECK,
  "outages" : [OUTAGE, ...]
 }]
```

---

Return a list of downtimes for a check on an entity (outages outside of scheduled maintenance periods):

```ruby
# start time (Time object, optional)
# end time (Time object, optional)
Flapjack::Diner.downtime('example.com', :check => 'ping', :start_time => Time.local(2012, 08, 01), :end_time => Time.local(2012, 09, 01))
```

Returns an associative array with some statistics about the downtimes, including a list of the downtimes themselves. This may not be the same as would be returned from the 'outages' call for the same time period, as if scheduled maintenance periods overlap any of those times then they will be reduced, split or discarded to fit.

```
// TOTAL SECONDS gives the sum of the time spent in that state for each check state.
// PERCENTAGES represents the proportion of the total time that the check was in each state. Will be null if either start or end time were not provided in the request.
// OUTAGE is an associative array with the same format as an individual element of the list returned from Flapjack::Diner.outages(entity, check).
{"total_seconds" : {STATE => INTEGER, ...},
 "percentages" : {STATE => INTEGER, ...},
 "downtime" : [OUTAGE, ...]
}
```

---

Return a list of downtimes for all checks on an entity (outages outside of scheduled maintenance periods):

```ruby
# start time (Time object, optional)
# end time (Time object, optional)
Flapjack::Diner.downtime('example.com', :start_time => Time.local(2012, 08, 01), :end_time => Time.local(2012, 09, 01))
```

The data is returned as a list of associative arrays, where each associative array represents a downtime report for a check under the entity:

```
// CHECK is a string, e.g. 'ssh', 'ping'
// DOWNTIME is an associative array with the same format those returned from Flapjack::Diner.downtime(entity, check)
[{"check" : CHECK,
  "downtime" : [DOWNTIME, ...]
 },
 {"check" : CHECK,
  "downtime" : [DOWNTIME, ...]
 }]
```

---

Acknowledge the current state for a check on an entity:

```ruby
# summary (String, optional)
Flapjack::Diner.acknowledge!('example.com', 'ping', :summary => 'ack')
```

Returns a boolean value representing the success or otherwise of the creation of the acknowledgement by the server.

---

Generate test notifications for a check on an entity:

```ruby
# summary (String, optional)
Flapjack::Diner.test_notifications!('example.com', 'HOST', :summary => 'Testing notifications to all contacts interested in the HOST check on example.com')
```

Returns a boolean value representing the success or otherwise of the creation of the acknowledgement by the server.

---
---

Create a scheduled maintenance period for a check on an entity:

```ruby
# start time (Time object, optional)
# duration (Integer, required) is measured in seconds
# summary (String, optional)
Flapjack::Diner.create_scheduled_maintenance!('example.com', 'ping',
  :start_time => Time.local(2012, 12, 01), :duration => (60 * 60),
  :summary => 'changing stuff')
```

Returns a boolean value representing the success or otherwise of the creation of the scheduled maintenance period by the server.

## Contributing

1. Fork it
2. Create your feature branch (`git checkout -b my-new-feature`)
3. Commit your changes (`git commit -am 'Added some feature'`)
4. Push to the branch (`git push origin my-new-feature`)
5. Create new Pull Request

repository: jessereynolds/flapjack-diner

repo_name: jessereynolds/flapjack-diner


text:
## SBVPlugin: SBV Plugin for GHC

[![Hackage version](http://budueba.com/hackage/sbvPlugin)]
		   (http://hackage.haskell.org/package/sbvPlugin)
[![Build Status](http://img.shields.io/travis/LeventErkok/sbvPlugin.svg?label=Build)]
                (http://travis-ci.org/LeventErkok/sbvPlugin)

### Example

```haskell
{-# OPTIONS_GHC -fplugin=Data.SBV.Plugin #-}

module Test where

import Data.SBV.Plugin

{-# ANN test theorem #-}
test :: Integer -> Integer -> Bool
test x y = x + y >= x - y
```

*Note the GHC option on the very first line. Either decorate your file with
this option, or pass `-fplugin=Data.SBV.Plugin` as an argument to GHC, either on the command line
or via cabal. Same trick also works for GHCi.*

When compiled or loaded in to ghci, we get:

```
$ ghc -c Test.hs

[SBV] Test.hs:9:1-4 Proving "test", using Z3.
[Z3] Falsifiable. Counter-example:
  x =  0 :: Integer
  y = -1 :: Integer
[SBV] Failed. (Use option 'IgnoreFailure' to continue.)
```

Note that the compilation will be aborted, since the theorem doesn't hold. As shown in the hint, GHC
can be instructed to continue in that case, using an annotation of the form:

```haskell
{-# ANN test theorem {options = [IgnoreFailure]} #-}
```

### Using SBVPlugin from GHCi
The plugin should work from GHCi with no changes.  Note that when run from GHCi, the plugin will
behave as if the `IgnoreFailure` argument is given on all annotations, so that failures do not stop
the load process.

repository: fotonick/sbvPlugin

repo_name: fotonick/sbvPlugin


text:
# dip-ui TODO

- [x] Obtain servicedoc from config if not given - this is working in test_42_dip_deposit_sss (is part of stored collection metadata)
- [x] Define message values for DIP_NOUSERNAME and DIP_NOPASSWORD
- [x] Servicedoc discovery if not given? (from config, for --package) (WORKING)
- [x] Obtain collection_uri from config. (WONTDO: config can contain sevral collection_uri values; need to say which one to use)
- [x] Deposit from supplied package file? (Test added)
- [x] Figure out token response from deposit?  Currently using deposit receipt id for token.
- [x] implement config command (DONE)
- [x] Metadata? (Attribute tests present; generic metadata out of scope for the current development)
- [x] setup.py
- [x] How to query status of previous deposit - need to save details locally, or can use SSS?  Awaiting response, but if none forthcoming will resort to saving receipt locally.
- [x] Pull request for dip to support filename paths in zip
- [ ] Test against Databank - tried but failed.  Awaiting response.
- [ ] Consider dropping "token=" from deposit response.

## Commands for manual testing

    python dipmain.py create --dip=/tmp/diptest
    python dipmain.py show
    python dipmain.py --recursive add-file ../tests/test/data/files/
    python dipmain.py show
    python dipmain.py package
    python dipmain.py config \
        --collection_uri=http://localhost:8080/col-uri/04a89ccb-afde-4198-a033-0be960c24b5e \
        --servicedoc_uri=http://localhost:8080/sd-uri \
        --username=sword \
        --password=sword
    python dipmain.py deposit --dip=/tmp/diptest \
        --collection_uri=http://localhost:8080/col-uri/04a89ccb-afde-4198-a033-0be960c24b5e \
    python dipmain.py deposit
        --package=/tmp/diptest/packages/aHR0cDovL3B1cmwub3JnL25ldC9zd29yZC9wYWNrYWdlL1NpbXBsZVppcA==/SimpleZip.zip
        --collection_uri=http://localhost:8080/col-uri/04a89ccb-afde-4198-a033-0be960c24b5e

repository: CottageLabs/dip-ui

repo_name: CottageLabs/dip-ui


text:
[![Work in Repl.it](https://classroom.github.com/assets/work-in-replit-14baed9a392b3a25080506f3b7b6d57f295ec2978f6f33ec97e36a161684cbe9.svg)](https://classroom.github.com/online_ide?assignment_repo_id=313440&assignment_repo_type=GroupAssignmentRepo)
# Solo 6023-2 - {Short snappy Title of your project}

- Cancer Analysis

## Description
 - This directory contains the scripts of functions used for various purposes such as data cleaning and loading.

## Team Members

**Omkar Kulkarni**

## References
source: [Statistics Canada](https://open.canada.ca/data/en/dataset/bc5becae-2a29-49ba-80ea-7f6ae6708d04)


text:
---
id: 328
title: Modelling skirting boards
date: 2014-02-09T16:01:10+00:00
author: Simon Moreau
layout: post
guid: https://www.bim42.com/?p=328
permalink: /2014/02/modellingskirtingboards/
categories:
  - Revit
image: /assets/2014/02/workaround.jpg
tags:
  - .NET
  - Automation
  - Revit
  - Tips
  - room-finishing
---
One of my current project at work is to develop an application for the creation of a set of detailed drawings for each room of a building.

This set includes a plan view, a ceiling plan, an elevation view per wall and a schedule of furniture. These drawings must include all finishes details, like skirting boards, floor coverings, electrical equipment and so on.

So I came up with this idea for modeling details quickly and created a small application for drawing skirting boards in Revit.

My application uses a user-created wall type on a specific height to model a skirting board all around a previously selected room.

![interface]({{ "/assets/2014/02/interface.jpg" | absolute_url }})

The development of this application was pretty straightforward, except when it came to placing correctly the skirting board baseline against the finish face of the main wall. Indeed, Revit API does not allow to set up a wall baseline before creating it. And changing it after the creating doesn’t move the wall, only the baseline.

![wallbaseline]({{ "/assets/2014/02/wallbaseline.jpg" | absolute_url }})

My workaround was to create a larger wall, change its baseline, then change its wall type to the skirting board type, and finally, change back the wall baseline.

![workaround]({{ "/assets/2014/02/workaround.jpg" | absolute_url }})

This method allows me to place the skirting board baseline along the finish face of the wall.

I also used this example to publish my first application on Autodesk Exchange App.

Following the guidelines for publishing allowed me to create a well packaged application, bundled with help file and installer. It is also the opportunity to distribute the application to a larger audience.

The whole publishing process is quite smooth, and the Audesk guys are very helpful.

The app is now available [here](http://apps.exchange.autodesk.com/RVT/en/Detail/Index?id=appstore.exchange.autodesk.com%3aroomfinishing_windows32and64%3aen "Room Finishing") for free, and I plan to publish the code on GitHub as well soon.


text:
---
layout: creature
name: "Tyrannosaurus Zombie"
tags: [Huge, undead, cr8, tomb-of-annihilation]
cha: 5 (-3)
wis: 3 (-4)
int: 1 (-5)
con: 19 (+4)
dex: 6 (-2)
str: 25 (+7)
size: Huge undead
alignment: unaligned
challenge: "8 (3,900 XP)"
senses: "darkvision 60 ft., passive Perception 6"
condition_immunities: "poisoned"
damage_immunities: "poison"
speed: "40 ft."
hit_points: "136 (13d12 +52)"
armor_class: "11 (natural armor)"
---

***Disgorge Zombie.*** As a bonus action , the tyrannosaurus zombie can disgorge a normal zombie, which appears in an unoccupied space within 10 feet of it. The disgorged zombie acts on its own initiative count. After a zombie is disgorged, roll a d6. On a roll of l, the tyrannosaurus zombie runs out of zombies to disgorge and loses this trait . If the tyrannosaurus zombie still has this trait when it dies, ld4 normal zombies erupt from its corpse at the start of its next turn. These zombies act on their own initiative count.

***Undead fortitude.*** If damage reduces the tyrannosaurus zombie to 0 hit points, it must make a Constitution saving throw with a DC of 5 + the damage taken, unless the damage is radiant or from a critical hit. On a success, the zombie drops to 1 hit point instead.

### Actions

***Multiattack.*** The tyrannosaurus zombie makes two attacks: one with its bite and one with it s tail. It can't make both attacks against the same target.

***Bite.*** Melee Weapon Attack: +10 to hit, reach 10 ft., one target. Hit: 33 (4d12 +7) piercing damage. If the target is a Medium or smaller creature, it is grappled (escape DC 17). Until this grapple ends, the target is restrained and the tyrannosaurus zombie can't bite another target or disgorg e zombies.

***Tail.*** Melee Weapon Attack: +10 to hit, reach 10 ft., one target. Hit: 20 (3d8 +7) bludgeoning damage.

gha_language: CSS


text:
# Calculator

FCC Project: JavaScript Calculator

## Made by:

* jQuery
* Sass
* Flexbox

## Tools (linting, formating, task runner):

* Eslint
* Stylelint
* Prettier
* Gulp

repository: miljan-fsd/calculator

repo_name: miljan-fsd/calculator


text:
## Python library for communicating with AMQP peers and brokers using Twisted

[![Python Test](https://github.com/DomAmato/txamqp/workflows/Python%20Test/badge.svg)](https://github.com/DomAmato/txamqp/actions)
[![Coverage Status](https://coveralls.io/repos/github/DomAmato/txamqp/badge.svg?branch=master)](https://coveralls.io/github/DomAmato/txamqp?branch=master)

This is a quick post on getting started using the txAMQP library with RabbitMQ,
based on Dan Reverri's article "Getting started with RabbitMQ, Python, Twisted,
and txAMQP on Ubuntu 9.04" [http://www.apparatusproject.org/blog/?p=38]

### Install RabbitMQ

If you're using Debian (or a derivative, like Ubuntu) and RabbitMQ is not
included in your distribution, you can add RabbitMQ's APT repository:

    http://www.rabbitmq.com/debian.html#apt

### Running RabbitMQ

If you installed RabbitMQ using the Debian package, it will be automatically
started. If not, you'll find an init.d file in /etc/init.d/rabbitmq-server

### Install Twisted

As of 2009-07-09, txAMQP is being developed using Twisted 8.2.0, it may
work with older versions, but it's not guaranteed. In case you are using
Ubuntu, and the version available is not recent enough, you can install
Twisted through its PPA:

    https://launchpad.net/~twisted-dev/+archive/ppa

### Install txAMQP

The instructions below install txAQMP from trunk. There are Ubuntu packages
available if you prefer, refer to the following page for more details:

    https://launchpad.net/~txamqpteam/+archive/ppa

a. Install Bazaar

    $ sudo apt-get install bzr

b. Fetch txAQMP

    $ cd ~
    $ bzr branch lp:txamqp txamqp

If you get the error "bzr: ERROR: Unknown repository format: 'Bazaar
RepositoryFormatKnitPack6 (bzr 1.9)", you'll need to upgrade Bazaar. You may
do so following the instructions at:

    http://bazaar-vcs.org/Download

c. Install txAMQP

    $ cd txamqp
    $ sudo python setup.py install

repository: DomAmato/txamqp

repo_name: DomAmato/txamqp


text:
# The Framework Isolation Library

- [Homepage](https://the-framework.gitlab.io/libraries/isolation.html)
- [API Documentation](https://the-framework.gitlab.io/libraries/isolation/docs/)

[![Build](https://gitlab.com/the-framework/libraries/isolation/badges/master/pipeline.svg)](https://gitlab.com/the-framework/libraries/isolation/-/jobs)
[![Coverage](https://gitlab.com/the-framework/libraries/isolation/badges/master/coverage.svg?job=test:php)](https://the-framework.gitlab.io/libraries/isolation/coverage/)
[![Donate](https://img.shields.io/badge/Donate-PayPal-blue.svg)](https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=NGBNW5PY4VSJ4)

repository: natanfelles/isolation

repo_name: natanfelles/isolation


text:
#Connect dropwizard to MongoDB

*dropwizard-mongo is a set of factories and health checks to be used with [dropwizard](http://dropwizard.github.io/dropwizard/) for connecting to MongoDB.*

## Disclaimer
Update 8/1: Major refactor that simplifies usage. Thanks to [kgilmer](https://github.com/kgilmer) for the review.
This project is brand new, so I have a lot of additional work to support the multiple options that can be passed to the MongoClient, DB, and DBCollection objects.

##Usage

### Installation

The project artifacts are not currently hosted in a maven repository, so you will need to clone the repo and build the dropwizard-mongo project at a minimum.

I recommend you use dropwizard-mongo in combination with the [MongoJack](http://mongojack.org/) project for quickest implementation. The dropwizard-mongo-example project shows an example of using MongoJack with dropwizard-mongo.

### Updating Your yaml

If you want the factory to build a [MongoClient](https://api.mongodb.org/java/current/com/mongodb/MongoClient.html) object you can specify the connections in you config file.

    mongoDB:
      connections:
        - host: localhost
          port: 27017
        - host: <IP_ADDRESS>
          port: 27017

If you want to the factory to build a [DB](https://api.mongodb.org/java/current/com/mongodb/DB.html) object you will need to further specify the db name in the config.

    mongoDB:
        dbName: unittest
        connections:
            - host: localhost
              port: 27017
            - host: <IP_ADDRESS>
              port: 27017

Finally, the factory can return a [DBCollection](https://api.mongodb.org/java/current/com/mongodb/DBCollection.html) object
 you will need to further specify the collection name in the config.

    mongoDB:
        dbName: unittest
        collName: test
        connections:
            - host: localhost
              port: 27017
            - host: <IP_ADDRESS>
              port: 27017

### Updating you configuration
You will need to add a reference to MongoFactory in your class that extends Configuration or
you can extend from com.eeb.dropwizardmongo.configuration.DropwizardMongoConfiguration.

    @Valid
    @NotNull
    private MongoFactory mongoFactory = new MongoFactory();

    @JsonProperty("mongoDB")
    public MongoFactory getMongoFactory() {
        return this.mongoFactory;
    }

    @JsonProperty("mongoDB")
    public void setMongoFactory(MongoFactory MongoFactory) {
        this.mongoFactory = MongoFactory;
    }

### Update your applications run method
Your class that extends from Application needs to be updated to register the health checks and call the
factory method you wish to use. Once you have the object you want you can pass it to your dropwizard resources.

#### Registering the health checks
     final MongoClient mongoClient = config.getMongoFactory().buildClient(environment);
     environment.healthChecks().register("mongo",new MongoHealthCheck(mongoClient));

#### Building a MongoClient object
     final MongoClient mongoClient = config.getMongoFactory().buildClient(environment);
     //Register Resources
     environment.jersey().register(new CollectionIdsResource(mongoClient));

#### Building a DB object
     final DB db = config.getMongoFactory().buildDB(environment);
     //Register Resources
     environment.jersey().register(new CollectionIdsResource(db));

#### Building a DBCollection object
    final DBCollection coll = config.getMongoFactory().buildColl(environment);
    //Register Resources
    environment.jersey().register(new CollectionIdsResource(coll));

### Using MongoJack with dropwizard-mongo

The secret sauce here is MongoJack. It lets me pass my Jackson API objects directly to the MongoDB API as well as returning the results of queries as my API objects.

Super basic API object representing a MongoDB document:

    public class MongoDocument {

        private String id;

        @ObjectId
        @JsonProperty("_id")
        public String getId() {
            return this.id;
        }

        @ObjectId
        @JsonProperty("_id")
        public void setId(String id) {
            this.id = id;
        }

    }

My Resource's GET handler.

    @GET
    public List<MongoDocument> fetch(@PathParam("collection") String collection) {

        JacksonDBCollection<MongoDocument, String> coll = JacksonDBCollection.wrap(mongoDB.getCollection(collection), MongoDocument.class,
                String.class);
        DBCursor<MongoDocument> cursor = coll.find();

        List<MongoDocument> l = new ArrayList<>();

        try {
            while(cursor.hasNext()) {
                l.add(cursor.next());
            }
        }finally {
            cursor.close();
        }

        return l;
    }

MongoJack provides wrappers for the standard MongoDB api calls that will parse MongoDB documents into objects that are Jackson annotated.

repository: eeb/dropwizard-mongo

gha_language: Java

repo_name: eeb/dropwizard-mongo