text:
## ListOffersRequestFilters

## Properties

Name | Type | Description | Notes
------------ | ------------- | ------------- | -------------
**marketplace_id** | **string** | The marketplace identifier. The supported marketplaces for both sellers and vendors are US, CA, ES, UK, FR, IT, IN, DE and JP. The supported marketplaces for vendors only are BR, AU, MX, AE and NL. Refer to [Marketplace IDs](https://developer-docs.amazon.com/sp-api/docs/marketplace-ids) to find the identifier for the marketplace. |
**skus** | **string[]** | A list of SKUs to filter. This filter is only supported for sellers and not for vendors. | [optional]
**asins** | **string[]** | A list of Amazon Standard Identification Numbers (ASINs). | [optional]
**eligibilities** | [**\SellingPartnerApi\Model\ReplenishmentV20221107\EligibilityStatus[]**](EligibilityStatus.md) | A list of eligibilities associated with an offer. | [optional]
**preferences** | [**\SellingPartnerApi\Model\ReplenishmentV20221107\Preference**](Preference.md) |  | [optional]
**promotions** | [**\SellingPartnerApi\Model\ReplenishmentV20221107\Promotion**](Promotion.md) |  | [optional]
**program_types** | [**\SellingPartnerApi\Model\ReplenishmentV20221107\ProgramType[]**](ProgramType.md) | A list of replenishment program types. |

[[ReplenishmentV20221107 Models]](../) [[API list]](../../Api) [[README]](../../../README.md)

repository: jlevers/selling-partner-api

repo_name: jlevers/selling-partner-api


text:
# 09-team-generator

Template Engine + Employee Summary

One of the most important aspects of programming is writing code that is readable, reliable, and maintainable. Here we are building a NODE CLI to take in information about employees and generate an HTML webpage that displays summaries for each person. Testing is a key piece in making code maintainable, this app has been ensured that all unit tests have pass.

##

### User input

The project must prompt the user to build an engineering team. An engineering
team consists of a manager, and any number of engineers and interns.

##

### Instructions
1. Using the command line application, please remember to install all package dependencies.
2. The application will prompt the user for information about the team manager and then information about the team members, please click each person's role respectively.
3. The user can input may choose any number of team members, and they may be a mix of engineers and interns.
4. Once the user has filled out each prompt regarding their full name, position, employee ID, email, and or school then the application will have created a full team that will generate and create a HTML file that displays a nicely formatted team roster based on the information provided by the user.

##

### Technology
NPM Packages: Require and Jest

##

### License
MIT

##

### Important notes
While creating this team roster what helped along was implementing and creating constructor classes that contained the following setup:

  * Name

  * Role

  * ID

  * Role-specific property (School, link to GitHub profile, or office number)

After prompts are completed.
The file is then rendered and written to the output directory where the new team.html is then created.
You now have yourself a new team roster ready to be displayed and shown off!

##

### Roster output

![Employee prompts 1](./assets/images/prompts.png)
![Employee Summary 2](./assets/images/teampage.png)

### Video Demonstration
Please view video: https://drive.google.com/file/d/1o1k8fSNfw6poS89ADfzZ75pP35KeEONw/view?usp=sharing

license: MIT

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
---
layout: default
---

# 1995-11-18 - Re: NSA, ITAR, NCSA and plug-in hooks.

## Header Data

From<EMAIL_ADDRESS>(Adam Hupp)

To<EMAIL_ADDRESS>Message Hash: c2dc243a63b21180fd39a8655a6214ff7ebf8104d2fd9a8dad5fff5472db28be

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1995-11-18 03:43:12 UTC

Raw Date: Sat, 18 Nov 1995 11:43:12 +0800

## Raw message

```
{% raw  %}From<EMAIL_ADDRESS>(Adam Hupp)
Date: Sat, 18 Nov 1995 11:43:12 +0800
To<EMAIL_ADDRESS>Subject: Re: NSA, ITAR, NCSA and plug-in hooks.
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

>From: Scott Brickner<EMAIL_ADDRESS>>Date: Thu, 16 Nov 1995 15:13:27 -0600
>Subject: Re: NSA, ITAR, NCSA and plug-in hooks.

>The problem is that the non-encryption program must use the same
>interface as the encryption program.  Text compression is often cited
>as an example of a non-encryption program that can use the same hooks
>as a compression program, but there's a key difference:  the text
>compressor *doesn't* need a key.
>
>The encryption tool would have an interface like
>    Boolean (*)( DataSource, DataSink, void*);
>
>A compressor written to the same interface would never need to touch
>that third argument.  Therefore, the second argument is "specifically
>designed" to permit an encryption tool to be used.
>
>You'd need a program which not only *accepted* the additional parameter,
>but also *needed* the second parameter.  I confess I have some difficulty
>thinking of one.
>

PKZIP allows encryption (other's ?).  How about a hook to that?

_____________________________________________________________

"We work in the dark  We do what we can  We give what we have
Our doubt is our passion  And our passion is our task
The rest is the madness of art."
                   --Henry James
___________________________________________________________

{% endraw %}
```

## Thread

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

+ Return to<EMAIL_ADDRESS>(Adam Hupp)](/authors/ahupp_at_primenet_com_adam_hupp_)"
+ Return to "[Tatu Ylonen <ylo@cs.hut.fi>](/authors/tatu_ylonen_ylo_at_cs_hut_fi_)"

+ 1995-11-18 (Sat, 18 Nov 1995 11:43:12 +0800) - Re: NSA, ITAR, NCSA and plug-in hooks. -<EMAIL_ADDRESS>(Adam Hupp)_
  + 1995-11-21 (Tue, 21 Nov 1995 20:46:35 +0800) - [Re: NSA, ITAR, NCSA and plug-in hooks.](/archive/1995/11/3377f2214464736e58d83835c8da56c6e2d940a33c2f1349937426e5f8eb5a43) - _Tatu Ylonen<EMAIL_ADDRESS>

gha_license_id: MIT


text:
# `uwrosys`: Source code for the UWROSYS ITP of RobMoSys

This repository contains the source code for running Skarv Technologies' UWROSYS project based on UUVSimulator. UWROSYS is an ITP supported through RobMoSys - a Horizon 2020 project.

# Installation

**Install docker:**
```
sudo apt-get install docker.io
```
**Start docker on boot and fix permissions (reboot required)**
```
sudo systemctl enable docker
sudo systemctl start docker
sudo usermod -aG docker $USER
```

**Install ssh and sshd:**
```
sudo apt-get install ssh openssh-server
```

# Useful make commands for running docker image

**Build docker image:**
```
cd <docker_directory>
make build
```

**Start terminal with possibility for GUI programs**
```
cd <docker_directory>
make interactive
```

**Run SmartMDSDD toolchain**
```
cd <docker_directory>
make toolchain
```

**Connect additional terminal to container (only works when container is running)**
```
cd <docker_directory>
make shell
```

**Clean stopped docker containers**
```
cd <docker_directory>
make clean
```

**Clean docker system (requires full rebuild of all images)**
```
cd <docker_directory>
make clean_system
```

# Set up toolchain
First run the make command for starting the toolchain. Once started, select:
File -> Import. Then select General -> Existing Projects into Workspace.
- Select folder containing RobMoSys-repos (~/SOFTWARE/smartsoft/repos)

# Fix indexer using CPU
Select Window-Preferences. In the preference window, select C/C++->Indexer and uncheck 'Enable indexer' and 'Automatically update the index'.

repository: skarvtech/uwrosys

repo_name: skarvtech/uwrosys


text:
# coloredtime
This is a widget for Übersicht https://github.com/felixhageloh/uebersicht

This widget replicates James E. Murphy’s awesome site http://whatcolourisit.scn9a.org/, which displays the time and the color that is created when you interpret the time as a hex color.

For example, if it is 5:53:16 PM, the color of your desktop would be #175316, which is a dark green.

repository: totallyuneekname/uebersicht-coloredtime

repo_name: totallyuneekname/uebersicht-coloredtime


text:
# Ember-odometer

This addon wraps [odometer.js](http://github.hubspot.com/odometer/) in a component. Usage:

```hbs
{{ember-odometer value=counter}}
```

When `counter` changes, the div output by this component will animate to the new value.

[![Build Status](https://travis-ci.org/plyfe/ember-odometer.svg?branch=master)](https://travis-ci.org/plyfe/ember-odometer)

## Installation

From your ember-cli app's directory:

`ember install:npm ember-odometer` or `npm install ember-odometer --save-dev && ember generate ember-odometer`

## Running the Dummy App

* `ember server`
* Visit the dummy app app at http://localhost:4200.

## Running Tests

* `ember test`
* `ember test --server`

## Building

* `ember build`

For more information on using ember-cli, visit [http://www.ember-cli.com/](http://www.ember-cli.com/).

## Thanks

Thanks to Plyfe for sponsoring initial development and open-sourcing. ember-odometer authors include: Luke Melia.

repository: livilco/ember-odometer

repo_name: livilco/ember-odometer


text:
# Thoughts

## Documentation

Where would someone learn about the goals of the project, overall design, and technology used?

Most repositories have a README.md that explains the basics, and a `documentation` folder with additional project details.

## Tools

Generally most JavaScript projects use a linter to identify common isses. [ESLint](https://eslint.org/) is often used for JavaScript projects.

https://github.com/wandyezj/package has an example of how to set up ESLint.

## Structure

Typically it's convenient to have the project in the top level folder instead of a subdirectory. This makes it easy to open up Visual Studio Code in the project directory.

It's convneient to have all tool configurations under a single `config` directory, this declutters the main directory and makes it easy to find config files. See: https://github.com/wandyezj/package

## Code Style

It can be convenient to use enums in place of hard coded string values. This allows the type system to give you hints and allows linters to provide better warnings.

Use Strong Types were possible (avoid any and unknown) this allows Visual Studio Code to provide helpful IntelliSense and helps avoid errors.

Each file should contain a single concept when possible (single interface, single class, single enum, etc..). Name the file the same as the containing entity, this makes it easy to locate the contained entity.

Avoid exporing default. Instead use `export` next to the entity exported.

Use full words in variable names, avoid leaving out random characters. This makes it easy to understand for other people.

Avoid converting numbers to strings to do math operations for example use `Math.floor` to round to the nearest integer.

Annotate functions with their return values. This ensures strong interfaces.

Example

```typescript

// no return type on bad!!!
function bad() {
    return 5;
}

function good(): number {
    return 5;
}

```

When using Regex, place the expression in a separate variable and comment that regex to explain what it is doing. Regex are notoriously difficult for people to understand and are fragile, since it is easy to break then when making changes later.

Place data in a data appropriate files like `json` and then import those files. This makes it easy to tell which files are data and which are code.

In `simulationReducer` how come `return` instead of break and return? This would allow setting the entire state to local storage as one blob instead of as individual items.

In `MajorsGraph` usually better to declare interfaces such as `MajorsJSON` outside of functions they are used in.

Its usually better to iterate though arrays with `forEach` over indexing unless the index is needed for another purpose, this avoids off by one errors.

If using the same constant in multiple places it is convenient to pull it into a constant.

license: Unlicense

branch_name: refs/heads/main


text:
# REAPER

[![Build Status](https://travis-ci.org/r9y9/REAPER.jl.svg?branch=master)](https://travis-ci.org/r9y9/REAPER.jl)
[![Coverage Status](https://coveralls.io/repos/r9y9/REAPER.jl/badge.svg)](https://coveralls.io/r/r9y9/REAPER.jl)
[![License](http://img.shields.io/badge/license-MIT-brightgreen.svg?style=flat)](LICENSE.md)

A Julia interface for [REAPER](https://github.com/google/REAPER).

## High level interface

```julia
# Compute pitch mark, F0 and normalized cross-correlation function simultaneously
pm_times, pm, f0_times, f0, corr = reaper(x, fs)
```

where `fs` is sampling frequency and `x::Vector{Int16}` is a input monoral speech signal like:

![](examples/x.png)

### Pitch mark

![](examples/pitchmark.png)

### F0

![](examples/f0.png)

### Normalized cross-correlation function

![](examples/correlation.png)

For the complete code of visualizations shown above, please check [the ijulia notebook](http://nbviewer.ipython.org/github/r9y9/REAPER.jl/blob/master/examples/REAPER%20demo.ipynb).

## Notice

- This is not an official package
- REAPER.jl is based on a slightly modified version of REAPER (see [here](https://github.com/r9y9/REAPER/tree/cwrap))


text:
[![Build Status](https://travis-ci.org/sl33t/portfolio.svg?branch=master)](https://travis-ci.org/sl33t/portfolio)
[![Coverage Status](https://coveralls.io/repos/github/sl33t/portfolio/badge.svg?branch=master)](https://coveralls.io/github/sl33t/portfolio?branch=master)
[![Code Issues](https://www.quantifiedcode.com/api/v1/project/558993c5c2084efba58e3158f6b2305f/badge.svg)](https://www.quantifiedcode.com/app/project/558993c5c2084efba58e3158f6b2305f)

# My Portfolio Website: [RickyCatron.com](http://www.RickyCatron.com)
This is my development porfolio site.
It is built on Django utilizing a Postgres database.
It is hosted on Webfaction and encrypted using LetsEcrypt.
I am currently learning about testing, continuous integration, and a wide variety of other technologies.
I try to integrate them into this but not so much that it overcomplicates the project.
Right now Travis handles testing and deployment.
I hope you enjoy my site.

gha_language: Python


text:
# Predicates
[![Build Status](https://travis-ci.org/wookieb/predicates.svg)](https://travis-ci.org/wookieb/predicates)
[![NPM version](https://badge.fury.io/js/predicates.png)](http://badge.fury.io/js/predicates)
[![Bower version](https://badge.fury.io/bo/predicates.js.png)](http://badge.fury.io/bo/predicates.js)

Set of various predicates for type checking, assertions, filtering etc.

## Install
### NPM
```
npm install predicates
```

### Bower
```
bower install predicates.js
```

## Documentation
For list of all available functions see [API reference](docs/api.md)

If you wonder why _predicates_ is different, read [API design principles](docs/design.md)

## Example

```js
var is = require('predicates');

is.string(1); // false
is.string('test'); // true

is.undefinedOr(is.string, undefined); // true
is.undefinedOr(is.string, 'timmy'); // true
is.undefinedOr(is.string)(undefined); // true
is.undefinedOr(is.string)('timmy'); // true

var isPerson = is.structure({
	name: is.string,
	surname: is.undefinedOr(is.string),
	age: is.number
});

isPerson({name: 'Tom', age: 10}); // true
isPerson({surname: 'Welling', age: 100}); // false, lack of name property
```
Read [API reference](docs/api.md) for list of all available functions

## Assertions
[Assert-generator](https://github.com/wookieb/assert-generator) helps create assertions directly from predicates which is very useful for arguments assertions

```js
var assertName = createAssert(is.string, 'Name must be a string'),
    assertSurname = createAssert(is.all(
        is.string, is.not(is.empty)
    ), 'Surname must be a string and cannot be empty'),
    assertAge = createAssert(is.undefinedOr(is.positive),
        'Age must be a number and greater than 0');

var Person = function(name, surname, age) {
    assertName(name);
    assertSurname(surname);
    assertAge(age);
}

new Person('Tom', 'Welling', 33); // OK!
new Person('Tom', 'Welling'); // OK!
new Person('Tom', '', 33); // Error: Surname must be a string and cannot be emptye
```

## Supported browsers
Supported by all major browsers including IE >=9.
IE8 is supported as well but you need to include https://github.com/es-shims/es5-shim and es5-sham.

## Contributing
* clone repo
* ensure your editor is decent and pick up the `.editorconfig` files
* `npm install`
* add tests, add features
* `gulp` --> there should be no errors

## Changelog

### 1.0.1
* Fixed #21

### 1.0.0-rc.2
* Added bower support #16

### 1.0.0-rc.1
* Provided names for all the functions to make debugging easier #13
* Added _primitive_ predicate #12
* Added _plainObject_ predicate #4
* Added _divisible_ and _divisibleWithRemainder_ predicates
* Added _property_ predicate #14
* Added _notBlank_ predicate
* Improved performance

### 0.3
* Fixed path to finite polyfill
* Better support for is.NaN #11
* Added _notEmpty_ predicate #9
* Improved is.false and is.true to accept new Boolean(true/false) as well
* Fixed behavior of is.object to accept Object.create(null) #10

### 0.2.1
* Fix: instanceof renamed to instanceOf

### 0.2
* Added information how to use _predicates_ for arguments assertions
* Added documentation with examples and design rules
* Added "startsWith" and "endsWith" functions
* Added type checking for property names for hasOwnProperty and hasProperty predicate
* Fixed error type declaration for @throws


text:
# cloudflare-ddns
This Dockerfile will keep your Docker containers public IP address up to date with a CloudFlare DNS A record (Dynamic DNS).

*Based on the work of Marcus Hughes<EMAIL_ADDRESS>to better fit UNRAID, infact all the original code was directly copied from his repo (including the first part of the description): https://github.com/macexx/*

**Usage:**

To use, run the Docker container with your CloudFlare API credentials found on your CloudFlare account page:

docker run  --net="host" --name="cloudflare" -e<EMAIL_ADDRESS>-e "CF_HOST=sub.domain.com" -e "CF_API=xxxxxxxxxxxxxx" mace/cloudflare-ddns

To run in the background, add the -d switch after docker run.


text:
---
layout: note
title:  "Debug: a simple console.log wrapper with line numbers"
date:   Wednesday, June 26, 2015
tags:   console, debug, JavaScript
---

Not all browsers support the `console` object in the same way or at all. While it is best to avoid running debugging code on a production site, there are times when you may need to (or think you do 😜). To get around these cross browser issues, the following helper function calls `console.log()` for you, first checking if the `console` object exits:

    function debug(args) {
      if (!window.console || !console.log) {
        return;
      }
      console.log(args);
    }

The issue with this function is that `console` shows the line and column numbers for this function definition instead of showing the line and column numbers of the caller. Not very helpful!

The following method resolves this by using `bind` and `call`, to act as if `console.log()` is getting called from the caller:

    var debug = function () {
      if (!window.console || !console.log) {
        return;
      }
      return Function.prototype.bind.call(console.log, console);
    } ();


text:
---
id: 41618
title: Chicago Public Library Launches New Website
date: 2014-04-11T20:04:18-05:00
author: alexisneisser
layout: post
guid: http://digital.cityofchicago.org/?p=41618
permalink: /index.php/chicago-public-library-launches-new-website/
image: https://digital.cityofchicago.org/wp-content/uploads/2014/04/stack_of_books1.jpg
categories:
  - Default
  - Feature
tags:
  - chicago public library
  - Chicago Public Schools
  - cpl
  - Digital Literacy
---
Introducing Chicago Public Library’s [new and improved website](http://chipublib.org), accessible on your phone or tablet so you can take the library with you on the go! The website features an improved library catalog and search features and greater accessibility so that library resources are always right at your fingertips.

CPL has partnered with software company [BiblioCommon](http://www.bibliocommons.com/)[s](http://www.bibliocommons.com/) to re-envision the library’s online experience which included the site’s development, research, design, and ongoing enhancements that will be rolled out over the next three years. The new online experience integrates with the library’s catalog, showcasing the Library’s diverse range of collections, events, and services. CPL is the first library system to date to launch this innovative online platform. The new website, catalog, and mobile apps are all “software as a service” providing the foundation for continuous innovation while reducing the need for costly in-house infrastructure and staff technical expertise.

You’ll immediately notice the more customer-friendly features, including the ability to create a unique user name and PIN, keep a history of what you have checked out and a wish list of what you want to borrow in the future. You can also rate titles, as well as write and read reviews of books, movies and music – visible not only to other CPL patrons, but also to the community of the 200 libraries around the world currently using BiblioCommons’ catalog platform.

And of course, the new website also adapts to any screen size, like smart phones and tablets; the responsive design ensures users have the same experience–no matter the mobile device. Free apps will also be available for iPhone/iPod Touch and Android.

gha_language: HTML


text:
### Python の本

[写真](https://firebasestorage.googleapis.com/v0/b/hola-c4bc5.appspot.com/o/photo6253451926503008228.jpg?alt=media&token=d30364e7-6a5a-4dc8-a430-4a2561a3ac00)

---

### Primitive Datatypes and Operators

---

### Data Types

*   Numbers
*   Booleans
*   Strings
*   Lists
*   Tuples
*   Dictionaries

---

### Numbers

1.  Integers
2.  Floats

---

|          | Operation            |
| -------- | -------------------- |
| x + y    | Add                  |
| x - y    | Sub                  |
| -x       | Negate               |
| +x       | Plus                 |
| x \* y   | Multiply             |
| x / y    | Divide               |
| x // y   | Integer Divide(整除) |
| x % y    | Modulo(取余)         |
| x \*\* y | 乗方                 |

---

### Division with Integers

### python2

```python
5 / 2 = ?
5 // 2 = ?
```

### python3

```python
5 / 2 = ?
5 // 2 = ?
```

---

### Division with Integers

### python2

```python
5 / 2 = 2
5 // 2 = 2
```

### python3

```python
5 / 2 = 2.5
5 // 2 = 2
```

---

### Booleans

*   True
*   False

---

### Booleans

*   True (1)
*   False (0)

---

### Booleans

```python
# Note using Bool operators with ints
# False is 0 and True is 1
# Don't mix up with bool(ints) and bitwise and/or (&,|)
0 and 2     # => 0
-5 or 0     # => -5
0 == False  # => True
2 == True   # => False
1 == True   # => True
-5 != False != True #=> True
```

---

### Booleans

| ==  | Equal to                 |
| --- | ------------------------ |
| !=  | Not equal to             |
| <   | Less than                |
| >   | Greater than             |
| <=  | Less than or equal to    |
| >=  | Greater than or equal to |

---

### Booleans

```python
# (is vs. ==)
# is checks if two variables refer to the same object,
# but == checks if the objects pointed to have the same values.
a = [1, 2, 3, 4]
b = a
b is a
b == a
b = [1, 2, 3, 4]
b is a
b == a
```

---

### Booleans

| Operator | What it means                | What it looks like |
| -------- | ---------------------------- | ------------------ |
| and      | True if both are true        | x and y            |
| or       | True if at least one is true | x or y             |
| not      | True only if false           | not x              |


text:
# EGI documentation

[![Build Status](https://travis-ci.org/EGI-Foundation/documentation.svg?branch=master)](https://travis-ci.org/EGI-Foundation/documentation)

Sources to build
[EGI documentation static pages](https://egi-foundation.github.io/).

- [Hugo](https://gohugo.io/) is used to build a static website.
- The theme [docsy](https://www.docsy.dev) is used.
- The static site is
  [deployed on GitHub](https://gohugo.io/hosting-and-deployment/hosting-on-github/)
  using a dedicated
  [GitHub repository](https://github.com/EGI-Foundation/EGI-Foundation.github.io).

> If you are interested in contributing please check the
> [Contributing Guide](https://docs.egi.eu/about/contributing/).

### Requirements

- mdl
- hugo
- NodeJS
  - postcss-cli
  - autoprofixer

### Installing dependencies, building and testing

To install npm+nodejs please check the instructions at:
https://www.npmjs.com/get-npm

The rest of the tools can be installed as follows:

```console
gem install mdl
npm install<EMAIL_ADDRESS>npm install<EMAIL_ADDRESS>```

The supported Hugo version packages are available under the `binaries` folder.

To build the site, from the repository root

```console
git submodule update --init --recursive --depth 1
mdl -s relaxed -s style.rb -r ~MD002,~MD024 content/
./binaries/<platform>/hugo
```

To test your changes:

```console
./binaries/<platform>/hugo server -D
```

The website is available locally at: http://localhost:1313/

## Usage

Please refer to [Hugo documentation](https://gohugo.io/documentation/) and
[docdock theme documentation](https://docdock.netlify.com/).

### Updating the theme

To ease management the [docsy](https://www.docsy.dev/docs/getting-started/)
theme has been cloned as a git submodule.

Updating the submodule

```console
git submodule foreach git pull
git commit themes/docsy -m 'Update theme'
```

### Deploying to the EGI organisation pages

To speed up the travis run a binary version of Hugo (extended version) for Linux
64 bit is included in the repository under `binaries`. Updates can be downloaded
at https://github.com/gohugoio/hugo/releases.

Travis will automatically deploy a new version when a PR is merged to master.

repository: vtenhunen/documentation

repo_name: vtenhunen/documentation


text:
# PROMPT
## Spaceship ZSH

This issue is related to how your terminal emulator renders Unicode 9 characters. To fix this issue:
- Make sure terminal uses Unicode Version 9 Widths.
- Let your terminal render ambiguous-width characters as double-width.

In iTerm follow these instructions:
- Go iTerm → Preferences… (⌘,) → Profiles → Text
- Check Unicode Version 9 Widths.
- Check Threat ambiguous-width characters as double-width.
- Reload terminal's tab.

## Resources
- [Troubleshooting](https://github.com/denysdovhan/spaceship-prompt/blob/master/docs/Troubleshooting.md)

repository: ZeroDeth/dotfiles

gha_language: Shell

repo_name: ZeroDeth/dotfiles


text:
---
hrs_structure:
  division: '2'
  volume: '11'
  title: '26'
  chapter: 481R
  section: 481R-7
type: hrs_section
tags:
  - Business
menu:
  hrs:
    identifier: HRS_0481R-0007
    parent: HRS0481R
    name: 481R-7 General warrantor operation requirements
weight: 37035
title: General warrantor operation requirements
full_title: 481R-7 General warrantor operation requirements
---
**[§481R-7] General warrantor operation requirements.** (a) A warrantor may appoint a designee to be responsible for any or all of the administration of vehicle protection products and for compliance with this chapter. The designee shall be liable to the extent the warrantor would be liable for violations of this chapter committed by the designee.

(b) A vehicle protection product may not be issued, sold, or offered for sale in this State unless at the time of purchase the warrantor provides to the consumer:

(1) A copy of the vehicle protection product warranty; or

(2) A receipt for, or other written evidence of, the purchase of the vehicle protection product.

(c) A warrantor who complies with subsection (b)(2), within thirty days after the date of purchase, shall provide to the consumer a copy of the vehicle protection product warranty.

(d) A warrantor shall indemnify a seller who pays or is obligated to pay a consumer any money the warrantor is obligated to pay under the terms of the vehicle protection product warranty, including damages, reasonable attorney's fees, and costs. [L 2002, c 237, pt of §1]

repository: SamMade/BlueAndKrabby

repo_name: SamMade/BlueAndKrabby


text:
Ignorance 1.3
=============
[![Ko-Fi](https://img.shields.io/badge/Donate-Ko--Fi-red)](https://ko-fi.com/coburn)
[![PayPal](https://img.shields.io/badge/Donate-PayPal-blue)](https://paypal.me/coburn64)
[![GitHub issues](https://img.shields.io/github/issues/SoftwareGuy/Ignorance.svg)](https://github.com/SoftwareGuy/Ignorance/issues)
![GitHub last commit](https://img.shields.io/github/last-commit/SoftwareGuy/Ignorance.svg) ![MIT Licensed](https://img.shields.io/badge/license-MIT-green.svg)

_If you feel so inclined, I'd appreciate [**a coffee** to keep me
caffeinated](https://ko-fi.com/coburn) if you use this transport._

Welcome to Ignorance, a Enet-powered Transport system for the [Mirror
Networking](https://github.com/vis2k/Mirror) project. By utilizing the tried
and true ENet native C library, Ignorance provides reliable UDP communications
for your game projects where the default Telepathy TCP transport would choke.

Ignorance scales up to 4096 theortical CCU with up to 255 channels per client (also known as a peer in Enet terms). Channels
allow you to split up network communications so you can have channels for data that are
mission critical as well as non-essential data. Mirror and by extension, Unity, choke
before hitting that CCU mark in the real world unless one carefully optimizes their network code carefully.

Ignorance was used in a recent "Vinesauce is Hope" walking simulation demo which had multiple
server instances running with over 300 CCU each. [Video clips available here.](https://clips.twitch.tv/UglyColdbloodedAlfalfaAllenHuhu)

Ignorance was originally intended to replace Unity's LLAPI Transport that ships with
Mirror, however since it uses native libraries it was deemed too risky to ship with Mirror itself.

Enet has been proven to be superior when compared to Unity LLAPI. Please read the FAQ (towards the bottom of this wall of text) before using the
Ignorance Transport.

Compatiblity
------------

### Desktop

-   **Windows 7, 8.1, 10 x64**
    -   32bit (x86) Environments not supported. **Use 64bit instead.**

    -   ARM64 Environments not currently supported (ie. Windows 10 on Raspberry Pi 4)

-   **macOS 10.12 onwards**
    -   El Captain and below **ARE NOT** supported.

    -   Compiled on a GitHub autobuilder MacOS instance.

    -   Tested and confirmed working on High Sierra, Mojave, Catalina. Big Sur probably works too?

-   **Linux x64**

    -   GCC-compiled x86_64 libraries are included, compiled on a Ubuntu buildbot.

    -   Should *just work* on various Linux distros, as long as they aren’t too
        exotic. Main testing has been done on Debian/Ubuntu/Fedora/CentOS/Arch.

    -   If your distro uses a different C library instead of GNU C then you’ll
        need to recompile the blobs manually. See the ENet-CSharp repository for
        more information.

### Console

-   **Nintendo Switch**

    -   Manual compile of Enet native binaries required, [see this document from the ENet-CSharp
        repository.](https://github.com/SoftwareGuy/ENet-CSharp/blob/master/BUILD-FOR-SWITCH.txt)

-   **Xbox One**

    -   UWP: Tested and confirmed working for **LAN Client only**. LAN Host doesn't work.

    -   Native: Possibly, however I don’t have development kit or license to
        test.

-   **PlayStation**

    -   Vita: Dead platform.

    -   PS4: Likely would require custom version of Enet due to the console using a BSD-based OS.

### Mobile

-   **Android**

    -   Android 4.4 "KitKat" onwards.

    -   ARMv7, ARM64 and x86 blobs are included.

    -   x86_64 Blobs are not included since Unity 2018.4 LTS does not support
        that platform yet.

-   **Apple iOS**

    -   System version 8.0 minimum

    -   Supports iPhone 4S to the latest iPhone. Tested and working on iPhone
        4S, iPhone 5s, iPad 2 WiFi + 3G and iPad (5th Gen)

    -   Compiled as a FAT library.

Dependencies
------------

-   [ENet-CSharp](https://github.com/SoftwareGuy/ENet-CSharp)

-   [Mirror Networking](https://github.com/vis2k/Mirror)

Mirror Compatibility
--------------------

Please use the Mirror Asset Store releases. The master branch of Mirror can also
be used but please beware that it's bleeding edge.

Installation
------------

Download the Unity Package from Releases that is the latest one. Simply import
the Unity Package and Unity will do the rest. Follow the instructions below.

How to use
----------

As of Ignorance 1.3, I have included a pre-configured sample scene so you can
get started easily. Otherwise add the script called **Ignorance Threaded** to your NetworkManager object,
removing any TCP-based or other UDP-based transport. Then set the script to be used in NetworkManagers' "Transport" field.

FAQ (aka Please Read This First)
--------------------------------

### Why should I use Ignorance over Unity LLAPI?

Don't even talk about Unity LLAPI - it's obsolete and dead in the eyes of Unity Technologies.
Depending on what you threw over the network, you'd get random latency spikes and packets would
go missing even in reliable delivery mode.

Ignorance aimed to be the LLAPI replacement that harnesses ENet's stable and high performance
networking so you can forget about low-level networking stress and spend more time
focusing on development of the high-level portion of your networked game.

### Ignorance Classic is no more. Ignorance Threaded is here to take its place.

As of Ignorance <IP_ADDRESS>, Ignorance Classic is no longer in this repo. It was causing Access Violations and
since it was on the chopping block for quite some time, I decided it was dead weight and gave it the axe.

In short, use Ignorance Threaded and enjoy high performance threaded networking.

### Important note

Since Mirror and all transports use LateUpdate to process their network code,
there might be a chance that at very low framerate (ie. you are really stressing
the server or creating lots of GameObjects in which Unity has to load from disk)
that the networking gets overwhelmed, regardless of how ENet is coping in the
native world.

It is essential to keep your server's frame rate running as high
as possible as this will reduce latency and in-game lag. You will be able to
tell when the server is under heavy stress when networked objects get very
choppy and/or the client starts hanging.

Mirror using LateUpdate for polling is a design flaw that the main developers have
little interest in fixing. Until they decide to change it, we are stuck with
having to deal with this design issue.

### I have a bug!

[Check the current open bug reports and/or report a new one
here](https://github.com/SoftwareGuy/Ignorance/issues). I strongly also recommend you
be present in the [Mirror Discord](https://discord.gg/N9QVxbM) so I can ask for further info and/or you can test
fixes for your bug reports. Trolls are not welcome.

Bugs that do not have enough details will be closed with \#wontfix. Details like
your OS, Unity Editor version, any Ignorance errors, etc is essential for a good
bug report.

I have questions, I want answers.
---------------------------------
[Here's a quick primer.](https://vis2k.github.io/Mirror/Transports/Ignorance)

It might be slightly out of date, but it covers the basics of Ignorance.

### I am not satisfied with Ignorance.

Please let me know why as I can't improve my code if I don't get feedback.
*However, if you're just here to troll me and my code, then please move on.*

See also:
[LiteNetLib4Mirror](https://github.com/MichalPetryka/LiteNetLib4Mirror).

Credits
-------

-   **Coffee Donators**: Thank you so much.

-   [vis2k](https://github.com/vis2k) and [Paul](https://github.com/paulpach):
    Mirror lead developers.

-   [Katori](https://github.com/katori): Helped kickstart the threaded version
    that evolved into Ignorance 2.

-   [BigBoxVR](https://github.com/GabeBigBoxVR): Pull requests and found a race
    condition that threatened stability.

-   [c6burns](https://github.com/c6burns): Words cannot describe how much help
    he's been. Bloody oath mate.

-   [Petris](https://github.com/MichalPetryka): Code refactoring and tidy up
    (you rock man!)

-   [BigBoxVR](https://github.com/GabeBigBoxVR) and
    [Martin](https://github.com/martindevans): Pull requests.

-   **The folks at the Mirror discord**: Memes, Courage, laughs, drama and
    all-round awesome folks to chat with.

-   To all the others who I have missed. Thanks a lot, you know who you are.

-   You too can have your name here if you send in a PR. Don't delay, get your
    PR in today!

### Previous hall of fame:
-   [FSE_Vincenzo](https://github.com/Vincenz099): Providing insight into proper
    usage of ENET, rebuttal, improvements, etc.

-   [shiena](https://github.com/shiena): Pull requests for bug fixes and
    oversights.

-   [Draknith](https://github.com/FizzCube): Testing and mapping
    Reliable/Unreliable channels in Mirror to ENET Channels, testing.

-   [nxrighthere](https://github.com/nxrighthere): Helped debug some things in
    early versions of Ignorance, author of the upstream ENet-CSharp repository
    my fork is based on

repository: VoltUnityPackages/Ignorance

gha_license_id: NOASSERTION

repo_name: VoltUnityPackages/Ignorance


text:
# Working with files

## Reading and writing files

Elmo comes with a build-in function to read files. The ``file`` function. It actually does a bit more than just reading, it provides information about a file returned as an elmo dictionary.

```elmo
readme: (file README.md)
puts $readme
```

The ``file`` function returns a dictionary with the following properties:

- ``absPath`` (gives the absolute path)
- ``exists`` (checks if file exists)
- ``isDir`` (checks if file is a directory)
- ``size`` (file size)
- ``mode`` (unix style string representation of the file mode. e.g. -rw-r--r--)
- ``name`` (well, the name of the file)
- ``path`` (the relative path)
- ``binary`` (a function returning the content as binary value)
- ``string`` (a function returning the content as string value)
- ``write`` (a function to write content to the file)
- ``append`` (a function to append content to the file)

### read

To retrieve the content of a file, simply use the returned ``string`` function:

```elmo
content: ((file README.md) string)
puts $content
```

### write

And to write something to a file, simply use the returned ``write`` function:

```elmo
f: (file data.txt)
f.write "nice!"
```

A simple trick to read content from a file, process it and write it to another file is by combining read and write in a pipe construction:

```elmo
str: (load string)
((file in.data) string) | (func s { str.replace all $s "a" "o" }) | ((file out.data) write)
```

### append

Writing to files will overwrite existing content. It's also possible to append content to a file using a file's ``append`` function.

```elmo
f: (file data.txt)
f.append "first line"
f.append "\n"
f.append "second line"
```

## Temporary files

Elmo has build in support to work with temporary fileswhich are removed after being using. This is done through the ``tempFile`` function. ``tempFile`` Creates a temporary file in the default directory for temporary files. It then executes the provided block of elmo code, passing the associated file dictionary as variable, and removes the file afterwards.

```elmo
result: (tempFile tmp {

    # do something with $tmp

    return $tmp.absPath
})
```

## Reading CSV files

Elmo comes with a ``data`` module which contains some handy functions to work with structured data. It, among other formats, support the parsing of comma separated value files.

```
data: (load data)
peppers: (((file "peppers.csv") string) |data.fromCSV)
```

Suppose the peppers.csv file contains data like

```csv
shumin, shumax, rating, name
855000, 1463000, 4.0, Ghost Pepper
876000, 970000, 4.0, Dorset Naga
```

Then the ``data.csv`` function (assuming the data module is loaded as ``data``), returns a list of dictionaries with the properties found on the first line of the CSV file. To assert this try:

```elmo
(peppers 0) name |eq "Ghost Pepper" |assert
(peppers 1) shumax |eq 970000 |assert
```

## Reading JSON files

The same kind of mechanism can be used to read a file containing JSON data.

```
data: (load data)
peppers: (((file "peppers.json") string) |data.fromJSON)
```

Here the ``data.json`` function does the trick. It assumes the input data contains a JSON object and converts it to an elmo dictionary.

## Producing CSV data

Elmo can convert a list of dictionaries into a string containing CSV data.

```elmo
data: (load data)

# Load csv data (which returns a list of dictionaries)
#
peppers: (((file "./test/peppers.csv") string) |data.fromCSV)

# And produce csv again. But only use name and rating properties
#
puts (data.toCSV ["name" "rating"] $peppers)
```

## Producing JSON data

Elmo dictionaries (and other value types) can be easily converted to strings containing JSON data.

```elmo
data: {
    Pepper: "Cayenne"
    shu: {
        min: 30000
        max: 50000
    }
    notAsHotAs: ["habanero", "santaka"]
}
json: (data.toJSON $data)
puts $json
```

This will print one line of JSON (which looks almost the same as the original Elmo dictionary):

```elmo
{"Pepper":"Cayenne","notAsHotAs":["habanero","santaka"],"shu":{"max":50000,"min":30000}}
```

Note, the order of all properties is sorted by key name when converted to JSON.

repository: okke/elmo

repo_name: okke/elmo


text:
---
title: "Video for iOS"
excerpt: ""
---
The Sinch SDK is a product that makes adding voice/video calling and/or instant messaging to mobile apps easy. It handles the complexity of signaling and audio & video management while providing you the freedom to create a stunning user interface.

This document provides an overview for developers integrating with Sinch SDK for the first time. It outlines the prerequisites and guides you through the process of setting up and answering calls as well as sending and receiving instant messages.

Please see the [Reference Documentation](http://www.sinch.com/docs/ios/reference/) for a comprehensive description of all the classes.

Edit on GitHub

repository: davidmarquis/docs

repo_name: davidmarquis/docs


text:
# Asteroids_v2

A spin from the Atari Asteroids game from 1979, but with more weapons. I didn't program in death so anyone playing has to use cheat codes to add more enemies.

This is a rewrite of my original assignment from Mr. Simon's AP Computer Science class. https://github.com/APCSLowell/AsteroidsGame

[![Java Asteroids Demo](https://img.youtube.com/vi/qiRtD9vJ2K8/0.jpg)](https://www.youtube.com/watch?v=qiRtD9vJ2K8)

Demo here: https://youtu.be/qiRtD9vJ2K8

## Features
* Decked out ship with laser, repellant, chain lightning and zero laser.
* Options panel for changing the color of your ship
* Options panel for changing controls (doesn't work on Mac)
* Anti-aliasing for smoother rendering

## Controls
Move - Left Mouse button OR WASD OR Arrow Keys

Space - Fire primary weapon

Tab - Show weapon cooldowns

Left CTRL - Hyperspace

1-9 - Weapons

0 - Toggle Debug mode (adds a shield, unlimited bullets and gives a lot more HP)

F1 - Options Panel for changing ship color and game controls

F5 - Partially lower health

F6 - Multiply speed by 1.1

F8 - Kill all asteroids

F9 - Add new asteroids

F11 - Add new small asteroids

F12 - Restart game

## Install
All code is in the src folder.
Asteroids can either be a Java Applet or Java Application. `main()` is in `mainClass.java`.

 It was like being a space engineer without any money, any physics or electrical or mechanical knowledge.

### Why didn't you make it into a commercial game?
I thought hard about making this into a real game that I could sell on Steam, but I felt like that was 10x the work. I would have had to do the level design, stats balancing, boss design, sound design, customer feedback, optimization to 60+ FPS, visual polish beyond lines and circles. A new "Geometry wars" had just been released too, so my motivation died because I didn't want to release an inferior copy. Yes I can carve out another niche within the arcade genre. I just have to be more creative.

### How much time did you spend on this?
A few hundred hours.

### Which weapon was the hardest to make
The reinforcements and chain lighting were very difficult. I had to think of all the psudocode in my head before writing anything. You can read it in `Reinforcements outline.txt`

## I want some ideas to make my Asteroids unique
Weapon ideas: black hole, lasso, powerups, snakes, fire, gravity wave

Mechanics ideas: play the map on a 3D sphere instead of a 2D rectangle, control more than one ship at a time, make a space tower defense

Alternatively, remove the space theme and make another kind of shooter

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

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

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


text:
---
title: About
permalink: about/
profile: true
---

Undergraduate Student
Former Director of Academic Department of the Student Union of the College

[Computer Science and Technology][cist]
[Beijing Normal University][bnu]

Email<EMAIL_ADDRESS>
LinkedIn: <https://cn.linkedin.com/in/xuhongxu>
GitHub: <https://github.com/xuhongxu96>
Facebook: [Hongxu.Xu][facebook]
Twiiter: [Xuhongxu_it][twitter]
QQ: 469614686

Follow @Xuhongxu_it

# Short BIO
Hongxu Xu is currently an undergraduate student in the College of Information Science and Technology at Beijing Normal University. He enrolled in Beijing Normal University in 2014 and major in Computer Science. He is the former director of Academic Department of the Student Union of the College of Information Science and Technology.

# Projects

1. [Website for Baige Volunteer Association of Beijing Normal University][bnubaige]
2015.3 - 2015.6
2. [Website for Multimedia Platform of Beijing Normal University][bnumedia]
2015.6 - 2015.9
3. [Campus public bike renting system - Tagexing 2][tagexing2]1
2015.6 - 2016.1
    - [Campus public bike renting system - Tagexing (Deprecated)][tagexing]
2014.12 - 2015.7
4. [Students' spare time calculator][timetable]2
2015.9
5. [Web-based Gateway Logger for Beijing Normal University][gateway]
2016.3
6. [Schoolwork Assistant for Beijing Normal University (Python)][bnujwc]
2016.2 - 2016.3
7. [BNU Xiaoya (Android)][bnuxiaoya]
2016.2 - now

# Coursework
1. [Data Structure][data-structure-course]
2015.9 - 2015.12
2. [Algorithm Design][algorithm-course]
2016.3 - now
3. [Computer Graphics][cg-course]
2016.3 - now

# Honors
1. **Volunteer Star**
Baige Volunteer Association of Beijing Normal University 2014.10
2. **Second Prize in Beijing Normal University Programming Contest**
College of Information Science and Technology at Beijing Normal University 2014.12
3.  **Second Prize in "Dianshi Cup" Beijing University creative design competition (Participant)**
Beijing University 2015.6
5. **Top Ten Volunteers of Beijing Normal University**
Beijing Normal University Youth League, Baige Volunteer Association of Beijing Normal University 2015.11
6. **Gold Prize in Capital University Buisiness Contest**
Beijing Science and Technology Association, China Youth League, Beijing Student Union, Beijing Education Institution... 2016.6

----
1. Tagexing is a campus bike sharing project belonging to Baige Volunteer Association in Beijing Normal University.
2. Supporting importing students' class schedule conveniently, and generating a table indicating students' spare time.

----

[Source code of this blog][blog-source]

{% include footer.html %}

[cist]: http://cist.bnu.edu.cn
[bnu]: http://www.bnu.edu.cn
[mail]<EMAIL_ADDRESS>[facebook]: https://www.facebook.com/hongxu.xu
[twitter]: https://twitter.com/Xuhongxu_it

[bnubaige]: http://vol.bnu.edu.cn
[bnumedia]: http://media.bnu.edu.cn
[tagexing2]: https://github.com/xuhongxu96/tagexing2
[tagexing]: https://github.com/xuhongxu96/Tagexing
[timetable]: https://github.com/xuhongxu96/timetable
[gateway]: https://github.com/xuhongxu96/BNU-Gateway
[bnujwc]: https://github.com/xuhongxu96/BNU-Schoolwork-Assist
[bnuxiaoya]: https://github.com/xuhongxu96/BNU-Xiaoya

[data-structure-course]: https://github.com/xuhongxu96/Data-Structure-Course
[algorithm-course]: https://github.com/xuhongxu96/Algorithm-Design-Course
[cg-course]: https://github.com/xuhongxu96/Computer-Graphics-Course

[blog-source]: https://github.com/xuhongxu96/xuhongxu96.github.io


text:
## Start Pose Estimation

We provide a demo for video-based pose estimation:
```shell
mmskl pose_demo [--video $VIDEO_PATH] [--gpus $GPUS] [--$MORE_OPTIONS]
```
This demo predict pose sequences via sequentially feeding frames into the image-based human detector and the pose estimator. By default, they are  **cascade-rcnn** and **hrnet** respectively. To check the full usage, please run `mmskl pose_demo -h`. You can also refer to [pose_demo.yaml](../configs/pose_estimation/hrnet/pose_demo.yaml) for detailed configurations.

We also provide another demo `pose_demo_HD` with a slower but more powerful detector. Similarly, run:
```shell
mmskl pose_demo_HD [--video $VIDEO_PATH] [--gpus $GPUS] [--$MORE_OPTIONS]
```

repository: ideaflow/mmskeleton

gha_language: Cuda

repo_name: ideaflow/mmskeleton


text:
[![github license badge](https://img.shields.io/github/license/eWaterCycle/era5cli)](https://github.com/eWaterCycle/era5cli)
[![rsd badge](https://img.shields.io/badge/RSD-era5cli-blue)](https://research-software-directory.org/software/era5cli)
[![fair-software.eu](https://img.shields.io/badge/fair--software.eu-%E2%97%8F%20%20%E2%97%8F%20%20%E2%97%8F%20%20%E2%97%8F%20%20%E2%97%8B-yellow)](https://fair-software.eu)
[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.3252665.svg)](https://doi.org/10.5281/zenodo.3252665)

[![Documentation Status](https://readthedocs.org/projects/era5cli/badge/?version=stable)](https://era5cli.readthedocs.io/en/stable/?badge=stable)
[![build](https://github.com/eWaterCycle/era5cli/actions/workflows/test_and_build.yml/badge.svg)](https://github.com/eWaterCycle/era5cli/actions/workflows/test_and_build.yml)
[![Test Coverage](https://codecov.io/gh/eWaterCycle/era5cli/branch/main/graph/badge.svg?token=qeZXgGASBK)](https://codecov.io/gh/eWaterCycle/era5cli)
[![PyPI](https://badge.fury.io/py/era5cli.svg)](https://badge.fury.io/py/era5cli)

A command line interface to download ERA5 data from the [Copernicus Climate Data Store](<https://climate.copernicus.eu/>).

With `era5cli` you can:

 - Download meteorological data in GRIB/NetCDF, including ERA5 data from the preliminary back extension, and ERA5-Land data.
 - List and retrieve information on available variables and pressure levels
 - Select multiple variables for several months and years
 - Split outputs by years (and optionally months), producing a separate files instead of merging them in one file
 - Download multiple files at once
 - Extract data for a sub-region of the globe

Free software: Apache Software License 2.0

Documentation: https://era5cli.readthedocs.io


text:
# Pipeline
A std of pipeline.

## The Mind
- Limit: Consider the pipeline to be one line and just forward.
- featurs:
    - Forward pipeline
    - Mutable batch size for invoke

## API

### 1. ForwardPipeline
- Constructe a forward pipeline.
```
ForwardPipeline pipeline = pipeline::ForwardPipeline;
```

### 2. addTask
- Add a task with num threads.
```
shared_tsque(Ret) addTask(int num_threads,
                          Ret (*func)(Args...),
                          shared_tsque(T) in,
                          TArgs... rest)
```

### 3. addTaskStackBatch
- Add a task with num threads.
- Load list of datas in inque, put one data to outque.
```
shared_tsque(Ret) addTaskStackBatch(int num_threads,
                                    Ret (*func)(Args...),
                                    shared_tsque(T) in,
                                    int batch_size,
                                    TArgs... rest)
```

### 4. addTaskSplitBatch
- Add a task with num threads.
- Load one data for inque (it should be a vector), put list of datas to outque.
```
shared_tsque(Ret) addTaskSplitBatch(int num_threads,
                                    std::vector<Ret> (*func)(Args...),
                                    shared_tsque(T) in,
                                    TArgs... rest)
```

### 5. stackPipe
- Stack the datas for different pipe to one single pipe.
```
shared_tsque(T) stackPipe(int num_threads,
                          std::vector<shared_tsque(T)> in)
```

repository: smarsu/pipeline

repo_name: smarsu/pipeline


text:
RiotControl
============

```
npm install @zaplabs/riotcontrol-requirejs
```

A Simplistic Central Event Controller / Dispatcher For [RiotJS](https://github.com/muut/riotjs), Inspired By Facebook's [Flux](https://github.com/facebook/flux) Architecture Pattern.

RiotControl is, in the spirit of Riot itself, extremely lightweight. It forgoes elements of Flux, to favor small and simple applications. RiotControl passes events from views to stores, and back, relying heavily on Riot's observerable API. Stores can talk to many views, and views can talk to many stores.

Usage
============

Requires Riot 2.0+

Include riotcontrol.js, or it's few lines of code, in your project.

API
============

Register the store in central dispatch, where store is a riot.observable(). Generally, all stores should be created and registered before the Riot app is mounted.

```javascript
RiotControl.addStore(store)

// Example, at start of application:
var todoStore = new TodoStore() // Create a store instance.
RiotControl.addStore(todoStore) // Register the store in central dispatch.
```

Trigger event on all stores registered in central dispatch. Essentially, a 'broadcast' version of Riot's el.trigger() API.

```javascript
RiotControl.trigger(event)
RiotControl.trigger(event, arg1 ... argN)

// Example, inside Riot view (tag):
RiotControl.trigger('todo_add', { title: self.text })
```

Listen for event, and execute callback when it is triggered. This applies to all stores registered, so that you may receive the same event from multiple sources.

```javascript
RiotControl.on(event, callback)

// Example, inside Riot view (tag):
RiotControl.on('todos_changed', function(items) {
    self.items = items
    self.update()
})
```

Remove event listener.

```javascript
RiotControl.off(event)

RiotControl.off(event, callback)
```

Same as RiotControl.on(), executes once.

```javascript
RiotControl.one(event, callback)
```

repository: zap-labs/RiotControl

repo_name: zap-labs/RiotControl


text:
---
title: August ASB, new devices and new features
mathjax: true
layout: post
---

Most of you already got the update and some already discovered the new changes. For those that didn't yet, here is what to look out for.

The latest weeklies feature the [August Security Patches](https://source.android.com/security/bulletin/2019-08-01.html) based on android-9.0.0_r46 and we've added lockscreen weather! You can enable it in CarbonFibers.

Also, thanks to newly joined team members we were able to extend our list of supported devices.
We're happy to welcome back the [Samsung Galaxy S2](https://get.carbonrom.org/device-i9100.html) (yes, that thing that released with Gingerbread back in 2011) and the [Xiaomi Redmi Note 5](https://get.carbonrom.org/device-whyred.html).

Lastly, an announcement for all OnePlus 3/3T users: Starting with the latest weekly you will need to use the latest Pie firmware from OnePlus.

repository: CarbonROM/blog-sources

repo_name: CarbonROM/blog-sources


text:
# Relay-Modern Application

[![Commitizen friendly](https://img.shields.io/badge/commitizen-friendly-brightgreen.svg?style=flat-square)](http://commitizen.github.io/cz-cli/)
[![React](https://img.shields.io/badge/react-15.5-blue.svg?style=flat-square)](https://github.com/facebook/react)
[![Relay Modern](https://img.shields.io/badge/relay-dev-brightorange.svg?style=flat-square)](https://github.com/facebook/relay/releases/tag/v1.0.0-rc.1)

Playing around with React + Relay + GraphQL

repository: rockchalkwushock/relay-modern-app

repo_name: rockchalkwushock/relay-modern-app


text:
## Continuous deployment and integration using Cloud Foundry

In this session we will explore how to build and deploy cloud native applications using Cloud Foundry.

Requirements:

- JDK 1.8 or later
- Gradle 2.3+ or Maven 3.0+
- IDE of choice
- [Virtual Box](https://www.virtualbox.org/wiki/Downloads)
- [Vagrant](https://www.vagrantup.com/downloads.html)
- [Cloud Foundry CLI](https://github.com/cloudfoundry/cli#downloads)
- [PCF Dev](https://network.pivotal.io/products/pcfdev)

### Topics

In this session we will explore how to set up a local Cloud Foundry environment using PCF Dev.

Topics:

* Introduction to Cloud Foundry
* Provisioning and binding to services
* Pushing applications to Cloud Foundry
* Service Brokers
* Spring Cloud Services
* Integrating Microservices on Cloud Foundry
* CI/CD with Concourse CI

### Getting setup

This section will require some extra steps to get your development environment setup. We're going to need to have Cloud Foundry running locally, as well as Concourse. This will require that we have the latest version of Virtual Box installed.

#### Virtual Box

The first thing we need is Virtual Box. Go to the download page located here: https://www.virtualbox.org/wiki/Downloads

Download and install the latest version of Virtual Box for your machine.

#### Vagrant

The next thing we're going to need is Vagrant. After Virtual Box has finished installing, go to the Vagrant download page located here: https://www.vagrantup.com/downloads.html

Download and install the latest version of Vagrant for your machine.

#### Cloud Foundry CLI

Before we can start talking to Cloud Foundry from our local machine, we'll need to grab and install the latest command line tools. You can find installation instructions here: https://github.com/cloudfoundry/cli#downloads

If you're on macOS, you can easily grab and install the binaries using Homebrew.

    $ brew tap cloudfoundry/tap
    $ brew install cf-cli

After you have installed the CF CLI, make sure you can open up a terminal or console window and run the following command.

    $ cf -v
    cf version 6.25.0+787326d95.2017-02-28

You should see the same or similar version as a response. If so, you're all set!

#### PCF Dev (Cloud Foundry)

What if you had a cloud environment on your local machine that you could use to learn and test your cloud-native applications on Cloud Foundry? That's the idea of PCF Dev -- a local Cloud Foundry environment for developers from Pivotal.

After Virtual Box and Vagrant have finished installing, go login or sign up for a Pivotal Network account: https://network.pivotal.io/registrations/new

If you're already signed up, you can download PCF Dev from here: https://network.pivotal.io/products/pcfdev

After you've downloaded the binary for PCF Dev from the download page on Pivotal Network, you'll need to open up a terminal or console to install the PCF Dev plugin.

    $ ./pcfdev-v0.24.0+PCF1.9.0-osx
    Plugin successfully installed. Current version: 0.24.0. For more info run: cf dev help

After locating and executing the PCF Dev binary, you should see the message above. The PCF Dev environment is actually a plugin for the CF CLI we installed in the previous step. Now all we have to do to spin up our local Cloud Foundry environment is to run the following command.

    $ cf dev start

You'll be asked to enter your Pivotal network credentials, which you should have handy from earlier. After authenticating on the CLI, you may be presented with an EULA for the PCF Dev beta. Read and then agree, to start the VM download and installation of PCF Dev.

After the installation completes, you'll see some epic ASCII art and directions for how to connect to Cloud Foundry using the CLI. To login, run the following command:

    $ cf login -a https://api.local.pcfdev.io --skip-ssl-validation

You'll be asked for a username and password. The answer is `admin` to both prompts. After you've signed in, you'll be asked to choose your org. Choose `pcfdev-org`.

Congrats! You've just installed the cloud to your local machine.

#### Concourse CI

The next thing we'll need to do is to set up a local environment for Concourse CI. Concourse is a continuous integration and deployment tool for cloud-native applications. We'll use this tool to build a continuous delivery pipeline to build and integration test our applications before deploying to Cloud Foundry.

The fastest way to get up and running with a local Concourse environment is to use Vagrant. Thankfully we installed Vagrant earlier.

The installation instructions can be found here: https://concourse.ci/vagrant.html

Open up a new terminal or console and run the following commands:

    $ vagrant init concourse/lite
    $ vagrant up

It's recommended you do this from a directory where you'll start Concourse from in the future. This is because the `vagrant init` command will download a `Vagrantfile` with the recipe for spinning up a Concourse VM in Virtual Box. Every time you want to stop or start the Concourse VM you'll return to this same directory.

After Vagrant is finished downloading and running the VM in Virtual Box, you'll be able to browse to the Concourse dashboard at http://<IP_ADDRESS>:8080/

You should see a web page that tells you to install the CLI tools. Go ahead and install the CLI tools for your platform.

The binary you'll download is called `fly` and you should install it to your environment so that it will always be available from your terminal or console. For macOS you can simply move it to your `/usr/local/bin`.

    $ chmod +x fly
    $ mv fly /usr/local/bin/fly

You're all set. Try running the following command from a new terminal or console window.

    $ fly -t lite login -c http://<IP_ADDRESS>:8080

You should now be signed in. Just to test the deployment of a simple pipeline, you can save the following snippet as `deploy-hello.yml`.

    jobs:
    - name: hello-world
      plan:
      - task: say-hello
        config:
          platform: linux
          image_resource:
            type: docker-image
            source: {repository: ubuntu}
          run:
            path: echo
            args: ["Hello, world!"]

Now open a terminal window and go to the directory where you saved `deploy-hello.yml`. Run the following command.

    $ fly -t lite set-pipeline -p hello-world -c deploy-hello.yml

Follow the prompts and you'll then be able to see your pipeline running on the dashboard located here: http://<IP_ADDRESS>:8080/teams/main/pipelines/hello-world

To run the deployment job you can click the play button on the dashboard or head back to your CLI and run the following command:

    $ fly -t lite unpause-pipeline -p hello-world

Now head back to your dashboard in the browser and you should see the `hello-world` build running!


text:
---
layout:   post
title:    "Pretty Terminal"
date:     2016-07-23
category: CompSci
tags:     [terminal, shell, colour]
---

This is just a short post about my new terminal setup. I think it's both pretty and useful. For example, it gives me the current time and info about version control when I'm in a directory with vcs:

![A Zsh terminal, with the powerlevel9k theme (default settings), and the Gogh Aci colour scheme on the font Source Code Pro]({{url}}/images{{page.id}}/iterm2_gogh_aci_source_code_pro_zsh_powerlevel9k.png)

Skip to the [end](#tldr) for terse instructions/commands for mac and linux.

## Terminal

First off, you need a good terminal emulator that can handle 256 colours. Try `echo $TERM`. If it returns `xterm-256color` you're good. You can use a script [like this](https://raw.githubusercontent.com/mbadolato/iTerm2-Color-Schemes/2e5e8e7628ddb09bd2f9408a85e317d25ba7b282/tools/screenshotTable.sh) to get an overview of the kinds of colours that are in your current theme.

### But I don't get `xterm-256color`

OK. Well, if you're only linux, you terminal probably supports it, so look up the best way to set it to 256 colours. It might be just in the terminal settings, or the internet may advice you to put `TERM=xterm-256color` in a `profile` or `rc` file.
If you're on a mac, Terminal.app is not going to help you with 256 colours. What I did was install [iTerm2](https://iterm2.com/), which I'm happy with.

## Colour scheme

Since we're talking colours anyway, let's see about that colour scheme. I use the colour scheme [aci from Gogh](https://github.com/Mayccoll/Gogh/blob/master/content/themes.md#aci). I installed the colours manually rather than downloading the script. I suspect it only works on linux anyway. For mac users that decided on iTerm2, I exported the aci colour scheme after setting it up, so you can download it [here]({{url}}/other{{page.id}}/gogh-aci.itermcolors).

## Shell

The theme that I use is a theme for zsh. So instead of the standard bash shell, you'll need to run zsh. Now zsh can be customised a lot with plugins and you'll probably want to use a system that handles those plugins for you. I use [oh-my-zsh](http://ohmyz.sh/), but there are at least two other popular systems.

## Theme

The theme is called [powerlevel9k](https://github.com/bhilburn/powerlevel9k) and it's based on (ideas/symbols from) a Vim plugin called powerline. I use the standard configuration of the theme, but you can completely customise the information that the theme shows you. Do note that you need a special font to show the symbols in the terminal!

To make sure powerlevel9k doesn't show redundant information, set `DEFAULT_USER="<your-username-here>"` in `~/.zshrc`. You can `echo $USER` to get your current username.

## Font

I use the font Source Code Pro in my terminal. The theme does require special symbols, but on linux you can just install the powerline fonts via your package manager. On mac the easiest option is to install the [patched font](https://github.com/powerline/fonts) (font + relevant symbols) that you want to use in your terminal.

# Tl;dr

## Linux

1. Install oh-my-zsh:

   ```sh
   sh -c "$(wget https://raw.github.com/robbyrussell/oh-my-zsh/master/tools/install.sh -O -)"
   ```

    If you added you own stuff to `~/.bashrc` or `~/.bash_profile` now is the time to copy that to `~/.zshrc`.

2. To set `zsh` as the default shell everywhere:

   ```zsh
   chsh -s /bin/zsh
   ```

3. Install font(s) using your package manager. Search/install the powerline font or patched powerline fonts. Or:

   ```zsh
   git clone https://github.com/powerline/fonts.git ~/powerline-fonts
   cd ~/powerline-fonts && ./install.sh && cd - && rm -r ~/powerline-fonts
   ```

    Set the font in your terminal settings. I use Source Code Pro for Powerline.

4. Powerlevel9k theme:

   ```zsh
   git clone https://github.com/bhilburn/powerlevel9k.git ~/.oh-my-zsh/custom/themes/powerlevel9k
   sed -i 's:ZSH_THEME="robbyrussell":ZSH_THEME="powerlevel9k/powerlevel9k":' ~/.zshrc
   ```

5. Set `xterm-256color` and default user (so powerlevel9k doesn't show redundant info):

   ```zsh
   echo "# First thing to change is the TERM variable
   if [[ -e /usr/share/terminfo/x/xterm-256color ]]; then
       export TERM=xterm-256color
   fi

   DEFAULT_USER='$USER'
   " | cat - ~/.zshrc > /tmp/out && mv /tmp/out ~/.zshrc
   ```

6. Gogh aci colours:

   ```zsh
   wget -O xt  http://git.io/v3Dlm && chmod +x xt && ./xt && rm xt
   ```

## Mac

1. Install [iTerm2](https://iterm2.com/):

   ```sh
   brew cask install iterm2
   open iterm2
   ```

   If iterm2 wants to update, do that, currently `brew` has version 2.3 whereas version 3 is already out.

   (or just do the graphical download/install)

2. [Download this]({{url}}/other{{page.id}}/gogh-aci.itermcolors), type command+i (⌘+i), navigate to Colors tab, click on Load Presets, click on Import, select the downloaded file. Now click Load Presets again and select `gogh-aci`.

3. Install fonts:

   ```zsh
   git clone https://github.com/powerline/fonts.git ~/powerline-fonts
   cd ~/powerline-fonts && ./install.sh && cd - && rm -r ~/powerline-fonts
   ```

    Set the font in your terminal with command+i (⌘+i), select font, pick a font that ends with "for Powerline". I use Source Code Pro for Powerline.

4. Install oh-my-zsh:

   ```sh
   sh -c "$(curl -fsSL https://raw.github.com/robbyrussell/oh-my-zsh/master/tools/install.sh)"
   ```

    If you added you own stuff to `~/.bashrc` or `~/.bash_profile` now is the time to copy that to `~/.zshrc`.

5. Powerlevel9k theme:

   ```zsh
   git clone https://github.com/bhilburn/powerlevel9k.git ~/.oh-my-zsh/custom/themes/powerlevel9k
   sed -i 's:ZSH_THEME="robbyrussell":ZSH_THEME="powerlevel9k/powerlevel9k":' ~/.zshrc
   ```

6. Set default user so powerlevel9k doesn't show redundant info:

   ```zsh
   echo "DEFAULT_USER='$USER'
   " | cat - ~/.zshrc > /tmp/out && mv /tmp/out ~/.zshrc
   ```

## Windows

Sorry, but I don't develop on windows. I think you can probably reuse most of these instructions if you can get a proper terminal emulator. Or you could switch to a linux or whatever ¯\\\_(ツ)\_/¯

repository: Apanatshka/blog

branch_name: refs/heads/jekyll

gha_language: CSS

repo_name: Apanatshka/blog


text:
# Substance.js [![Build Status](https://travis-ci.org/substance/substance.svg?branch=devel)](https://travis-ci.org/substance/substance)

Substance is a JavaScript library for web-based content editing. It provides building blocks for realizing custom text editors and web-based publishing system. It is developed to power our online editing platform [Substance](http://substance.io).

## Development

Install the dev dependencies.

```
npm install
```

Run the dev server.

```
npm start
```

Navigate to `http://localhost:4001/test` for the running the browser test suite. The test suite is rebuilt as you make changes to the source files.

To run the test-suite headless.

```
$ npm test
```

repository: zhutony/substance

gha_language: JavaScript

repo_name: zhutony/substance


text:
# Introduction to Granitic
Back to: [Reference](README.md)

---

The purpose of Granitic is to allow developers who want to build web services in Go to do so with a single dependency.
Granitic is a framework (a library of code and patterns) but it is also a lightweight application server. By using Granitic
your Go application becomes a self-contained service which can accept HTTP requests, run scheduled activities or perform
any other task that is appropriate for the service tier of your architecture.

## Who should use Granitic?

There are many service and micro-service frameworks available for Go, each with its own intended audience and use cases.
Granitic is aimed at:

 * Developers who are new to Go and are moving from a framework like Spring or Rails in another programming language.
 * Developers who want a single framework to provide 'enough' features to build production ready web services without
 needing to research and import multiple libraries.
 * DevOps practitioners who require services to be container and FaaS friendly and to exist within a configuration-management
 controlled environment.

## Principles

Granitic was developed according to a number of design principles that are worth understanding in order to give context
to the way Granitic works and help you decide if it is right for your project.

###  Inversion of Control for lifecycle management

For building services where a non-trivial number of objects are created and where the concept of 'global' or 'singleton'
objects are important, Inversion of Control (IoC) remains a key design pattern. IoC is commonly implemented using a
container, where object life-cycles and configuration are defined declaratively in configuration files or as code annotations.

This model is common in languages where types can be loaded at runtime (like Java, C# etc) but less common in statically
linked languages like Go.

The heart of Granitic is a fully featured IoC container, which allows user components to be defined in configuration files
and converted into code using a 'binding' step in the build process.

###  Externalised and layered configuration

Typically services are created in a development environment then transition through a number of test and pre-production
environments before eventually being deployed to production. In each environment, different behaviours will required
(e.g. use of a mocked dependency in development) and different external resources will be accessed (e.g. different
database server hostname).

Granitic recognises and supports this workflow in two ways:

 * Configuration files are separate from the executable service (e.g. they're not 'burnt in' at compile time)
 * Configuration files can be layered (e.g. the configuration common to all environments can be defined in one file,
 the changes/overrides required for a particular environment can be defined in another)

Additionally, Granitic does not require that configuration files are hosted in the same compute resource (FaaS, container, VM)
as the executable. They can be loaded from a remote source at startup time.

### No downstream dependencies

Package management is a complicated problem in any programming language and it is our belief that it is developers who should
choose which third-party libraries at which versions should be included in their application, not framework developers.
As such Granitic has no downstream dependencies at all, even test frameworks.

### Easily replaceable core features

Because Granitic is intended to be self-contained, it has implementations of many capabilities (logging, scheduling,
validation) that are the subjects of other large and fully featured Go libraries. Granitic's principle is that its
implementation of these capabilities (_facilities_, in Granitic's terminology) should be mature and fully featured
enough to support the vast majority of use-cases, but if you want to swap out Granitic's implementation with your preferred
third-party implementation, you will be supported in doing so.

### Fast start-up

Cold start time is an increasing concern to application developers due to the increasing use of containers and FaaS as a
deployment mechanism. Start up time is a key performance metric for Granitic and is actively monitored and designed for.
Simple Granitic applications have sub-millisecond startup times on modern hardware.

repository: graniticio/granitic

gha_language: Go

repo_name: graniticio/granitic


text:
# multimodel-demo
view multi-model in Forge Viewer, with support for color themes, selection and isolation

Live Demo: https://wallabyway.github.io/multimodel-demo

Blog post: https://forge.autodesk.com/blog/highlighting-clashes-multi-model

![](https://user-images.githubusercontent.com/440241/46635291-badca780-cb08-11e8-8304-45788c9f322a.gif)

screenshot:
![](https://user-images.githubusercontent.com/440241/46625349-a812a480-cb01-11e8-8d79-db2789cdecca.jpg)

repository: sermonis/autodesk-forge-multimodel

repo_name: sermonis/autodesk-forge-multimodel


text:
---
layout: default
---

# 1998-09-15 - Re: The DES Analytic Crack Project

## Header Data

From: Anonymous<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: cc714d77a3f4c1894f3d35d658f598ac02e8f5dc37ee8e3427a7a0f8c1698be0

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1998-09-15 01:59:32 UTC

Raw Date: Tue, 15 Sep 1998 09:59:32 +0800

## Raw message

```
{% raw  %}From: Anonymous<EMAIL_ADDRESS>Date: Tue, 15 Sep 1998 09:59:32 +0800
To<EMAIL_ADDRESS>Subject: Re: The DES Analytic Crack Project
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

Eric Michael Cordian<EMAIL_ADDRESS>writes:

> The concerns are generally that
> we will experience an unexpected "combinatoric explosion" in the
> higher round problems

Unexpected by you, perhaps, but expected by everyone else.  The complexity
of the expressions should increase exponentially with the number of
rounds.  Extrapolating from two and four round results to eight and
sixteen is the wrong model.  (You can artificially suppress this by
introducing new variables for each round, but that doesn't change the
underlying complexity of the problem.)

Can't you come up with a back-of-the-envelope estimate for the number of
terms in your sixteen round expression?  Even without fully optimized
S-box expressions this information would be useful.  If it is greater than
the number of atoms on Earth then it would be a strong hint that this
approach won't work.

If you really want to attract money you need some kind of numbers to show
that the approach has a prayer of working.    You should be able to do this with a few hours
of work, at least to show that the basic concept is sound (or unsound).

{% endraw %}
```

## Thread

+ Return to [September 1998](/archive/1998/09)

+ Return to "[Anonymous <nobody@replay.com>](/authors/anonymous_nobody_at_replay_com_)"
+ Return to "[Eric Cordian <emc@wire.insync.net>](/authors/eric_cordian_emc_at_wire_insync_net_)"

+ 1998-09-15 (Tue, 15 Sep 1998 09:59:32 +0800) - Re: The DES Analytic Crack Project - _Anonymous<EMAIL_ADDRESS>  + 1998-09-15 (Tue, 15 Sep 1998 11:52:19 +0800) - [Re: The DES Analytic Crack Project](/archive/1998/09/4007cd8b445399c9f814efebc89713d6a9bf845e39884937a4f62baff392e775) - _Eric Cordian<EMAIL_ADDRESS>


text:
# gm_pr: A multi project Github pull request viewer

If your project is spread over multiple git repositories, it can be hard to
keep track of all the open pull requests.

The gm_pr project gives you a simple web page where you can see all the open
pull requests with the number of reviews, labels, milestones, etc

![screenshot](screenshot.png)

As a bonus, we also have a slack bot :-)

## Installation

The recommended method to run gm_pr is to use the docker image.

A Dockerfile is available in the "deploy" folder. Building and running the image
can be done in a few lines:

```
cd deploy
docker build -t gm_pr .
docker run -v /path/to/gm_pr:/var/www/gm_pr --name gm_pr -p 8000:80 -d gm_pr
```

Now, you can simply point your browser to http://localhost:8000.

If you want to make gm_pr available on your external interface, configure a
reverse proxy with apache. You can use this snippet:

```
<Proxy http://localhost:8000/>
        Order deny,allow
        Allow from all
</Proxy>

ProxyPass /gm_pr http://localhost:8000
ProxyPassReverse /gm_pr http://localhost:8000

<Location /gm_pr/bot>
        Require all granted
</Location>
```

## Configuration

2 files are used for configuration:

 * gm_pr/settings.py: this is the standard Django configuration file
 * gm_pr/settings_projects.py: contains everything related to your projects

### Django configuration

Refer to the django project if you want to change the configuration.
Normally you should only need to adjust a few settings:

**ALLOWED_HOSTS** You may want to add the name of your server if you use
the docker / apache configuration.

**STATIC_URL** Add the full URL to your static directory

### Gm_pr configuration

Open **gm_pr/settings_projects.py** and read the comments. You'll need to change
most of the configuration here, but the file is self-documenting.

### Slack configuration

You can see your pull requests from Slack.

You need to add a "slash command" in the slack settings:

 * Open https://mydomain.slack.com/services/new/slash-commands
 * Choose a command name, for eg: "/pr"
 * For the URL, append "/bot/" to your gm_pr URL.
 * In order to make things easy with the Django CSRF protection, you have to
 choose the GET method.
 * Copy the token and add it in **settings_project.py** (**SLACK_TOKEN**)
 * click on "Save Integration"

Then you need to add a incoming-webhook to let the bot send messages to Slack:

 * Open https://mydomain.slack.com/services/new/incoming-webhook
 * Choose a channel (the bot will be able to override it, so it doesn't really
 matter what you enter)
 * Copy the webhook URL in **setting_project.py** (**SLACK_URL**)

Now, go to the channel related to your project and type "/pr". After a
few seconds the list of pull requests should appear in your channel.

## Hacking

You need to install django for python3, celery and rabbitmq

Here is the command line for MacOS/homebrew

```
brew doctor
brew update

brew install python3 rabbitmq-server
pip3 install -r requirements/commons.txt
```

On Debian-like system

```
sudo apt-get install python3 celeryd rabbitmq-server
sudo pip3 install -r requirements/commons.txt
```

Create a user and vhost for rabbitmq

```
sudo rabbitmqctl add_user gm_pr gm_pr
sudo rabbitmqctl add_vhost gm_pr
sudo rabbitmqctl set_permissions -p gm_pr gm_pr ".*" ".*" ".*"

```

Run the following commands to start the server:
```
python3 manage.py migrate
python3 manage.py runserver
```

Run the following command in a new terminal:
```
python3 manage.py celeryd
```

Open the web page at http://localhost:8000

# About gm_pr

Gm_pr is an open-source project distributed under the Apache license
version 2

If you like this project, click on the star button on github  :-)

Feel free to send us issues, and of course PRs!!


text:
Generally, almost every UI control could be bound to a data object (all NativeScript controls are created with data binding in mind).
After the code has met the following requirements, data-binding can be used out of the box.

- The target object has to be a successor of the `Bindable` class. **All NativeScript UI controls inherit from `Bindable` class**.
- For one-way binding, using a plain property is sufficient.
- For two-way data binding, the target property should be a dependency property.
- The data object should raise a `propertyChange` event for every change in the value of its property in order to notify all of the listeners interested in the change.

The article will show basic and advanced binding techniques including the architectural pattern used in NativeScript framework - MVVM (Model-View-ViewModel).


text:
# PowerPoint-Sound-Extractor
This application was created because I had a friend who wanted a quick way to combine all of the
audio files in a PowerPoint file.  The issue with using built-in functionality was the fact that it would take 30
minutes to convert  one  PowerPoint (this adds up very quickly if you have 12 from a course that you need to do).
Since underneath the hood a pptx file is a zip file with some XML I could quickly extract the sound files and combine
them using pydub which is much faster than the before mentioned solution.

# Local Environment Setup
**Main Dependencies**
- Python 3.7.5
- Node v10.15.2

The front end of the application was created using create-react-app with the Typescript template
and the backend of the application was created using Python with the Django framework.

In order to get this project up and running please refer to the following steps:
1. Clone to the project repository
2.  From the root directory either create a new virtual python environment (or use your main one) and use the command
`pip install -r requirements.txt` to install all of the python dependencies
3. From the root directory navigate to client and run the command `npm install` followed by `npm build`
4. From the root directory you can use the command `python manage.py runserver` to create an instance of the server
and start exploring

Note: if you wish to run the frontend and backend separately you can take the client out of the django project and
configure the file located in client/src/components/File/File.tsx to utilize the route of the django server when making
the api call
# Usage
I decided to keep the site as a simple to use as possible.  I accomplished this by having the user either
click a button to upload a pptx file or drag and drop it (with some animations too!).  Once the file is uploaded
the user sees it in a table which then gives them an `extract` option to download the combined sound.
![Image of clear-office](app.png)

# Testing
All the unit tests for the project are located in the audio_extractor/lib folder with the file name test_extract.py
In order to run these tests simply locate and run the file with the command.
`python test_extract.py`

# Future Considerations
One of the bigger issues I had with this project was in regards to how I wanted to keep the files
that a user would upload.  My solution was to use temporary files and then delete them when they were done.  The
issue comes in regards deleting the sound files that are created which I decided to do using Heroku scheduler and
running a job for this after a certain amount of time.  I would like to explore and see if there is a
better way to do this with django and heroku.

repository: LoganCorey/PowerPoint-Sound-Extractor

repo_name: LoganCorey/PowerPoint-Sound-Extractor


text:
# MangaDB
Local database including a web front-end for managing mangas/doujinshi.

## WebGUI preview
The previews are taken from a desktop PC, but the site is responsive and can be used just as well on a mobile device!

### Main page
![MangaDB webGUI main page](https://i.imgur.com/1swDFbE.png)

### Book page
![MangaDB book page](https://i.imgur.com/FAlKwTY.png)

See the bottom of the README for links to the arwork (before I butchered some of them).

## Installation
Download the latest release  of your choice [here](https://github.com/nilfoer/mangadb/releases) (the standalone version is recommended for not so tech-savy people). For more advanced users that want to clone this repo: Keep in mind that third-party dependencies as well as the `.css` file that was generated from SASS are **not** checked into git!

### Standalone zip

All dependencies are included and contained in the zip file. Just extract to contents and run the `MangaDB.exe` with:
```
MangaDB.exe -h
```
to show the available commands! Most users will just want to start the webGUI using `MangaDB.exe webgui`.

The webGUI will automatically create an `instance` folder inside the directory of the executable where the database, config and thumb images will be stored.

### Source zip including third-party dependencies

All third-party dependencies that can't be aquired over `pip` are included in the zip archive. For the ones that can be, use:
```
python -m pip install -r requirements.txt
```

Installing MangaDB to your site-packages is not recommended but if you want to, you can:
```
python -m pip install .
```
When starting MangaDB you should then specify a custom path using `manga_db -p /your/path` otherwise Flask, which is used by MangaDB for the webGUI will store your user data in `$PREFIX/var/manga_db.webGUI-instance`, where `$PREFIX` is the prefix of your Python installation. For more information have a look at [Flask's documentation](https://flask.palletsprojects.com/en/1.0.x/config/#instance-folders).

## Usage

If you are not using the default `instance` directory in the same path where the executable or `run_manga_db.py` are stored (the *instance* folder is where the database file and the thumbs are located) you  need to pass it to MangaDB using `-p /your/path`. (See above for where the webGUI stores user files in the case it's installed as a python package)

For using the WebGUI run the script like so (replace `MangaDB.exe` with `run_manga_db.py` if you are using the source zip version):
```
MangaDB.exe webgui
```

Then you can access the WebGUI by going to `localhost:7578` (7578 is the default port) in your web browser. The first time you access the WebGUI you have to create a user by clicking on **Register**. Then just type in the username and password combination you chose and press **Login**.

To be able to access the site with e.g. your phone in your LAN use `MangaDB.exe webgui --open` and then browse to http://INSERT.YOUR.IP.HERE:7578/

### Adding books
You can either import books from supported sites by pasting their URL into the search field and selecting **Import Book** and submitting or press the **Add book** button inside the toolbox in the top right to add a book manually.

#### Adding external links

Paste the URL of a site that provides additional information for the book or just hosts the
images into the input box at the bottom of the Book page. If the site is supported
informations will be extracted from it, otherwise you can add the information manually
(To add a information without a link just hit the 'Add Info' button with an empty box).

#### Error: 503 - Service unavailable
Importing a book from sites that use DDoS protection by services like Cloudflare might fail
due to our script getting recognized as a bot.

In order to circumvent that you have to manually visit the page, upon which either your browser has to pass
a JavaScript challenge or you have to solve a Captcha. After that your browser will be recognized as
a "real human". On subsequent requests you will be automatically recognized using cookies. These can be exported for use with MangaDB, so that we are able to import books from sites like these.

The most convenient way is to use the
[NoRobot Extension](https://addons.mozilla.org/de/firefox/addon/norobot-exporter/)
that automatically gathers all the required information. Save that to a `cookies.txt` in your `instance`
folder where your DB file etc. are located. This is the path the **webGUI** uses, but you can pass arbitrary
paths to the **CLI** using `MangaDB.exe --cookies "path\to\cookies.txt"` (e.g. when you're using the
`link_collector`).

Loading or updating the cookies from the cookie file on the webGUI is done by pressing the **Refresh cookies**
button in the toolbox.

### Searching
The search bar matches the input string against the book's english and foreign title by default (so it if there's a string without a preceeding keyword the title is searched).

Additionally you can search the following fields:

| Field           | Search keyword | Possible values               |
|:--------------- |:-------------- | -----------------------------:|
| Tags            | tag            |                    Any string |
| Artist          | artist         |                    Any string |
| Language        | language       |                    Any string |
| Group           | groups         |                    Any string |
| List            | list           |                    Any string |
| Collection      | collection     |                    Any string |
| Category        | category       |                    Any string |
| Status          | status         |   Unknown, Completed, Ongoing |
|                 |                | Unreleased, Hiatus, Cancelled |
| Parody          | parody         |                    Any string |
| Character       | character      |                    Any string |
| Favorite        | favorite       |                        0 or 1 |
| Content Rating  | nsfw           |                        0 or 1 |
| Download status | downloaded     |                        0 or 1 |
| Read status     | read\_status   |         read, reading, unread |
| (Title)         | title          |     Any string, partial match |

All of these fields can be combined in one search. When the search string for a specific keyword contains spaces, it needs to be escaped with quotes. To search for multiple items that have to be present, separate them with semicolons.

E.g. this string searches for a book that has the tags Seinen and "Martial Arts" and is in the list "good":
```
list:good tag:"seINen;MaRTial ARTS"
```
_Hint: search is **case-insensitive** since v0.25.0_

Search for sfw favorites in the 'Manga' category:
```
category:Manga favorite:1 nsfw:0
```

Display 'Seinen' mangas you're currently reading:
```
read_status:reading tag:Seinen
```
*Note: read\_status currently doesn't respect 'Chapter status'. So in order to mark a book as __'reading'__
you have to set the 'Read status' to a __non-zero value__. To mark a book as __'read'__ set 'Read status'
to __zero__.*

#### Location of DB and thumbnails
To backup your installation of MangaDB you only need to copy the instance folder in the directory where either the `MangaDB.exe` or the `run_manga_db.py` is located. The 'instance' directory is where your login info, all thumbnails and the database file is saved.

### Importing a lot of different mangas/doujinshi
Use:
```
MangaDB.exe link_collector
```
(When used with source zip version you need to specify the path to your `instance` folder, where the database file and the thumbs directory are located: e.g. `run_manga_db.py -p ./instace`)

To add a single link use the command
```
add URL [list [list]...]
```
if downloaded is among the lists, the downloaded option will be set on the external link.

The best way of adding a lot of books is using the command `collect` which will watch the clipboard for supported URLs and add them to the import list. If you want to add all of the added books to certain lists, use `set_standard_lists [lists [list]...]`, these will be added to all following books from that point on.

To change lists on added links use:
```
set_lists(sl) URL/r(ecent) [list [list]...]
```
`r` or `recent` as first argument sets the lists on the most recent book (works on most commands).

Set book as not downloaded:
```
not_downloaded(ndl) URL/r(ecent)
```
Remove book:
```
remove URL/r(ecent)
```
`export` writes current state of added links to `link_collect_resume.json`, which can be used to resume at this state when starting the script with `run_manga_db.py link_collector --resume`

Use `p(rint)` with no argmuent to print the most recent book, `p URL` to print the book with that URL or `p all` to print all books.

When your're finished use `import` to start importing books.

## Sources

Cover art main page (top to bottom, left to right) all from [Pixabay](https://pixabay.com/):

- [Image](https://pixabay.com/illustrations/cartoon-painting-fantasy-creativity-5265167/)
  by [愚木混株 Cdd20](https://pixabay.com/users/cdd20-1193381/)
- [Image](https://pixabay.com/illustrations/people-girl-woman-face-portrait-2013447/)
  by [Alexandra Haynak](https://pixabay.com/users/tsukiko-kiyomidzu-1850874/)
- [Image](https://pixabay.com/illustrations/moe-cute-anime-3734213/)
  by [Akane-K](https://pixabay.com/users/akane-k-8075952/)
- [Image](https://pixabay.com/illustrations/illumination-imagination-creativity-5173540/)
  by [愚木混株 Cdd20](https://pixabay.com/users/cdd20-1193381/)
- [Image](https://pixabay.com/illustrations/fantasy-night-ladder-universe-4063619/)
  by [愚木混株 Cdd20](https://pixabay.com/users/cdd20-1193381/)
- [Image](https://pixabay.com/illustrations/dinosaur-katana-japan-ninja-5178645/)
  by [Akiko Nagamatsu](https://pixabay.com/users/akikionagamatsu-16400508/)
- [Image](https://pixabay.com/illustrations/couple-students-anime-love-5711220/)
  by [Châu Nguyễn](https://pixabay.com/users/kittypinkart-4024560/)
- [Image](https://pixabay.com/illustrations/cartoon-drawing-manga-comic-5190962/)
  by [愚木混株 Cdd20](https://pixabay.com/users/cdd20-1193381/)
- [Image](https://pixabay.com/illustrations/reading-girl-leisure-woman-5173530/)
  by [愚木混株 Cdd20](https://pixabay.com/users/cdd20-1193381/)
- [Image](https://pixabay.com/illustrations/moe-boy-healthy-anime-vtuber-3669744/)
  by [Akane-K](https://pixabay.com/users/akane-k-8075952/)
- [Image](https://pixabay.com/illustrations/turn-pen-manga-anime-digital-design-976930/)
  by [Willian Yuki Fujii Memmo](https://pixabay.com/users/willianfujii-1276991/)
- [Image](https://pixabay.com/illustrations/cartoon-painting-fantasy-5123446/)
  by [愚木混株 Cdd20](https://pixabay.com/users/cdd20-1193381/)
- [Image](https://pixabay.com/illustrations/cartoon-drawing-manga-comic-5190955/)
  by [愚木混株 Cdd20](https://pixabay.com/users/cdd20-1193381/)
- [Image](https://pixabay.com/illustrations/illustration-women-beauty-fantasy-4424064/)
  by [Diana aka Loony\_Rabbit](https://pixabay.com/users/loony_rabbit-9685066/)
- [Image](https://pixabay.com/illustrations/fantasy-lighting-man-one-man-show-4065924/)
  by [愚木混株 Cdd20](https://pixabay.com/users/cdd20-1193381/)
- [Image](https://pixabay.com/illustrations/hand-girl-light-surreal-cartoon-5879027/)
  by [愚木混株 Cdd20](https://pixabay.com/users/cdd20-1193381/)
- [Image](https://pixabay.com/illustrations/moe-rice-eat-burger-breakfast-3336882/)
  by [Akane-K](https://pixabay.com/users/akane-k-8075952/)
- [Image](https://pixabay.com/illustrations/man-underwater-chopsticks-food-5879120/)
  by [愚木混株 Cdd20](https://pixabay.com/users/cdd20-1193381/)

Cover art book page:

- [Image](https://pixabay.com/illustrations/dinosaur-katana-japan-ninja-5178645/)
  by [Akiko Nagamatsu](https://pixabay.com/users/akikionagamatsu-16400508/) from [Pixabay](https://pixabay.com/)

repository: ubiqare/mangadb

repo_name: ubiqare/mangadb


text:
# Rotate capture files

To rotate capture files, "`-C file_size`" (the unit is `MB`, i.e., `1,000,000` Bytes) option can be used to set the size of rotation file:

	# tcpdump -w enp0s3.pcap -C 1

Otherwise the files can be rotated based on time (seconds) through "`-G seconds`" option:

	# tcpdump -w enp0s3_%F_%T.pcap -G 3
	tcpdump: listening on enp0s3, link-type EN10MB (Ethernet), capture size 262144 bytes
	^C10 packets captured
	12 packets received by filter
	0 packets dropped by kernel
	# ls -lt *.pcap
	-rw-r--r-- 1 root root 100 Jun  6 09:13 enp0s3_2019-06-06_09:13:28.pcap
	-rw-r--r-- 1 root root 176 Jun  6 09:13 enp0s3_2019-06-06_09:13:24.pcap
	-rw-r--r-- 1 root root 746 Jun  6 09:13 enp0s3_2019-06-06_09:13:21.pcap

For time format, this [page](http://www.cplusplus.com/reference/ctime/strftime/) gives a reference.

If some operations need to be done with saved files, "`-z postrotate-command`" option can be used. E.g., compress the rotated file:

	# tcpdump -w enp0s3_%F_%T.pcap -G 3 -z gzip
	tcpdump: listening on enp0s3, link-type EN10MB (Ethernet), capture size 262144 bytes
	^C22 packets captured
	24 packets received by filter
	0 packets dropped by kernel
	# ls *.gz
	enp0s3_2019-06-21_13:37:29.pcap.gz  enp0s3_2019-06-21_13:37:37.pcap.gz  enp0s3_2019-06-21_13:37:43.pcap.gz
	enp0s3_2019-06-21_13:37:34.pcap.gz  enp0s3_2019-06-21_13:37:40.pcap.gz

BTW, there is another "`-W filecount`" option which can be used in conjunction with "`-C`" or "`-G`" option to limit the number of files.