text:
# Setup an Otoroshi cluster

In this tutorial, you create an cluster of Otoroshi.

### Summary

1. Deploy an Otoroshi cluster with one leader and 2 workers
2.  Validate the installation by adding a header on the requests

Let's start by downloading the latest jar of Otoroshi.

```sh
curl -L -o otoroshi.jar 'https://github.com/MAIF/otoroshi/releases/download/v16.8.0-dev/otoroshi.jar'
```

Then create an instance of Otoroshi and indicates with the `otoroshi.cluster.mode` environment variable that it will be the leader.

```sh
java -Dhttp.port=8091 -Dhttps.port=9091 -Dotoroshi.cluster.mode=leader -jar otoroshi.jar
```

Let's create two Otoroshi workers, exposed on `:8082/:8092` and `:8083/:8093` ports, and setting the leader URL in the `otoroshi.cluster.leader.urls` environment variable.

 The cluster is now configured, you can see the 3 instances and some health informations on each instance.

To complete our installation, we want to spread the incoming requests accross otoroshi worker instances.

In this tutorial, we will use `haproxy` has a TCP loadbalancer. If you don't have haproxy installed, you can use docker to run an haproxy instance as explained below.

But first, we need an haproxy configuration file named `haproxy.cfg` with the following content :

```sh
frontend front_nodes_http
    bind *:8080
    mode tcp
    default_backend back_http_nodes
    timeout client          1m

backend back_http_nodes
    mode tcp
    balance roundrobin
    server node1 host.docker.internal:8092 # (1)
    server node2 host.docker.internal:8093 # (1)
    timeout connect        10s
    timeout server          1m
```

and run haproxy with this config file

no docker
:   @@snip [run.sh](../snippets/cluster-run-ha.sh) { #no_docker }

docker (on linux)
:   @@snip [run.sh](../snippets/cluster-run-ha.sh) { #docker_linux }

docker (on macos)
:   @@snip [run.sh](../snippets/cluster-run-ha.sh) { #docker_mac }

docker (on windows)
:   @@snip [run.sh](../snippets/cluster-run-ha.sh) { #docker_windows }

The last step is to create a route, add a rule to add, in the headers, a specific value to identify the worker used.

Create this route, exposed on `http://api.oto.tools:xxxx`, which will forward all requests to the mirror `https://mirror.otoroshi.io`.

```sh
curl -X POST 'http://otoroshi-api.oto.tools:8091/api/routes' \
-H "Content-type: application/json" \
-u admin-api-apikey-id:admin-api-apikey-secret \
-d @- <<'EOF'
{
  "name": "myapi",
  "frontend": {
    "domains": ["api.oto.tools"]
  },
  "backend": {
    "targets": [
      {
        "hostname": "mirror.otoroshi.io",
        "port": 443,
        "tls": true
      }
    ]
  },
  "plugins": [
    {
        "enabled": true,
        "plugin": "cp:otoroshi.next.plugins.AdditionalHeadersIn",
        "config": {
            "headers": {
                "worker-name": "${config.otoroshi.cluster.worker.name}"
            }
        }
    }
  ]
}
EOF
```

Once created, call two times the service. If all is working, the header received by the backend service will have `worker-1` and `worker-2` as value.

```sh
curl 'http://api.oto.tools:8080'
## Response headers
{
    ...
    "worker-name": "worker-2"
    ...
}
```

This should output `worker-1`, then `worker-2`, etc. Well done, your loadbalancing is working and your cluster is set up correctly.

repository: MAIF/otoroshi

gha_language: Scala

repo_name: MAIF/otoroshi


text:
Version Controller
==================
Abstract Object Version Controller

The purpose of this project is to have a version history of an abstract object.

1. [Project principle](https://github.com/mapado/VersionControlBundle/blob/master/src/Mapado/VersionControlBundle/Resources/doc/1-principle.md)
2.

### Add the classes to your Kernel
```php
new Mapado\VersionControlBundle\MapadoVersionControlBundle(),
```

## Webservice Configuration
Add this to your routing.yml :
```
mapado_version_control:
    resource: "@MapadoVersionControlBundle/Controller/"
    type:     annotation
    prefix:   /version_control/
```

license: MIT

repository: mapado/VersionControlBundle

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: mapado/VersionControlBundle


text:
## Synopsis

`\unset var_name [var_name ...]`

## Description

Unsets one or more jsqsh variables. Note that any variable that appears in
`\help vars` is a special configuration variable and may not be unset with
this command.

Removing a session-local variable (created with `\set -x`), will re-expose
any global variable of the same name. Two calls to [[\set|set]] would need to be
invoked to completely remove the variable in this case.

## Options
  None.

## See also

[[\set|set]]

repository: scgray/jsqsh

gha_language: Java

repo_name: scgray/jsqsh


text:
## glab pipeline status

View a running pipeline on current or other branch specified

### Synopsis

View a running pipeline on current or other branch specified

```
glab pipeline status [flags]
```

### Examples

```
$ glab pipeline status --live
$ glab pipeline status --branch=master   // Get pipeline for master branch
$ glab pipe status   // Get pipeline for current branch

```

### Options

```
  -b, --branch string   Check pipeline status for a branch. (Default is current branch)
  -h, --help            help for status
  -l, --live            Show status in realtime till pipeline ends
```

### Options inherited from parent commands

```
  -R, --repo string   Select another repository using the OWNER/REPO format or the project ID. Supports group namespaces
```

### SEE ALSO

* [glab pipeline](glab_pipeline.md)	 - Manage pipelines

###### Auto generated by spf13/cobra on 18-Aug-2020

repository: princeselasi/glab

branch_name: refs/heads/trunk

gha_language: Go

gha_license_id: MIT

repo_name: princeselasi/glab


text:
# iBeacon Demo

iBeacon demo in Swift

# How to use

## Prepare
1. Two real iDevice or more.
2. An Apple develop account (Joined iOS Developer Program).

## As Broadcaster
Launch this app in device,

after launched, You get this screen.

![Broadcast Off](https://raw.github.com/Darktt/iBeacon-Demo/master/Images/Broadcast_Off.png)

Press "Start Broadcast" to start broadcast the iBeacon singal.

![Broadcast On](https://raw.github.com/Darktt/iBeacon-Demo/master/Images/Broadcast_On.png)

## As Receiver
Launch this app in device and switch second tab on bottom.

Auto start receiving iBeacon singal.

![Receiving iBeacon](https://raw.github.com/Darktt/iBeacon-Demo/master/Images/Receiving.png)

When detected iBeacon singal, you can get iBeacon data like this,

![Received iBeacon](https://raw.github.com/Darktt/iBeacon-Demo/master/Images/Received.png)

#### In Locked Screen

iOS system auto detect iBeacon singal, when inside singal range,

![iBeacon Detect](https://raw.github.com/Darktt/iBeacon-Demo/master/Images/iBeacon_Detect.png)

swipe up to launch this app, like Handoff continuity.

## Support Devices
* iPhone 4s or laster.
* iPod touch (5th generation) or later.
* iPad mini or later.
* iPad (3rd generation) or later.

repository: iBolom/iBeacon-Demo

repo_name: iBolom/iBeacon-Demo


text:
The SoftwareSerial library has been developed to allow serial communication on other digital pins of CT-ARM, using software to replicate the functionality of native hardware Serial (hence the name "SoftwareSerial"). In CT-ARM, all I/O pins can be used for SoftwareSerial.

However, there is a few limitations:

 - If using multiple software serial ports, only one can receive data at a time.
 - Higher the baud rate, the less stable the data reception on RX pins. 9600 baud or below is the most stable baud rate tested for data transmission. For higher baud rate needed in applications, [Serial](/libraries/Serial) would be recommended.

## SoftwareSerial()

**Description**

SoftwareSerial is used to create an instance of a SoftwareSerial object, whose name you need to provide as in the example below. The inverse_logic argument is optional and defaults to false. See below for more details about what it does. Multiple SoftwareSerial objects may be created, however only one can be active at a given moment.

You need to call [begin()](#begin) to enable communication.

**Syntax**

`SoftwareSerial mySerial(rxPin, txPin)`

**Parameters**

 - rxPin: the pin on which to receive serial data

 - txPin: the pin on which to transmit serial data

 - inverse_logic: is used to invert the sense of incoming bits (the default is normal logic). If set, SoftwareSerial treats a LOW (0 volts on the pin, normally) on the Rx pin as a 1-bit (the idle state) and a HIGH (5 volts on the pin, normally) as a 0-bit. It also affects the way that it writes to the Tx pin. Default value is false.

**Example**

```c++
#include <SoftwareSerial.h>

const byte rxPin = 2;
const byte txPin = 3;

// set up a new serial object
SoftwareSerial mySerial (rxPin, txPin);
```

## available()

**Description**

Get the number of bytes (characters) available for reading from a software serial port. This is data that's already arrived and stored in the serial receive buffer.

**Syntax**

`mySerial.available()`

**Parameters**

None

**Return**

the number of bytes available to read

**Example**
```c++
// include the SoftwareSerial library so you can use its functions:
#include <SoftwareSerial.h>

#define rxPin 10
#define txPin 11

// set up a new serial port
SoftwareSerial mySerial =  SoftwareSerial(rxPin, txPin);

void setup()  {
  // define pin modes for tx, rx:
  pinMode(rxPin, INPUT);
  pinMode(txPin, OUTPUT);
  // set the data rate for the SoftwareSerial port
  mySerial.begin(9600);
}

void loop() {
  if (mySerial.available()>0){
    mySerial.read();
  }
}
```

## begin()

**Description**

Sets the speed (baud rate) for the serial communication. Supported baud rates are 1200, 2400, 4800, 9600, 19200, 38400, 57600, and 115200.

**Syntax**

`mySerial.begin(speed)`

**Parameters**

 - speed: the baud rate (long)

**Return**

None

**Example**
```c++
// include the SoftwareSerial library so you can use its functions:
#include <SoftwareSerial.h>

#define rxPin 10
#define txPin 11

// set up a new serial port
SoftwareSerial mySerial =  SoftwareSerial(rxPin, txPin);

void setup()  {
  // define pin modes for tx, rx:
  pinMode(rxPin, INPUT);
  pinMode(txPin, OUTPUT);
  // set the data rate for the SoftwareSerial port
  mySerial.begin(9600);
}

void loop() {
  // ...
}
```

## isListening()

**Description**

Tests to see if requested software serial port is actively listening.

**Syntax**

`mySerial.isListening()`

**Parameters**

None

**Return**

boolean

**Example**
```c++
#include <SoftwareSerial.h>

// software serial : TX = digital pin 10, RX = digital pin 11
SoftwareSerial portOne(10,11);

void setup()
{
  // Start the hardware serial port
  Serial.begin(9600);

  // Start software serial port
  portOne.begin(9600);
}

void loop()
{
  if (portOne.isListening()) {
   Serial.println("Port One is listening!");
}
```

## overflow()

**Description**

Tests to see if a software serial buffer overflow has occurred. Calling this function clears the overflow flag, meaning that subsequent calls will return false unless another byte of data has been received and discarded in the meantime.

The software serial buffer can hold 64 bytes.

**Syntax**

`mySerial.overflow()`

**Parameters**

None

**Return**

boolean

**Example**
```c++
#include <SoftwareSerial.h>

// software serial : TX = digital pin 10, RX = digital pin 11
SoftwareSerial portOne(10,11);

void setup()
{
  // Start the hardware serial port
  Serial.begin(9600);

  // Start software serial port
  portOne.begin(9600);
}

void loop()
{
  if (portOne.overflow()) {
   Serial.println("SoftwareSerial overflow!");
}
```

## peek()

**Description**

Return a character that was received on the RX pin of the software serial port. Unlike read(), however, subsequent calls to this function will return the same character.

Note that only one SoftwareSerial instance can receive incoming data at a time (select which one with the [listen()](#listen) function).

**Syntax**

`mySerial.peek()`

**Parameters**

None

**Return**

the character read, or -1 if none is available

**Example**
```c++
SoftwareSerial mySerial(10,11);

void setup()
{
  mySerial.begin(9600);
}

void loop()
{
  char c = mySerial.peek();
}
```

## read()

**Description**

Return a character that was received on the RX pin of the software serial port. Note that only one SoftwareSerial instance can receive incoming data at a time (select which one with the [listen()](#listen) function).

**Syntax**

`mySerial.read()`

**Parameters**

None

**Return**

the character read, or -1 if none is available

**Example**
```c++
SoftwareSerial mySerial(10,11);

void setup()
{
  mySerial.begin(9600);
}

void loop()
{
  char c = mySerial.read();
}
```

## print()

**Description**

Prints data to the transmit pin of the software serial port. Works the same as the [Serial.print()](/libraries/Serial/#print) function.

**Syntax**

`mySerial.print()`

**Parameters**

vary, see [Serial.print()](/libraries/Serial/#print) for details

**Return**

byte

> [print()](#print) will return the number of bytes written, though reading that number is optional

**Example**
```c++
SoftwareSerial serial(10,11);
int analogValue;

void setup()
{
  serial.begin(9600);
}

void loop()
{
  // read the analog input on pin 0:
  analogValue = analogRead(A0);

  // print it out in many formats:
  serial.print(analogValue);         // print as an ASCII-encoded decimal
  serial.print("\t");                // print a tab character
  serial.print(analogValue, DEC);    // print as an ASCII-encoded decimal
  serial.print("\t");                // print a tab character
  serial.print(analogValue, HEX);    // print as an ASCII-encoded hexadecimal
  serial.print("\t");                // print a tab character
  serial.print(analogValue, OCT);    // print as an ASCII-encoded octal
  serial.print("\t");                // print a tab character
  serial.print(analogValue, BIN);    // print as an ASCII-encoded binary
  serial.print("\t");                // print a tab character
  serial.print(analogValue/4, BYTE); // print as a raw byte value (divide the
                                     // value by 4 because analogRead() returns numbers
                                     // from 0 to 1023, but a byte can only hold values
                                     // up to 255)
  serial.print("\t");                // print a tab character
  serial.println();                  // print a linefeed character

  // delay 10 milliseconds before the next reading:
  delay(10);
}
```

## println()

**Description**

Prints data to the transmit pin of the software serial port, followed by a carriage return and line feed. Works the same as the [Serial.println()](/libraries/Serial/#println) function.

**Syntax**

`mySerial.println()`

**Parameters**

vary, see [Serial.println()](/libraries/Serial/#println) for details

**Return**

byte

> [println()](#println) will return the number of bytes written, though reading that number is optional

**Example**
```c++
SoftwareSerial serial(10,11);
int analogValue;

void setup()
{
  serial.begin(9600);
}

void loop()
{
  // read the analog input on pin 0:
  analogValue = analogRead(A0);

  // print it out in many formats:
  serial.print(analogValue);         // print as an ASCII-encoded decimal
  serial.print("\t");                // print a tab character
  serial.print(analogValue, DEC);    // print as an ASCII-encoded decimal
  serial.print("\t");                // print a tab character
  serial.print(analogValue, HEX);    // print as an ASCII-encoded hexadecimal
  serial.print("\t");                // print a tab character
  serial.print(analogValue, OCT);    // print as an ASCII-encoded octal
  serial.print("\t");                // print a tab character
  serial.print(analogValue, BIN);    // print as an ASCII-encoded binary
  serial.print("\t");                // print a tab character
  serial.print(analogValue/4, BYTE); // print as a raw byte value (divide the
                                     // value by 4 because analogRead() returns numbers
                                     // from 0 to 1023, but a byte can only hold values
                                     // up to 255)
  serial.print("\t");                // print a tab character
  serial.println();                  // print a linefeed character

  // delay 10 milliseconds before the next reading:
  delay(10);
}
```

## listen()

**Description**

Enables the selected software serial port to listen. Only one software serial port can listen at a time; data that arrives for other ports will be discarded. Any data already received is discarded during the call to listen() (unless the given instance is already listening).

**Syntax**

`mySerial.listen()`

**Parameters**

`mySerial:the name of the instance to listen`

**Return**

None

**Example**

```c++
#include <SoftwareSerial.h>

// software serial : TX = digital pin 10, RX = digital pin 11
SoftwareSerial portOne(10, 11);

// software serial : TX = digital pin 8, RX = digital pin 9
SoftwareSerial portTwo(8, 9);

void setup()
{
  // Start the hardware serial port
  Serial.begin(9600);

  // Start both software serial ports
  portOne.begin(9600);
  portTwo.begin(9600);

}

void loop()
{
  portOne.listen();

  if (portOne.isListening()) {
   Serial.println("Port One is listening!");
}else{
   Serial.println("Port One is not listening!");
}

  if (portTwo.isListening()) {
   Serial.println("Port Two is listening!");
}else{
   Serial.println("Port Two is not listening!");
}

}
```

## write()

**Description**

Prints data to the transmit pin of the software serial port as raw bytes. Works the same as the [Serial.write()](/libraries/Serial/#write) function.

**Syntax**

`mySerial.write(data)`

**Parameters**

 - data: refer to [Serial.write()](/libraries/Serial/#write) for details

**Return**

byte

> [write()](#write) will return the number of bytes written, though reading that number is optional

**Example**
```c++
SoftwareSerial mySerial(10, 11);

void setup()
{
  mySerial.begin(9600);
}

void loop()
{
  // send a byte with the value 45
  mySerial.write(45);

  //send the string “hello” and return the length of the string.
  int bytesSent = mySerial.write(“hello”);
}
```

repository: Circuit-killer/CT-ARM

repo_name: Circuit-killer/CT-ARM


text:
# APN-P8

If you were looking for solution to send a Push Notifications using Auth Key (P8), this repository may interest you.

> Special thanks to @ethanhuang13 and his https://github.com/ethanhuang13/CupertinoJWT which is heavily used in this project. Thanks!

## Installation

Just download `P8.playground` file and open it in Xcode.

## Usage

Change the following data in playground and run it.

```swift
PAYLOAD         // content of push notification
DEVICE_TOKEN    // device token to which the notification should be sent
KEY_ID          // get it from your developer account
TEAM_ID         // get it from your developer account
BUNDLE_ID       // your app bundle id
P8              // generated private key
```

## License

The project is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).


text:
Update
======

#### [user-agent][ua] source code

`vendor` has been added as a git [subtree][subtree] and it can be updated like this:
```
git subtree pull --prefix=client-vendor/source/user-agent/vendor https://github.com/3rd-Eden/useragent.git <branch|tag> --squash
```

#### Regular Expressions

[user-agent][ua] is using a collection of regular expressions to parse the User Agent, defined in the [ua-parser][ua-parser] repository.

Steps to update the collection:

1. go in `vendor` folder
2. `npm install`
3. `./bin/update.js`

  [ua]: https://github.com/3rd-Eden/useragent
  [ua-parser]: https://github.com/ua-parser/uap-core
  [subtree]: https://developer.atlassian.com/blog/2015/05/the-power-of-git-subtree/

Usage
=====

```js
navigator.userAgent
> "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/49.0.2623.87 Safari/537.36"
UserAgentParser.parse(navigator.userAgent)
> {
  	"family": "Chrome",
  	"major": "49",
  	"minor": "0",
  	"patch": "2623",
  	"device": {
  		"family": "Other"
  	},
  	"os": {
  		"family": "Mac OS X",
  		"major": "10",
  		"minor": "10",
  		"patch": "5"
  	}
  }
```

repository: sebastien-fauvel/CM

repo_name: sebastien-fauvel/CM


text:
[
->Back to directory
](0.directory.md)

Considering the cost of the connection from the very beginning of the design, the easiest way.
## TCP
* Any client that supports TCP can link to the server.
* Note that TCP connections are not open for password security, so you should decide whether to block the TCP port of the server or disable the TCP service directly in the configuration file.

Simple debugging can use tools such as telnet, or you can write your own client program. For the specific communication interaction protocol, please refer to the chapter "Protocol" and "Command" in the document.

## HTTP
* Any client that supports HTTP can connect to the server.
* The way HTTP connections are in the main direction of owlcache is also recommended for this connection.

Simple debugging can use browsers, CURL and other tools, or you can write your own HTTP client program. For the specific communication interaction protocol, please refer to the chapter "Communication Protocol" and "Operation Command" in the document.

repository: beckbikang/owlcache

repo_name: beckbikang/owlcache


text:
# Questions on Github issues

Hi, github issues are reserved for bugs and/or features
discussions. Please email your questions to the mailing list or hit us
up on the irc channel. You can find more info on the
[community page](http://influxdb.com/community/)

repository: georgeoftown/facette

repo_name: georgeoftown/facette


text:
## Flexible plots

By default, XYPlot requires a width and a height. There are times, however, when you'd like your chart to take all the space it can.
For these cases, React-vis provides three different types of `XYPlot` with different flexible dimensions:

  - FlexibleWidthXYPlot
  - FlexibleHeightXYPlot
  - FlexibleXYPlot

and the associated helper functions that have been used to create these flexible components.

<!-- INJECT:"FlexibleChartsWithLink" -->

```jsx
import {
  FlexibleXYPlot,
  FlexibleWidthXYPlot,
  FlexibleHeightXYPlot
} from 'react-vis';
```

`FlexibleWidthXYPlot` modifies `XYPlot` so that it no longer requires a width, since it will take all the with in its container div.
Likewise, `FlexibleHeightXYPlot` modifies `XYPlot` so that is no longer requires a height, and its height will be that of its container div.
Finally, `FlexibleXYPlot` modifies `XYPlot` so that it no longer requires either a width and a height, its dimensions will be that of its container.

These components can be used exactly as `XYPlot`:

```jsx
<FlexibleWidthXYPlot height={100}>
  <VerticalBarSeries data={data} />
</FlexibleWidthXYPlot>

<FlexibleHeightXYPlot width={100}>
  <VerticalBarSeries data={data} />
</FlexibleHeightXYPlot>

<FlexibleXYPlot>
  <VerticalBarSeries data={data} />
</FlexibleXYPlot>
```

### No worries about resizing

A flexible plot is useful when you don't know for sure the size of the container where the chart will go.
On top of that, flexible plots resize themselves when the window size changes. You can try that by changing the size of this window.

### Size of parent container is not the same as "all the available space"

Flexible plots will inherit dimensions from their container. This is not the same thing as taking all the available space; if there are other elements in that container, a flexible plot won't deduce their dimensions from its own.
For best results, a flexible plot should be the only child of its container.

### Responsive visualizations

We can go one step beyond and not simply adjust the dimensions of the chart of the available space, but change how a dataset is being represented.
See the example [responsive visualizations](#/examples/charts/responsive-vis)

### Custom flexible components

By using the provided flexible helpers, you can use them to make your own components flexible, like we did to create `XYPlot` flexible alternatives:

```jsx
import {
  XYPlot,
  makeVisFlexible,
  makeWidthFlexible,
  makeHeightFlexible,
} from 'react-vis';

const FlexibleXYPlot = makeVisFlexible(XYPlot);
const FlexibleWidthXYPlot = makeWidthFlexible(XYPlot);
const FlexibleHeightXYPlot = makeHeightFlexible(XYPlot);
```

repository: Wattenberger/react-vis

repo_name: Wattenberger/react-vis


text:
# Metaheuristic Minimization Using Particle Swarm Optimization

## Reference

- Maurice Clerc, 2012, "[Standard Particle Swarm Optimisation](https://hal.archives-ouvertes.fr/hal-00764996/document)", hal-00764996.
- Maurice Clerc, 2006, "[Particle Swarm Optimisation](https://onlinelibrary.wiley.com/doi/book/10.1002/9780470612163)", ISTE Ltd.
- Martin Roberts, 2020, ["How to generate uniformly random points on n-spheres and in n-balls"](http://extremelearning.com.au/how-to-generate-uniformly-random-points-on-n-spheres-and-n-balls/), Extreme Learning.

## Characteristics

- The code has been written and tested in Python 3.7.7.
- Particle Swarm Optimization (PSO) implementation for metaheuristic minimization.
- Variables can be real, integer, or mixed real/integer.
- Variables can be constrained to a specific interval or value setting the lower and the upper boundaries.
- Confidence coefficients depend on one single parameter.
- Search space can be normalized to improve convergency.
- An adaptive random topology is used to define each agent's neighbourhood (with an option to use the full swarm as neighbourhood).
- Unbiased velocity equation using hyperspherical uniform distribution (including the corner case where an agent is the neighbourhood best).
- Three velocity confinement methods (hyperbolic, random-back, and mixed hyperbolic/random-back).
- Possibility to specify the velocity limits.
- Possibility to specify an initial position for the agents.
- To improve the execution speed the algorithm has been designed without any loop on the agents.
- An arbitrary number of parameters can be passed (in a tuple) to the function to minimize.
- Option to run sequential tests with constant or random (uniformly distributed) number of agents.
- Usage: *python test.py example*.

## Parameters

`example` Name of the example to run (Parabola, Alpine, Tripod, and Ackley.)

`func` Function to minimize. The position of all agents is passed to the function at the same time.

`LB`, `UB` Lower and upper boundaries of the search space.

`nPop`, `epochs` Number of agents (population) and number of iterations.

`K` Average size of each agent's group of informants. If `K=0` the entire swarm is used as agent's group of informants.

`phi` Coefficient to calculate the self-confidence coefficient and the confidence-in-others coefficient.

`vel_fact` Velocity factor to calculate the maximum and the minimum allowed velocities.

`conf_type` Confinement type (on the velocities): `HY=` hyperbolic, `RB=` random-back, `MX=` mixed hyeperbolic/random-back.

`IntVar` List of indexes specifying which variable should be treated as integer. If all variables are real set `IntVar=None`, if all variables are integer set `IntVar=all`. Indexes are in the range `(1,nVar)`.

`normalize` Specifies if the search space should be normalized (to improve convergency).

`rad` Normalized radius of the hypersphere centered on the best particle. The higher the number of other particles inside and the better is the solution.

`args` Tuple containing any parameter that needs to be passed to the function to minimize. If no parameters are passed set `args=None`.

`Xinit` Initial position of each agent.

`nVar` Number of variables (dimensions of the search space).

`nRun` Number of runs for a specific case.

`random_pop` Specifies if the number of agents (for each run) is kept constant at `nPop` or randomly choosen from the uniform distribution `nVar/2 <= nPop <= nVar/2`.

`Xsol` Solution to the minimization point. Set to `None` if not known.

## Examples

There are four examples: Parabola, Alpine, Tripod, and Ackley (see *test.py* for the specific equations and parameters). As illustration, a 3D plot of these function is shown [here](examples.bmp).

- **Parabola**, **Alpine**, and **Ackley** can have an arbitrary number of dimensions, while **Tripod** has only two dimensions.

- **Parabola**, **Tripod**, and **Ackley** are examples where parameters (respectively, array `X0`, scalars `kx` and `ky`, and array `X0`) are passed using `args`.

- The global minimum for **Parabola** and **Ackley** is at `X0`; the global minimum for **Alpine** is at zero; the global minimum for **Tripod** is at `[0,-ky]` with local minimum at `[-kx,+ky]` and `[+kx,+ky]`.

repository: gabrielegilardi/PSO

repo_name: gabrielegilardi/PSO


text:
# [Connecticut Facts](http://alexa.amazon.com/#skills/amzn1.ask.skill.d9fd1895-5b85-45d6-82ba-7701cc9a4098)
![0 stars](../../images/ic_star_border_black_18dp_1x.png)![0 stars](../../images/ic_star_border_black_18dp_1x.png)![0 stars](../../images/ic_star_border_black_18dp_1x.png)![0 stars](../../images/ic_star_border_black_18dp_1x.png)![0 stars](../../images/ic_star_border_black_18dp_1x.png) 0

To use the Connecticut Facts skill, try saying...

* *Alexa, open Connecticut facts*

* *Alexa, start Connecticut facts and tell me a fact*

* *Alexa, launch Connecticut facts and give me a fact*

If your friends have ever questioned just how cool of a state Connecticut really is, now you can have Alexa help you convince them! Ask Alexa to tell you some cool facts, to help you prove that it is a pretty neat place.

***

### Skill Details

* **Invocation Name:** connecticut facts
* **Category:** null
* **ID:** amzn1.ask.skill.d9fd1895-5b85-45d6-82ba-7701cc9a4098
* **ASIN:** B01J0EQJQ0
* **Author:** chadioo
* **Release Date:** July 25, 2016 @ 19:26:24
* **In-App Purchasing:** No


text:
---
layout: default
---

# 1996-06-24 - Re: unsuscribe

## Header Data

From<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: d470d20dc2cd8c5175521ded9e956e59b9979687cb5d56a3accb1990a86e2712

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1996-06-24 05:40:35 UTC

Raw Date: Mon, 24 Jun 1996 13:40:35 +0800

## Raw message

```
{% raw  %}From<EMAIL_ADDRESS>Date: Mon, 24 Jun 1996 13:40:35 +0800
To<EMAIL_ADDRESS>Subject: Re: unsuscribe
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

<EMAIL_ADDRESS>writes:
 > unsuscribe

     Hmm, the clueless list is no longer available at c2.  Pity.

{% endraw %}
```

## Thread

+ Return to [June 1996](/archive/1996/06)

+ Return to "[anonymous-remailer@shell.portal.com](/authors/anonymousremailer_at_shell_portal_com)"

+ 1996-06-24 (Mon, 24 Jun 1996 13:40:35 +0800) - Re: unsuscribe -<EMAIL_ADDRESS>


text:
# Changelog for Elixir v1.9

## Releases

The main feature in Elixir v1.9 is the addition of releases. A release is a self-contained directory that consists of your application code, all of its dependencies, plus the whole Erlang Virtual Machine (VM) and runtime. Once a release is assembled, it can be packaged and deployed to a target as long as the target runs on the same operating system (OS) distribution and version as the machine running the `mix release` command.

You can start a new project and assemble a release for it in three easy steps:

    $ mix new my_app
    $ cd my_app
    $ MIX_ENV=prod mix release

A release will be assembled in `_build/prod/rel/my_app`. Inside the release, there will be a `bin/my_app` file which is the entry point to your system. It supports multiple commands, such as:

  * `bin/my_app start`, `bin/my_app start_iex`, `bin/my_app restart`, and `bin/my_app stop` - for general management of the release

  * `bin/my_app rpc COMMAND` and `bin/my_app remote` - for running commands on the running system or to connect to the running system

  * `bin/my_app eval COMMAND` - to start a fresh system that runs a single command and then shuts down

  * `bin/my_app daemon` and `bin/my_app daemon_iex` - to start the system as a daemon on Unix-like systems

  * `bin/my_app install` - to install the system as a service on Windows machines

### Why releases?

Releases allow developers to precompile and package all of their code and the runtime into a single unit. The benefits of releases are:

  * Code preloading. The VM has two mechanisms for loading code: interactive and embedded. By default, it runs in the interactive mode which dynamically loads modules when they are used for the first time. The first time your application calls `Enum.map/2`, the VM will find the `Enum` module and load it. There’s a downside. When you start a new server in production, it may need to load many other modules, causing the first requests to have an unusual spike in response time. Releases run in embedded mode, which loads all available modules upfront, guaranteeing your system is ready to handle requests after booting.

  * Configuration and customization. Releases give developers fine grained control over system configuration and the VM flags used to start the system.

  * Self-contained. A release does not require the source code to be included in your production artifacts. All of the code is precompiled and packaged. Releases do not even require Erlang or Elixir in your servers, as they include the Erlang VM and its runtime by default. Furthermore, both Erlang and Elixir standard libraries are stripped to bring only the parts you are actually using.

  * Multiple releases. You can assemble different releases with different configuration per application or even with different applications altogether.

### Hooks and Configuration

Releases also provide built-in hooks for configuring almost every need of the production system:

  * `config/config.exs` (and `config/prod.exs`) - provides build-time application configuration, which is executed when the release is assembled

  * `config/releases.exs` - provides runtime application configuration. It is executed every time the release boots and is further extensible via config providers

  * `rel/vm.args.eex` - a template file that is copied into every release and provides static configuration of the Erlang Virtual Machine and other runtime flags

  * `rel/env.sh.eex` and `rel/env.bat.eex` - template files that are copied into every release and executed on every command to set up environment variables, including ones specific to the VM, and the general environment

We have written extensive documentation on releases, so we recommend checking it out for more information.

## Configuration overhaul

A new `Config` module has been added to Elixir. The previous configuration API, `Mix.Config`, was part of the Mix build tool. But since releases provide runtime configuration and Mix is not included in releases, we ported the `Mix.Config` API to Elixir. In other words, `use Mix.Config` has been soft-deprecated in favor of `import Config`.

Another important change related to configuration is that `mix new` will no longer generate a `config/config.exs` file. [Relying on configuration is undesired for most libraries](https://hexdocs.pm/elixir/library-guidelines.html#avoid-application-configuration) and the generated config files pushed library authors in the wrong direction. Furthermore, `mix new --umbrella` will no longer generate a configuration for each child app, instead all configuration should be declared in the umbrella root. That's how it has always behaved, we are now making it explicit.

## Other enhancements

There are many other enhancements. The Elixir CLI got a handful of new options in order to best support releases. `Logger` now computes its sync/async/discard thresholds in a decentralized fashion, reducing contention. `EEx` templates support more complex expressions than before. Finally, there is a new `~U` sigil for working with UTC DateTimes as well as new functions in the `File`, `Registry`, and `System` modules.

## v1.9.0-dev

### 1. Enhancements

#### EEx

  * [EEx] Allow more complex mixed expressions when tokenizing

#### Elixir

  * [Access] Allow `Access.at/1` to handle negative index
  * [CLI] Add support for `--boot`, `--boot-var`, `--erl-config`, `--pipe-to`, `--rpc-eval`, and `--vm-args` options
  * [Code] Add `static_atom_encoder` option to `Code.string_to_quoted/2`
  * [Code] Support `:force_do_end_blocks` on `Code.format_string!/2` and `Code.format_file!/2`
  * [Code] Do not raise on deadlocks on `Code.ensure_compiled/1`
  * [Config] Add `Config`, `Config.Reader`, and `Config.Provider` modules for working with configuration
  * [File] Add `File.rename!/2`
  * [Inspect] Add `:inspect_fun` and `:custom_options` to `Inspect.Opts`
  * [Kernel] Add `~U` sigil for UTC date times
  * [Kernel] Optimize `&super/arity` and `&super(&1)`
  * [Kernel] Optimize generated code for `with` with a catch-all clause
  * [Kernel] Validate `__struct__` key in map returned by `__struct__/0,1`
  * [Module] Add `Module.get_attribute/3`
  * [Protocol] Improve `Protocol.UndefinedError` messages to also include the type that was attempted to dispatch on
  * [Protocol] Optimize performance of dynamic dispatching for non-consolidated protocols
  * [Record] Include field names in generated type for records
  * [Regex] Automatically recompile regexes
  * [Registry] Add `Registry.select/2`
  * [System] Add `System.restart/0`, `System.pid/0` and `System.no_halt/1`
  * [System] Add `System.get_env/2`, `System.fetch_env/1`, and `System.fetch_env!/1`
  * [System] Support `SOURCE_DATE_EPOCH` for reproducible builds

#### ExUnit

  * [ExUnit] Allow multiple `:exclude` on configuration/CLI
  * [ExUnit.DocTest] No longer wrap doctest errors in custom exceptions. They ended-up hiding more information than showing
  * [ExUnit.DocTest] Display the actual doctest code when doctest fails

#### IEx

  * [IEx.CLI] Copy ticktime from remote node on IEx `--remsh`
  * [IEx.CLI] Automatically add a host on node given to `--remsh`

#### Logger

  * [Logger] Use a decentralized mode computation for Logger which allows overloads to be detected more quickly
  * [Logger] Use `persistent_term` to store configuration whenever available for performance

#### Mix

  * [Mix] Follow XDG base dir specification in Mix for temporary and configuration files
  * [Mix.Generator] Add `copy_file/3`, `copy_template/4`, and `overwite?/2`
  * [mix archive.uninstall] Allow `mix archive.uninstall APP` to uninstall any installed version of APP
  * [mix new] No longer generate a `config/` directory for mix new
  * [mix release] Add support for releases
  * [mix release.init] Add templates for release configuration
  * [mix test] Allow running tests for a given umbrella app from the umbrella root with `mix test apps/APP/test`. Test failures also include the `apps/APP` prefix in the test location

### 2. Bug fixes

#### EEx

  * [EEx] Consistently trim newlines when you have a single EEx expression per line on multiple lines

#### Elixir

  * [Code] Quote `::` in `Code.format_string!/1` to avoid ambiguity
  * [Enum] Ensure the first equal entry is returned by `Enum.min/2` and `Enum.max/2`
  * [Kernel] Improve error message when string interpolation is used in a guard
  * [Kernel] Properly merge and handle docs for callbacks with multiple clauses
  * [Kernel] Guarantee reproducible builds on modules with dozens of specs
  * [Kernel] Resolve `__MODULE__` accordingly in nested `defmodule` to avoid double nesting
  * [Kernel] Type variables starting with an underscore (`_foo`) should not raise compile error
  * [Kernel] Keep order of elements when macro `in/2` is expanded with a literal list on the right-hand side
  * [Kernel] Print proper location on undefined function error from dynamically generated functions
  * [System] Make sure `:init.get_status/0` is set to `{:started, :started}` once the system starts
  * [Path] Do not expand `~` in `Path.expand/2` when not followed by a path separator
  * [Protocol] Ensure `debug_info` is kept in protocols
  * [Regex] Ensure inspect returns valid `~r//` expressions when they are manually compiled with backslashes
  * [Registry] Fix ETS leak in `Registry.register/2` for already registered calls in unique registries while the process is still alive

#### ExUnit

  * [ExUnit] Raise error if attempting to run single line tests on multiple files
  * [ExUnit] Return proper error on duplicate child IDs on `start_supervised`

#### IEx

  * [IEx] Automatically shut down IEx if we receive EOF

#### Logger

  * [Logger] Don't discard Logger messages from other nodes as to leave a trail on both systems

#### Mix

  * [mix compile] Ensure Erlang-based Mix compilers (erlang, leex, yecc) set valid position on diagnostics
  * [mix compile] Ensure compilation halts in an umbrella project if one of the siblings fail to compile
  * [mix deps] Raise an error if the umbrella app's dir name and `mix.exs` app name don't match
  * [mix test] Do not consider modules that are no longer cover compiled when computing coverage report, which could lead to flawed reports

### 3. Soft-deprecations (no warnings emitted)

#### Mix

  * [Mix.Config] `Mix.Config` has been deprecated in favor of the `Config` module that now ships as part of Elixir itself. Reading configuration files should now be done by the `Config.Reader` module

### 4. Hard-deprecations

#### Elixir

  * [CLI] Deprecate `--detached` option, use `--erl "-detached"` instead
  * [Map] Deprecate Enumerable keys in `Map.drop/2`, `Map.split/2`, and `Map.take/2`
  * [String] The `:insert_replaced` option in `String.replace/4` has been deprecated. Instead you may pass a function as a replacement or use `:binary.replace/4` if you need to support earlier Elixir versions

#### Mix

  * [Mix.Project] Deprecate `Mix.Project.load_paths/1` in favor of `Mix.Project.compile_path/1`

## v1.8

The CHANGELOG for v1.8 releases can be found [in the v1.8 branch](https://github.com/elixir-lang/elixir/blob/v1.8/CHANGELOG.md).

repository: Schultzer/elixir

repo_name: Schultzer/elixir


text:
# Jarvis - A Slackbot for Operations

Jarvis is a Slack bot that can interact with MS SQL Server, Pagerduty, and JIRA.

## Connecting to Slack

In order to connect to Slack you have to first configure a bot integration. This will provide you with an API token. This token, as well as the bot name, must be passed in via envrionment variables SLACK_TOKEN and SLACK_BOT.

```
docker run \
  -e 'SLACK_TOKEN=xxxx-00000000000-000000000000000000000000' \
  -e 'SLACK_BOT=jarvis' \
  -d m82labs/jarvis
```

## Limiting Plugins

If you only want to run specific plugins, you can list them in the PLUGINS environment variable. Current available plugins are: sql_status, jira, and pagerduty.
```
 docker run \
  -e 'SLACK_TOKEN=xxxx-00000000000-000000000000000000000000' \
  -e 'SLACK_BOT=jarvis' \
  -e 'PLUGINS=sql_status jira'  \
  -d m82labs/jarvis
```

## MS SQL Server

To connect to SQL Server you must first create a user on each instance you will be connecting to. The user will require VIEW SERVER STATE permissions. When running the container, the DB_USERNAME and DB_PASSWORD environment variables must be provided.

Jarvis uses REGEX to determine which server you are trying to get the status of. By default it will match servers with a naming scheme of: AA-AAAA-###, or a standard IP address. If you have a special naming scheme you use, pass in a regex that matches it via the SQL_REGEX environment variable.
```
docker run \
  -e 'SLACK_TOKEN=xxxx-00000000000-000000000000000000000000' \
  -e 'SLACK_BOT=jarvis' \
  -e 'DB_USERNAME=jarvis' \
  -e 'DB_PASSWORD=MyStrongPassword001@@' \
  -d m82labs/jarvis
```

## JIRA

JIRA requires a username and password, as well as the base URL for the JIRA API.
```
docker run \
  -e 'SLACK_TOKEN=xxxx-00000000000-000000000000000000000000' \
  -e 'SLACK_BOT=jarvis' \
  -e 'JIRA_USER=jarvis' \
  -e 'JIRA_PASSWORD=MyStrongPassword001@@' \
  -e 'JIRA_URL=https://jira.mydomain.com' \
  -d m82labs/jarvis
```

## PagerDuty

Jarvis has several functions related to PagerDuty including assigning the pager to the user, seeing who is on call, and seeing when the user is on call next.


text:
# Example dataset
We use the [data on seizure counts for 59 epileptics](https://content.sph.harvard.edu/fitzmaur/ala/epilepsy.txt) from the [Applied Longitudinal Analysis](https://content.sph.harvard.edu/fitzmaur/ala/) by Garrett Fitzmaurice, Nan Laird & James Ware.

The dataset is converted into design matrix, outcome vector and id vector to serve as inputs of the geeCpp functions.

## References
* Thall, P.F. and Vail, S.C. (1990). Some covariance models for
longitudinal count data with overdispersion. Biometrics, 46, 657-671,
* Fitzmaurice, G. M., Laird, N. M., & Ware, J. H. (2012). Applied longitudinal analysis (Vol. 998). John Wiley & Sons.

repository: hengshiyu/geeCpp

repo_name: hengshiyu/geeCpp


text:
---
title: Migration
---

# Migration to 1.0

On the one hand I want to minimize the breaking-changes in this release, but on the other hand
due the beta-testing I realize that much aspects should be changed. The library have became
much larger and much difficult that it was before, so the breaking-changes became inevitable.

This goal of this guide to facilitate the migration to the new version.

## Installation

### Styles

Now the styles are not injected automatically. You should import the styles directly.

### Using Bundler

```js
import { Cropper } from 'vue-advanced-cropper';
// Add the following line to import the cropper styles
import 'vue-advanced-cropper/dist/style.css';
```

### Using CDN

```html
<script<EMAIL_ADDRESS>/>
<!-- Add the following line to import the cropper styles -->
<link rel="stylesheet"<EMAIL_ADDRESS>/>
```

## Changed the markup of cropper

1. Background is limited by boundaries now. To set the background of the entire cropper set background for the entire cropper.

2. The foreground layer was added (to customize it use `foreground-class`. It lays above the background and the image, but it lays below the stencil.
It used to dark the image.

## Changed the defaults

1. The default setting for the `default-boundaries` is `'fill'` now (was `'fit'`). It looks as more appropriate setting for the
majority of different croppers.

2. The default setting for the `image-restriction` is `fit-area` now (was `'fill-area'`)

3. The default `size-restrictions-algorithm` is changed: `minWidth`, `minHeight`, `maxWidth` and `maxHeight` set
the limitations in the pixels now (before they set limitations in the percents).

4. The default settings of `resizeImage` is changed. Now `adjustStencil` is enabled by default.

## Changed props

1. Replaced `wheelResize`, `touchResize`, `touchMove`, `mouseMove` props by [`resizeImage`](/components/cropper.html#resizeimage) and [`moveImage`](/components/cropper.html#moveImage) props.

2. Renamed `classname`, `areaClassname`, `backgroundClassname`, `imageClassname`, `linesClassnames` and `classnames` to `class`, `boundariesClass`, `backgroundClass`, `imageClass`, `linesClasses` and `classes` respectively.

3. Renamed `lineComponent`, `handlerComponent` to `linesComponent`, `handlersComponent`

4. Renamed `restrictions` to `size-restrictions-algorithm`

5. The priority prop now accepts `'visible-area'` instead of `'visibleArea'`.

6. The `RectangleStencil`, `CircleStencil` and `BoundingBox` prop `scalable` was renamed to `resizable`.

## Changed methods

1. The callback in `setCoordinates` method now should accept only one argument: the object with fields `coordinates`, `imageSize` and `visibleArea`.
```js
this.$refs.cropper.setCoordinates(({ coordinates, imageSize, visibleArea}) => {
	return {
		width: visibleArea.width,
		height: visibleArea.height
	}
})
```

repository: tiebasile/vue-advanced-cropper

repo_name: tiebasile/vue-advanced-cropper


text:
Thank you for taking the time to consider making a contribution to the
cfdm package.

# General Guidelines

All questions, reports of bugs, and suggestions for enhancements
should be raised as GitHub issues
(https://github.com/NCAS-CMS/cfdm/issues).

# Versioning

A version of the cfdm package will always be based on the latest version of
the CF conventions to which it applies, with the addition of an extra
integer value that is incremented each time the package is
updated. For example, the first release for version 1.7 of the CF
conventions (CF-1.7) would have cfdm version `1.7.0`, and subsequent
changes to the package would be `1.7.1`, `1.7.2`, etc. This carries on
until the first release to apply to version CF-1.8, which would be
cfdm version `1.8.0`.

repository: cofinoa/cfdm

repo_name: cofinoa/cfdm


text:
# cadexquis

## Set up

You should have created a bot through [Discord developer's portal](https://discordpy.readthedocs.io/en/latest/discord.html)

1. Download the repo
2. Write your bot token inside `src/bot/config/config-example.json`
3. Rename the config file to `config.json`
4. Spin up the container: `docker-compose up`
5. Add the bot to your server

repository: sixIf/cadexquis

branch_name: refs/heads/main

gha_language: TypeScript

repo_name: sixIf/cadexquis


text:
[![Build Status](https://travis-ci.org/siemendev/forskel.svg?branch=master)](https://travis-ci.org/siemendev/forskel)
[![Latest Stable Version](https://poser.pugx.org/siemendev/forskel/v/stable)](https://packagist.org/packages/siemendev/forskel)

# Forskel

Forskel is a loosely coupled frontend rendering library for multi-site symfony projects that share the same frontend markup.

**Sound good, right? *But what does that MEAN?***

When using the same frontend for multiple symfony projects, one way to keep redundancy low is to decouple the frontend architecture from the actual business logic into an own bundle. Taking over from this approach I´ve been developing *Forksel* to keep the templating out of the operational symfony projects.

With *Forskel* you're able to write super clean, object-oriented code instead of templating markup in the projects while you  maintain the markup in the templates for all of them at one place: The *Forskel* based Extension-Bundle.

## Give it a shot, take me to implementing *Forskel*!

First of all, one thing is important to understand: **You don´t implement *Forskel* in a normal project.**
*Forskel* is intended to be used as a basic library/tool for your own external frontend bundle.

### Setup your first *Forskel* bundle
So lets just jump right in and start with a basic implementation of *Forskel* for a demo project:

1. Setup an reusable Bundle for your project ouside your project root according to [The Symfony Documentation](https://symfony.com/doc/4.1/bundles/best_practices.html).
2. Install *Forskel* in your bundle: ``` $ composer require siemendev/forskel```
3. Install your reuseable bundle in one of your main projects by configuring a local [repository](https://getcomposer.org/doc/05-repositories.md) in your composer.json. As long as you are developing locally, you probably want to link the bundle via the [*path* repository type](https://getcomposer.org/doc/05-repositories.md#path). Later on production environments you probably use the vcs repository to install specific stable versions of your bundle to your project.
4. **Keep in mind:** Unless you still want to use it, the twig templating engine will from now on no longer be used in your project´s repository. All templates will be created and maintained inside of your newly created bundle.

**That´s it already, we´re good to go!**

### Implementing your first model

1. Create your model file. e.g. [bundle sources root]/models/MyFancyPage.php
  ```php
  namespace vendor\FrontendBundle\Models;

  use siemendev\ForskelBundle\Models\AbstractModel;
  use siemendev\ForskelBundle\Models\ModelInterface;

  class MyFancyPage extends AbstractModel
  {
      /** @var string */
      public $headline;

      /** @var ModelInterface[] */
      public $contents;
  }
  ```
  *Pro tip:* Using private properties here with properly type-sensitive getters and setters allows you to force the right type for your property!

2. Create the corresponding template in [bundle sources root]/Resources/views/my-fancy-page.html.twig
  ```html
  <html>
  <body>
      <p>This is my fancy page.</p>
      {% if model.headline is not empty %}
          <h1>{{ model.headline }}</h1>
      {% endif %}

      {% for content in model.contents %}
          {{ forskel_render(content) }}
      {% endfor %}
  </body>
  </html>
  ```

Okay, that´s it on the bundle side, lets move over to the project itself where you installed the bundle manually!

### Filling the model with data and rendering it
In this example we´re using an existing controller, the IndexController from any project that has our previously created reusable bundle installed (see Setup 3).

Usually you would end this controller with a ```return $this->render();``` statement rendering the view, let´s see how *Forskel* changes this:

```php
namespace vendor\ProjectBundle\Controller;

use vendor\FrontendBundle\Models\MyFancyPage;
use siemendev\ForskelBundle\Renderers\TwigRenderer;

class IndexController extends AbstractController
{
    /**
     * @Route("/", name="index")
     */
    public function index(TwigRenderer $forskel)
    {
        $page = new MyFancyPage();
        $page->headline = 'This page is so fancy!';

        return $forskel->render($page));
    }
}
```
**Pro tip:** If you don't want to inject the Renderer in every controller manually, try extending symfonys AbstractController to automaticly load the renderer.

**Master tip:** Overwrite the render() method in the extended AbstractController. This way you remove the build-in twig rendering, which forces the developers in the project even more to use Forskel for Frontend rendering.

## Contribution welcome!
If you´re trying out *Forskel* and have some feedback, [open up an issue](https://github.com/siemendev/forskel/issues)
or start contributing directly into the github repository, I´m thankful for every help to make *Forskel* better!

repository: Fazzke/forskel

repo_name: Fazzke/forskel


text:
# autobanking

Automatic banking to keep track of your expenses

## Objectives

* Small project to keep online banking expenses under control.

* Automatizes the access to online banking and keeps your expenses data locally in a database.

* Requests the status of all your online bank accounts and saves it in an excel automatically.

* This Excel will be parsed and categorised and inserted into a SQLite DB.

* Weekly reports sent to e-mail and specific analysis available.

## Status
### What is currently done:
* Access Spanish Kutxabank online bank: enter ID and password from config file.
* Select desired bank account (pending to use XPATH to parse Account number)
* Download data between two dates into /tmp

### TO-DO list:
* Refactor and organise code.
* Use Python-Excel library to read excel data.
* Insert this data into SQLite db
* Reparse SQLite data to categorize it into topics: household, transport, food, ...
* Automatic categorization by requesting the user
* Create expenses reports:
   * Current status
   * Weekly expenses, comparing to previous weeks
   * Monthly expenses, comparing to previous months. show trend
   * Evolution of categories in time
* Add ING bank

### In the future:
* Create all above for other bank provider and join data in one place
* Multiplatform packaging (windows, linux, mac) with Python for easy install and config.
* Docker server running service
* Small app with frontend info and charts

## Getting started

### Prerequisites

Yo need Python 2.7 and the following packages:
```
sudo apt-get install python
sudo apt-get install pip
sudo apt-get install xvfb
#Browser automation
pip install selenium
#Python image processing:
pip install Pillow
#SQL Lite database:
sudo apt-get install sqlite3
#SQLite bindings for python
#Python-excel library
```

download geckodriver and put it in your path

### Installation

clone or download the repository

Copy configexample.ini to config.ini and put your ID/code to access the Spanish ING personal account.

### Usage

To test it, run:

```
python ingdirect.es.py
```

This will open firefox and you will see the execution.
If something fails you will see it in the exceptions.

### Disclamer:
This is a work in progress, use it at your own risk.

### Author:
quikshot

### Acknowledgements
Roger Barnes for inspiration on its Australian ING online access:
https://gist.github.com/mindsocket/3015852

repository: quikshot/autobanking

repo_name: quikshot/autobanking


text:
simple_shell

Table of Contents

.Description
.File Structure
.Requirements
.Installation
.Usage
.Example of Use
.Bugs
.Authors

Description
This is a command line interpreter, or shell, in the tradition of the first Unix shell written by Ken Thompson in 1971. This was made as a project for Holberton School. In this project we apply the knowledge that we have learned in C programming language. Standard functions and system calls employed in simple_shell include:

access, execve, exit, fork, free, malloc, read, signal, wait, write.
File Structure
AUTHORS - List of contributors to this repository
man_1_simple_shell - Manual page for the simple_shell
shell.h - program header file
coincidence.c -
coincidence - looks for coincidence
ext - free and exit buffer
env - prints environ
compare_path - compare PATH in environ
str_concate - concates two strings
free.c - function related to free
freeAll - frees a buffer
checks - writes to standar error
exit.c - fuction related to exit
sigintHandler - signal error
free_env - frees the shell's environment
getargs.c - funtion creates an array of pointers
count - counts the buffer
getargs - creates arrays of ponters with all the arguments
get_env.c - enviromental variables related function
get_env - gets an environ char
get_pwd - creates a pointer of the path
get_env1 - get a specific pointer from env
_strtok.c - custom strtok
_strtok - checks if a character matches in a string and breaks it into tokens
getline1.c - functions related to get a line
store_lineptr - aasigns the line
getline1 - reads imput from a stream
prompt.c - essential functions to the shell
prompt - prints a prompt
spaces.c - functions related to string manipulation
spaces - compare size of string
cpstring - duplicates a string
cd_fun - cd function
changepwd - change pwd and old pwd
oldpwd - get oldpwd
shell.c - main function of the shell
main - the main function of the program
ret - return function
extstatus - return status
writeexe - writes to standar error
writes0 - writes to standar error
calloc.c - allocates memory
calloc - allocates memory and return a pointers
realloc.c - reallocates memory
calloc - reallocates memory and return a pointers
strcpy.c - copies string to buffer
strcpy - copies string to buffer
aux.c - auxiliar functions to print
strlen - returns the length of a string
_puts - writes a string to standard output
_puts2 - writes a string to standard erro
unatoi - converts an unsigned int to a string
writes3 - writes to estandar error
Requirements
simple_shell is designed to run in the Ubuntu 14.04 LTS linux environment and to be compiled using the GNU compiler collection v. gcc 4.8.4 with flags-Wall, -Werror, -Wextra, and -pedantic.

Installation
Clone this repository: git clone "https://github.com/1Eba/simple_shell.git"
Change directories into the repository: cd simple_shell
Compile: gcc -Wall -Werror -Wextra -pedantic *.c -o hsh
Run the shell in interactive mode: ./hsh
Or run the shell in non-interactive mode: example echo "pwd" | ./hsh
Usage
The simple_shell is designed to execute commands in a similar manner to sh, however with more limited functionality. The development of this shell is ongoing. The below features will be checked as they become available (see man page for complete information on usage):

Features
 uses the PATH
 implements builtins
 handles command line arguments
 custom strtok function
 uses exit status
 shell continues upon Crtl+C (^C)
 handles comments (#)
 handles ;
 custom getline type function
 handles && and ||
 aliases
 variable replacement
Builtins
 exit
 env
 setenv
 unsetenv
 cd
 help
 history
Example of Use
Run the executable in your terminal after compiling:

$ ./hsh
$ ls -la
total 116
drwxrwxr-x  3 vagrant vagrant  4096 Aug 25 20:21 .
drwxr-xr-x 14 vagrant vagrant  4096 Aug 25 20:27 ..
drwxrwxr-x  8 vagrant vagrant  4096 Aug 25 20:27 .git
-rw-rw-r--  1 vagrant vagrant   160 Aug 25 00:09 AUTHORS
-rw-rw-r--  1 vagrant vagrant  2828 Jul 31 01:52 README.md
-rw-rw-r--  1 vagrant vagrant   823 Aug 23 16:54 _strtok.c
-rw-rw-r--  1 vagrant vagrant  1967 Aug 24 16:46 coincidence.c
-rw-rw-r--  1 vagrant vagrant   216 Aug 23 16:54 concidence.c~
-rw-rw-r--  1 vagrant vagrant   241 Aug 23 16:54 exit.c
-rw-rw-r--  1 vagrant vagrant   189 Aug 23 16:54 free.c
-rw-rw-r--  1 vagrant vagrant   338 Aug 24 16:46 get_env.c
-rw-rw-r--  1 vagrant vagrant  1117 Aug 23 18:42 getargs.c
-rw-rw-r--  1 vagrant vagrant  1477 Aug 25 20:21 getline1.c
-rw-rw-r--  1 vagrant vagrant  1302 Aug 24 16:46 holberton.h
-rwxrwxr-x  1 vagrant vagrant 29371 Aug 24 16:56 hsh
-rw-rw-r--  1 vagrant vagrant  2271 Aug 25 02:52 man_1_simple_shell
-rw-rw-r--  1 vagrant vagrant   167 Aug 23 16:54 prompt.c
-rw-rw-r--  1 vagrant vagrant   789 Aug 23 18:47 realloc.c
-rw-rw-r--  1 vagrant vagrant   973 Aug 24 16:51 shell.c
-rw-rw-r--  1 vagrant vagrant   527 Aug 24 16:46 spaces.c
-rw-rw-r--  1 vagrant vagrant   270 Aug 23 18:48 strcpy.c
-rw-rw-r--  1 vagrant vagrant    46 Aug 23 16:54 test
Bugs
At this time, there are no known bugs.

Authors
Eba Mengistu | GitHub | Twitter

Patrick Annang | GitHub | Twitter


text:
# Getty Images API SDK

[![Join the chat at https://gitter.im/gettyimages/gettyimages-api_java](https://badges.gitter.im/gettyimages/gettyimages-api_java.svg)](https://gitter.im/gettyimages/gettyimages-api_java?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)

Seamlessly integrate Getty Images' expansive digital content, powerful search technology, and rich metadata into your publishing tools, products and services!

- Search for images from our extensive creative and editorial catalogs.
- Get image metadata.
- Download files using your Getty Images products (e.g., Editorial subscriptions, Easy Access, Thinkstock Subscriptions, and Image Packs).

## Assumptions
* You have a Java SDK installed.
* You have the latest Stand-alone Android Sdk installed. Install at least the Android 2.2 (API 8) Sdk.
* You have IntelliJ IDEA >= 13 installed.
* You have "Getty Test" credentials from http://api.gettyimages.com

## IntelliJ Installation
Import the module into your project
```
File | Import Module...
Point to the ConnectSdk folder
Click on Next, Next, Next, Next, Reuse, then click Finish
```
Add the module dependency to your application
````
File | Project Structure...
Click on Modules
Click on your main application
Click on the Dependencies tab
Click on the + to add a Module Dependency to your main application
Click OK
````

## Usage
Add a TextView control to your activity.
```
   <TextView
            android:id="@+id/textView"
            android:layout_width="fill_parent"
            android:layout_height="wrap_content"
            android:text="Hello World, MyActivity"
            />
```
Add the following code to your activity.
```
import com.gettyimages.connectsdk.ConnectSdk;

public class MyActivity extends Activity {

    private String apiKey = "Connect API Key";
    private String apiSecret = "Connect API Secret";
	...
    String result;

	ConnectSdk connectSdk = new ConnectSdk(apiKey, apiSecret);
	result = connectSdk.Search().Images().Creative().WithPhrase("dog").WithPage(10).ExecuteAsync();

	TextView textView = (TextView) findViewById(R.id.textView);
    textView.setText(result);
	...
```
Update the AndroidManifest.xml to include internet permissions.
```
 <uses-permission android:name="android.permission.INTERNET"/>
```

## FAQ
* If you get an error running the test application make sure that you are using your Getty Key and Secret in the code.
* If you get "Failure [INSTALL_FALIED_OLDER_SDK]", you need to make sure that your minSdkVersion in the AndroidManifest.xml is less than the Target SDK of your AVD.
## Contributing

1. Fork it ( https://github.com/[my-github-username]/ConnectSdk/fork )
2. Create your feature branch (`git checkout -b my-new-feature`)
3. Commit your changes (`git commit -am 'Add some feature'`)
4. Push to the branch (`git push origin my-new-feature`)
5. Create a new Pull Request


text:
# Hive Integration - Conditions

Conditions provide a standard mechanism for higher-level status reporting from a controller. Read more about conditions [here](https://github.com/kubernetes/community/blob/master/contributors/devel/sig-architecture/api-conventions.md#typical-status-properties)

## ClusterDeployment Conditions

Hive handle a set of existing condition [types](https://github.com/openshift/hive/blob/master/apis/hive/v1/clusterdeployment_types.go#L338).

Assisted Installer handles additional types: `SpecSynced`, `ReadyForInstallation`, `Installed` and `Validated`.

|Type|Status|Reason|Message|Description|
|----|----|-----|-------------------|-------------------|
|SpecSynced|True|SyncOK|The Spec has been successfully applied|If the Spec was successfully applied|
|SpecSynced|False|BackendError|The Spec could not be synced due to backend error: <err>|If the Spec was not applied due to 500 error|
|SpecSynced|False|InputError|The Spec could not be synced due to an input error: <err>|If the Spec was not applied due to 40X error|
||||||
|Validated|True|ValidationsPassing|The cluster's validations are passing|Otherwise than other conditions|
|Validated|False|ValidationsFailing|The cluster's validations are failing: "summary of failed validations"|If the cluster status is "insufficient" or "pending-for-input"|
|Validated|Unknown|ValidationsUnknown|The cluster's validations have not yet been calculated|If the validations have not yet been calculated|
||||||
|ReadyForInstallation|True|ClusterIsReady|The cluster is ready to begin the installation|if the cluster status is "ready"|
|ReadyForInstallation|False|ClusterNotReady|The cluster is not ready to begin the installation|If the cluster is before installation ("insufficient"/"pending-for-input")|
|ReadyForInstallation|False|ClusterAlreadyInstalling|The cluster cannot begin the installation because it has already started|If the cluster has begun installing ("preparing-for-installation", "installing", "finalizing", "installing-pending-user-action", "adding-hosts", "installed", "error") |
||||||
|Installed|True|InstallationCompleted|The installation has completed: "status_info"|If the cluster status is "installed"|
|Installed|False|InstallationFailed|The installation has failed: "status_info"|If the cluster status is "error"|
|Installed|False|InstallationNotStarted|The installation has not yet started|If the cluster is before installation ("insufficient"/"pending-for-input"/"ready")|
|Installed|False|InstallationInProgress|The installation is in progress: "status_info"|If the cluster is installing ("preparing-for-installation", "installing", "finalizing", "installing-pending-user-action")|

Here an example of ClusterDeployment conditions:

```sh
Status:
  Conditions:
    Last Probe Time:       2021-04-20T12:40:38Z
    Last Transition Time:  2021-04-20T12:40:38Z
    Message:               The Spec has been successfully applied
    Reason:                SyncOK
    Status:                True
    Type:                  SpecSynced
    Last Probe Time:       2021-04-20T12:52:58Z
    Last Transition Time:  2021-04-20T12:52:58Z
    Message:               The cluster cannot begin the installation because it has already started
    Reason:                ClusterAlreadyInstalling
    Status:                False
    Type:                  ReadyForInstallation
    Last Probe Time:       2021-04-20T12:47:01Z
    Last Transition Time:  2021-04-20T12:47:01Z
    Message:               The cluster s validations are passing
    Reason:                ValidationsPassing
    Status:                True
    Type:                  Validated
    Last Probe Time:       2021-04-20T12:52:58Z
    Last Transition Time:  2021-04-20T12:52:58Z
    Message:               The installation is in progress: Preparing cluster for installation
    Reason:                InstallationInProgress
    Status:                False
    Type:                  Installed
```

## Agent Conditions

The Agent condition types supported are: `SpecSynced`, `Connected`, `ReadyForInstallation`, `Validated` and `Installed`

|Type|Status|Reason|Message|Description|
|----|----|-----|-------------------|-------------------|
|SpecSynced|True|SyncOK|The Spec has been successfully applied|If the Spec was successfully applied|
|SpecSynced|False|BackendError|The Spec could not be synced due to backend error: <err>|If the Spec was not applied due to 500 error|
|SpecSynced|False|InputError|The Spec could not be synced due to an input error: <err>|If the Spec was not applied due to 40X error|
||||||
|Validated|True|ValidationsPassing|The agent's validations are passing|Otherwise than other conditions|
|Validated|False|ValidationsFailing|The agent's validations are failing: "summary of failed validations"|If the host status is "insufficient"|
|Validated|Unknown|ValidationsUnknown|The agent's validations have not yet been calculated|If the validations have not yet been calculated|
||||||
|ReadyForInstallation|True|AgentIsReady|The agent is ready to begin the installation|if the host status is "known"|
|ReadyForInstallation|False|AgentNotReady|The agent is not ready to begin the installation|If the host is before installation ("discovering"/"insufficient"/"disconnected"/"pending-input")|
|ReadyForInstallation|False|AgentAlreadyInstalling|The agent cannot begin the installation because it has already started|If the agent has begun installing ("preparing-successful","preparing-for-installation", "installing", "installed", "error") |
||||||
|Installed|True|InstallationCompleted|The installation has completed: "status_info"|If the host status is "installed"|
|Installed|False|InstallationFailed|The installation has failed: "status_info"|If the host status is "error"|
|Installed|False|InstallationNotStarted|The installation has not yet started|If the cluster is before installation ("discovering"/"insufficient"/"disconnected"/"pending-input/known")|
|Installed|False|InstallationInProgress|The installation is in progress: "status_info"|If the host is installing ("preparing-for-installation", "preparing-successful", "installing")|
||||||
|Connected|True|AgentIsConnected|The agent has not contacted the installation service in some time, user action should be taken|If the host status is not "disconnected"|
|Connected|False|AgentIsDisconnected|The agent's connection to the installation service is unimpaired|If the host status is "error"|

Here an example of Agent conditions:

```sh
Status:
  Conditions:
    Last Transition Time:  2021-04-22T15:50:24Z
    Message:               The Spec has been successfully applied
    Reason:                SyncOK
    Status:                True
    Type:                  SpecSynced
    Last Transition Time:  2021-04-22T15:50:24Z
    Message:               The agent's connection to the installation service is unimpaired
    Reason:                AgentIsConnected
    Status:                True
    Type:                  Connected
    Last Transition Time:  2021-04-22T15:50:33Z
    Message:               The agent cannot begin the installation because it has already started
    Reason:                AgentAlreadyInstalling
    Status:                False
    Type:                  ReadyForInstallation
    Last Transition Time:  2021-04-22T15:50:26Z
    Message:               The agent's validations are passing
    Reason:                ValidationsPassing
    Status:                True
    Type:                  Validated
    Last Transition Time:  2021-04-22T15:50:24Z
    Message:               The installation is in progress: Host is preparing for installation
    Reason:                InstallationInProgress
    Status:                False
    Type:                  Installed
```

## InfraEnv Conditions

The InfraEnv condition type supported is: `ImageCreated`

|Type|Status|Reason|Message|Description|
|----|----|-----|-------------------|-------------------|
|ImageCreated|True|ImageCreated|Image has been created|If the ISO image was successfully created|
|ImageCreated|False|ImageCreationError|Failed to create image: "error message"If the ISO image was not successfully created|

Here an example of InfraEnv conditions:

```sh
Status:
  Conditions:
    Last Transition Time:  2021-04-22T15:49:35Z
    Message:               Image has been created
    Reason:                ImageCreated
    Status:                True
    Type:                  ImageCreated
```


text:
![Logo](assets/codebuddy.png)

[![Build Status](https://travis-ci.org/pastjean/codebuddy.svg?branch=master)](https://travis-ci.org/pastjean/codebuddy)
[![GoDoc](http://godoc.org/github.com/pastjean/codebuddy?status.svg)](http://godoc.org/github.com/pastjean/codebuddy)

> Have a buddy for the week

## Download

1. Get it from [Github releases](https://github.com/pastjean/codebuddy/releases/latest/)
2. Then create your [`teams.json`](teams.json) file
3.

repository: pastjean/codebuddy

repo_name: pastjean/codebuddy


text:
---
hrs_structure:
  division: '2'
  volume: '11'
  title: '26'
  chapter: 482B
  section: ''
type: chapter
tags:
  - Business
menu:
  hrs:
    identifier: HRS0482B
    parent: title26
    name: Chapter 482B Trade Secrets
weight: 40000
title: Trade Secrets
full_title: Chapter 482B Trade Secrets
---
**[CHAPTER 482B]**

**TRADE SECRETS**

Section

482B-1 Short title

482B-2 Definitions

482B-3 Injunctive relief

482B-4 Damages

482B-5 Attorney's fees

482B-6 Preservation of secrecy

482B-7 Statute of limitations

482B-8 Effect on other law

482B-9 Severability

Case Notes

By alleging an induced breach of a confidentiality agreement or a non-disclosure agreement, plaintiff had also alleged that defendants improperly acquired trade secret information; those claims were sufficiently related to plaintiff's allegations of trade secret misappropriation to warrant preemption under this chapter; defendants' motion to dismiss granted. 780 F. Supp. 2d 1061 (2011).

Trade secrets may be subject to equitable division pursuant to §580-47, depending upon when the right to the trade secret vested. 99 H. 101, 53 P.3d 240.

repository: SamMade/BlueAndKrabby

repo_name: SamMade/BlueAndKrabby


text:
Plugins
=======

*The following is a scratchpad for plugin system ideas. It's inconsistent and not final.*

Overview
--------

Mint is small, in the spirit of Unix. I want it to be extensible via a plugin architecture. This is an exploration of how I want that architecture to work.

I have two competing goals to balance:

- Mint should provide value and some degree of consistency to any
  plugins that choose to integrate with it.
- Plugins should not have to follow a hierarchical or class-heavy architecture
  to work out of the box.
- It would be nice if plugins could be written in any language, if they didn't want to
  have control over pre-rendered doc and other features only available to a Ruby script.

Ideas
-----

1. **The lightweight option: Bash interpolation.** `mint epub publish
   file --option1 --option2` calls `mint-epub publish file --option2`
   and consumes `option1`.

2. **The callback option (mainly implemented).** `mint epub publish
   file --option1 --option2` calls `mint publish` with the ePub plugin,
   passing in option2 with opts. *This plugin must be in a
   ~/.mint/plugins directory.* (There will be other plugin directories
   for other scopes.)

3. **The hacky option.** `mint epub publish file --option1 --option2`
   calls `mint` and searches $PATH for all mint-prefixed scripts.
   It then loads the named one and calls Mint.publish! with that
   plugin specified.

It seems like option 2 is the best one. However, it defeats my goal of wanting a lightweight plugin system.

Questions
---------

1. What if the plugin defines a parameter that's named the same as a mint one?

Thoughts
--------

1. I need to figure out how to give wrapped read/write access to the config file, in a standard "config namespace".

Plugin ideas
------------

The following are some ideas I have for Mint plugins. I want plugins to be related to Mint's functionality, but not limited to desktop publishing.

    gem install mint-code
    gem install mint-doc
    gem install mint-epub
    gem install mint-footnotes
    gem install mint-share

### Mint code ###

For syntax highlighting:

    mint code install ruby
    mint code install ruby --color dark

Needs to be able to:

- ON INSTALL: Store Javascript files in its own plugin resources folder
- ON CODE INSTALL: Download code parsers and style from a server
- ON CODE INSTALL: Decide whether user wants all text to be pre-processed
  with this filter, and for Javascript to be injected
- ON INVOCATION: Install new Javascript highlighters and color schemes
- ON INVOCATION: Pass through extra filter. Use jQuery to dynamically
  inject Javascript into `<head/>` of layout

  OR could have convenience method "javascript" that could be used in
  views - this method could be overridden by plugin to provide whatever
  Javascript was necessary - perhaps based on what it found in the
  content file

Potential specification:

- Install callbacks: `before_install`, `after_install`
- Plugin directory for all scopes except gem scope: `plugins/code/
  (Do I need this? Probably so because the gem scope is going to be
  installed with the plugin, but no other folders will be, and I don't
  want to clutter up the space - but I will need to implement convenience
  methods for accessing these folders.)
- Render callbacks: `before\_render`, `after\_render`
- `javascript` convenience method available inside views - one which
  we can override to provide our own (based on analysis from `before\_render`)

### Mint ePub ###

For desktop ePub publishing:

    mint epub publish Minimalism.md

### Desktop to the Web ###

Mint is primarily meant to be a desktop publishing system for people who care about reusability. But I want it to know about the Web, too, because there are plenty of good publishing platforms online that you might want to take advantage of.

What if Mint were social and a good citizen with respect to data portability? If it let you create your documents once and upload to anywhere at any time with one command. This could look like:

    mint share YOUR_FILE --service YOUR_SERVICE --user YOUR_USERNAME

For example:

    mint share Minimalism.md --service crocodoc --user david

If you reuse the same publishing service and authentication details over and over again, it would be easy to set up the scheme in your mint config file:

    services:
      - crocodoc:
          host: crocodoc.com
          username: david
          authentication: password
          key: etc.

      - google-docs:
          host: docs.google.com
          username: david
          authentication: OpenId
          key: etc.

That way, your command could be something like:

    mint share Minimalism.md --service crocodoc

Examples of services could be Crocodoc and Google Docs. Examples of authentication providers could be Twitter, Facebook, and OpenId providers.

Or maybe a plugin could let you could publish multiple output formats, and to multiple locations:

    mint publish --service my-ftp --format html
    mint publish --blog personal

The configuration:

    services:
      - my-ftp:
          host: ftp.provider.com
          username: david
          security: sftp
          directory: /home/david/example.com/documents
      - my-blog:
        # ... etc., etc.

repository: davejacobs/mint

repo_name: davejacobs/mint


text:
---
layout: post
title: "Ruby 1.9.3 Changelog"
date: 2011-11-05 12:52:27 +0530
comments: true
description: "Ruby 1.9.3 Changelog"
keywords: Ruby, Ruby 1.9.3
categories:
- Ruby
- Ruby 1.9.3
---

Ruby 1.9.3 has been released now question is, what’s new in ruby 1.9.3. Below list of new
features introduced in ruby 1.9.3.

###1) Objects hieararchy <!--more-->
###2) Fibers
###3) New character encodings
###4) Faster loading - the load.c patch
###5) Hashes syntax
###6) Improved GC performance with a lazy garbage collector
###7) A 'better strategy' for the GIL / GVL
###8) Test/unit supports parallel testing
###9) Random.rand tweaks (and rand() now accepts ranges)
###10) Main changes

The other main areas where changes were introduced: symbols, arrays,
hashes and blocks.

New method tap has been released to improve chain methods.

branch_name: refs/heads/source

extension: markdown

gha_language: SCSS


text:
# Global Keys for LÖVE
Global Keys is a library that lets you catch keypresses from other applications from within LÖVE!

It has the following limitations presently:
- Windows
- US key layout (others may work, but are untested)

Have a sample:

```lua
local gkeys = require("gkeys")

function love.load()
	gkeys.start()
end

function love.gkeypressed(key)
	print("DOWN:", key)
end

function love.gkeyreleased(key)
	print("UP:", key)
end

function love.update(dt)
	gkeys.update()
end
```

license: Zlib

repository: LPGhatguy/global-keys

gha_language: Lua

repo_name: LPGhatguy/global-keys


text:
---
layout: default
---

# 1994-03-03 - MacPGP a plant?

## Header Data

From: Black Unicorn<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: 37c3e85c917ff6de9c75ecb99d5a80c3a7309bf0f140058f5b85d3a5c2c7cf55

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1994-03-03 12:22:21 UTC

Raw Date: Thu, 3 Mar 94 04:22:21 PST

## Raw message

```
{% raw  %}From: Black Unicorn<EMAIL_ADDRESS>Date: Thu, 3 Mar 94 04:22:21 PST
To<EMAIL_ADDRESS>Subject: MacPGP a plant?
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

Now I'm sure I'm jumping to conclusions, but consider the following:

1>  The MacPGP2.3 source is, as near as I can tell, unreleased and
unavailable.

2>  The output from MacPGP2.3 is easily distinguishable from MSDOS
output.
(MacPGP headers all messages with "Version 2.3" and not "Version 2.3a")

3>  The signature file intended to show the applications is
intact from the author is not included with the compressed application
on any of the sites I have seen MacPGP2.3 on.

The implications are left as an exercise for the reader.

MacPGP2.3 has been in release for some time now, yet no one
has commented (that I have seen) on the absence of a signature
file or detached signature with the release.

Is this because I just can't find the signature, or is there no
signature available?

-uni- (Dark)

{% endraw %}
```

## Thread

+ Return to [March 1994](/archive/1994/03)

+ Return to "[Black Unicorn <unicorn@access.digex.net>](/authors/black_unicorn_unicorn_at_access_digex_net_)"

+ 1994-03-03 (Thu, 3 Mar 94 04:22:21 PST) - MacPGP a plant? - _Black Unicorn<EMAIL_ADDRESS>


text:
# Problem 1: classify double

### Problem statement:
We need to create checkers for the function `classify (double num) {...}` that classifies `double` numbers. [This](https://steve.hollasch.net/cgindex/coding/ieeefloat.html) article might come in handy.

repository: Illumaria/made-cpp

repo_name: Illumaria/made-cpp


text:
# Stan

## Marketing

### Website
<http://mc-stan.org/>

### Social Media
Twitter: [@mcmc\_stan](https://twitter.com/mcmc_stan)

### Citing
http://mc-stan.org/users/citations/index.html

## Governance

### Leadership Team
http://mc-stan.org/team/

### Code of Conduct
?

### Governance Documentation
?

## Code

### Repository
https://github.com/stan-dev

### Documentation
http://mc-stan.org/users/documentation/index.html

### License
https://github.com/stan-dev/stan/tree/develop/licenses
> "The copyright holder for the various Stan licenses are listed
> collectively as the Stan Development Team. The copyright for each code
> contribution to Stan is held by its developer. Each contribution has
> been licensed by its developer under the appropriate license:
>
>   Stan:      new BSD
>   Stan Math: new BSD
>   CmdStan:   new BSD
>   RStan:     GPLv3
>   PyStan:    GPLv3"

## Contact

### Discussion Forums
Discourse: http://discourse.mc-stan.org/

### Events
http://mc-stan.org/events/

repository: jni/numfocus

repo_name: jni/numfocus


text:
# caffe-net-upgrade
caffe-net-upgrade is a tool which takes a caffemodel or a prototxt file as an input that is defined with V1LayerParameters. (Caffe deprecated definition) .
This implementation upgrades to the layer parameters.

**Note: This tool doesn't require installation of caffe to upgrade your model.**

### Pre-requisites
1. Ubuntu 16.04
2. CMake 2.8 or newer [download](https://cmake.org/download/)
3. Install the [Protobuf](https://github.com/google/protobuf) library.

### Build Instructions
1. Install the respective pre-requisites if not present. Make sure to install libprotobuf-dev and protobuf-compiler
2. Navigate to the caffe-net-upgrade folder.
2. mkdir build
3. cd build
4. cmake ../
5. make

This automatically builds a executable in the build folder.

### Usage:
```
    % upgrade_layer_parameters <net.caffemodel | net.prototxt> [output_file_prefix]
```
### Example 1 : Upgrade VGG caffemodel

Download the VGG-Net 19 Layer caffemodel from the following site which is trained with V1LayerParameters [here](https://gist.github.com/ksimonyan/3785162f95cd2d5fee77)

Execute the following command :
```
    % upgrade_layer_parameters VGG.caffemodel output
```
This upgrades the caffemodel and writes into a new caffemodel named output.caffemodel.

### Example 2 : Upgrade VGG prototxt

Download the VGG-Net 19 Layers prototxt defenition from the following site defined with V1LayerParameters [here](https://gist.githubusercontent.com/ksimonyan/3785162f95cd2d5fee77/raw/f02f8769e64494bcd3d7e97d5d747ac275825721/VGG_ILSVRC_19_layers_deploy.prototxt)

Execute the following command:
```
    % upgrade_layer_parameters vgg.prototxt output
```

This upgrades the prototxt defenition and writes into a new file named output.prototxt


text:
## Observer Coding Exercise
Imagine a game where one or more rats can attack a player. Each individual rat has an initial `attack` value of 1. However, rats `attack` as a swarm, so each rat's attack value is actually equal to the total number of rats in play.

Given that a rat enters play through the initializer and leaves play (dies) via its `__exit__` method, please implement the Game and Rat classes so that, at any point in the game, the Attack value of a rat is always consistent.

Here's a sample unit test your code should pass:

```py
def test_three_rats_one_dies(self):
    game = Game()

    rat = Rat(game)
    self.assertEqual(1, rat.attack)

    rat2 = Rat(game)
    self.assertEqual(2, rat.attack)
    self.assertEqual(2, rat2.attack)

    with Rat(game) as rat3:
        self.assertEqual(3, rat.attack)
        self.assertEqual(3, rat2.attack)
        self.assertEqual(3, rat3.attack)

    self.assertEqual(2, rat.attack)
    self.assertEqual(2, rat2.attack)
```


text:
---
path: /beginner-to-git-aliases
date: 2017-06-01
title:
  Moving from beginner to (slightly more) advanced git with aliases.
tags: ['information', 'guide']
published: true
cover: ./cover.jpg
---

Speed up your git workflow with git aliases, this is a brief
introduction on using aliases 👌🚀👍

The more you work with Git the more familiar you become with the
commands used in your every day workflow for your projects or your
team's projects.

Commands like naming and creating feature branches making pull
requests or pushing your changes if you have the requisite
permissions.

So still used by me on a daily basis, and everyone else that uses git
[I presume] is the `git add .` command, then
`git commit -m 'my awesome feature'` and `git push` or
`git push origin <branch>`

In my short time using Git I have always just typed out the full
commands [usually with [my cheatsheet][git-cheatsheet] close to hand]
and thought nothing more of it, that is how you use the tool, right?

Well that was what I foolishly presumed until I learned about
dotfiles, I learned about `.` files from listening to the
[toolsday.io][toolsday] podcast with [Chris][chris] and [Una][una] a
great channel for learning about tooling 👍 the podcast was about [Git
Tools][git-tools] give it a listen it's a great show.

This was a pretty cool learning experience for me and I now have a
pretty efficient git workflow 🚀

Let's go over `.gitconfig`, do you remember having to enter your email
address and name when first setting up Git on your computer? That
information is stored in your `.gitconfig` file, your file will be
located in your user folder on Windows
`C:\Users\yourusername\.gitconfig` or `~/.gitconfig` on Linux/Mac

If you navigate to the file in the text editor of your choice and pop
it open you'll see your details under the `[user]` flag, here's mine:

```bash
[user]
  name = spences10
  email =<EMAIL_ADDRESS>```

I'm not sure what other configuration options you may have in yours so
we're just going to concentrate on the aliases, aliases can be used so
that you can shorten the commands [or make them longer if you like]
but I'm all for reducing key strokes, even if it is one or two less.

So let's review the common commands I mentioned at the start:

```bash
git add .
git commit -m 'my awesome feature'
git push
```

So with aliases we can shorten these down a bit:

In your `.gitconfig` file if there's not already one there add in the
`[aliases]` section, I have mine above my user details, then add in
some aliases:

```bash
[alias]
  a = add .
  c = commit -am
  p = push

[user]
  name = spences10
  email =<EMAIL_ADDRESS>```

So now we can shorten down our workflow for adding a change to one of
our repos:

```bash
git add .
git commit -m 'my awesome feature'
git push
```

Will become:

```bash
git a
git c 'my awesome feature'
git p
```

It's not a massive reduction in what you're typing but you'll be
amazed at how quickly you become accustomed to it and start adding
more an more.

Here's my current list of aliases:

```bash
[alias]
  a = add .
  b = branch
  c = commit -am
  cl = clone
  co = checkout
  d = diff
  f = fetch
  i = init
  o = open # see: https://github.com/paulirish/git-open ♥
  p = push
  pt = push --tags
  s = status
  t = tag
```

A new one I have found out whilst making this post is
`clone --depth 1` which clones only the HEAD of the repository instead
of the whole repository, so say if you were cloning react you'd just
get the master version rather than the other 38 branches included in
the repository. Pretty neat 👍 so that could be aliased into something
a lot shorter `git cl1d`?

You'll no doubt notice the link I have in there for `o = open` that
little gem belongs to [Paul Irish][pi] it's an npm package that will
pop open a browser tab to the current repository you are in, pretty
neat right?

I'm sure there are many, many more ways to configure Git if you take a
look at [Paul Irish][pidf]'s dotfiles repo for his `.gitconfig` you'll
see there is a lot of ways to configure Git, I'm still learning and
finding new ways to do things.

If there is anything I have missed, or if you have a better way to dom
something then please let me know 👍

Get me on [Twitter][sdt] or [Ask Me Anything][ama] on GitHub

If you like this post or if it has helped you in any way then please
give it a like and don't forget to share it on social media 🙌

<!--Links-->

[git-cheatsheet]:
  https://github.com/spences10/cheat-sheets/blob/master/git.md
[toolsday]: http://www.toolsday.io/
[chris]: http://twitter.com/chrisdhanaraj
[una]: http://twitter.com/una
[git-tools]: http://www.toolsday.io/episodes/git.html
[pi]: https://github.com/paulirish
[pidf]: https://github.com/paulirish/dotfiles/blob/master/.gitconfig
[sdt]: https://twitter.com/spences10
[ama]: https://github.com/spences10/ama

gha_language: JavaScript


text:
React Toast Component

    Online Demo

### Description

This is custom toast component implemented by react hooks + React Context API and stayled using tailwindCSS framework. Feel free to inspirate by implementation :) This is trim of my UI lib that i use for my projects.

This componnent allow to push notifications to user screen and auto remove it after set or default time..

Example implements this push-Events:

- Info
- Error
- Warning
- Success
- Custom body

#### Concepts

- Responsive
- Using Hooks and Context API
- Using Tailwind and Fontawesome
  (All can be adjusted by endpoint user)

### Installation

(!!! Package is not available on npm !!!)

1. Clone the repo
   ```sh
   git clone https://github.com/damikun/React-Toast.git
   ```
2. Restore packages
   ```
   yarn install
   ```
3. Build and run demo
   ```
   yarn run start
   ```

### Configuration API

Toast Provider

- Usually placed in Providers.tsx or on top of App.tsx
- Give you access to toast
- In this example toast are send from "HomePage"

```tsx
<ToastProvider variant={"top-right"}>
  <Layout>
    <HomePage />
  </Layout>
</ToastProvider>
```

Use hook to access toast actions

```tsx
// Custom hook to access default context
const toast = useToast();
// OR
// Use of concrete conetxt
const toast = useContext(ToastContext);
```

Example:

```tsx
export default function HomePage() {
  const toast = useToast();

  return (
    <div>
      <StayledButton
        variant="primaryred"
        onClick={() => toast?.pushError("Oppps Error", 5000)}
      >
        Error
      </StayledButton>
    </div>
  );
}
```

Various types to push

```tsx
toast?.pushError("Error messgae", 5000);
toast?.pushWarning("Warning message"); // Default timeValue
toast?.pushSuccess("Success message");
toast?.pushInfo("Info Message");
toast?.push("Message", "Info", 2000);
toast?.pushCustom(<ToastCustomMessage />, 2000);
toast?.pushError("Error messgae", 5000, "truncate-2-lines");
```

Predefined types (can be extended)

```tsx
type TostMessageType = "Info" | "Success" | "Warning" | "Error";
```

Support message truncate trim

```tsx
type Truncate = "truncate-1-lines" | "truncate-2-lines" | "truncate-3-lines";
```

Pass any custom React.ReactNode component to body

```tsx
toast?.pushCustom(<ToastCustomMessage />, 2000);
toast?.pushCustom(<div>My custom body</div>, 2000);
```

Various toast position

```tsx

<ToastProvider variant={"top-right"}>
 // ...
</ToastProvider>

type Position "top_right" | "top_middle" | "top_left" | "bottom_right" | "bottom_middle" | "bottom_left"
```

### Other

For valid display check that your React _"root"_ is flexible and fulscreen to support all browsers behaviour...

```
// public/index.html
<div class="flex h-full w-full" id="root"></div>
```

### Doc

You can read [setp-by-step](./Step-By-Step.md) tutorial if you wanna start from scratch. (Currently writting / Not finished).

## License

This project is licensed with the [MIT license](LICENSE).

repository: visionimpossible/React-Toast

repo_name: visionimpossible/React-Toast


text:
# FedData 2.4.6
* DAYMET functions now do *not* operate in parallel. This was breaking the download functions.
* Final update for version 2 of FedData.
* Accepted to ROpenSci! Migrating to the ROpenSci organization on GitHub.

# FedData 2.4.3
* writeOGR for SSURGO and NHD were failing on Windows when the `extraction.dir` included a trailing slash. Paths are now normalized to remove the trailing slash.

# FedData 2.4.2
* Updated the `get_ned` function to provide more useful errors and warnings when downloads are unsuccessful.

# FedData 2.4.1
* Added pkgdown site.
* SSURGO functions (e.g., `get_ssurgo`) now doesn't bomb on large (> 1 billion sq meter) requests. Now, the area of interest is broken into smaller chunks to build the download list.

# FedData 2.4.0
* Added a `NEWS.md` file to track changes to the package.
* Updated DAYMET functions to fix a bug that downloaded only one tile at a time.
* Linted all code.

repository: mhweber/FedData

repo_name: mhweber/FedData


text:
# TerraForged

TerraForged is a small collection of projects centered around procedurally generated worlds.
The primary outlet of which is a Forge mod for the popular game Minecraft (Java Edition).

### Building From Source

#### Steps
1. Clone the TerraForged repo:
```shell
git clone https://github.com/TerraForged/TerraForged.git
```
2. Modify the build-script to uncomment line#46 and comment-out line#47 (ie the Engine dependency)
3. Generate the TerraForged resources & then build the mod jar:
```shell script
cd TerraForged
./gradlew runData
./gradlew build
```

Notes:
- The runData task will say it failed despite it having completed successfully (bug in forge gradle)
- You may need to set the '[org.gradle.java.home](https://docs.gradle.org/current/userguide/build_environment.html)' variable in gradle.properties to point to your jdk8 installation if you have more modern java versions installed

### Developing With TerraForged's API

#### Dependency
```groovy
repositories {
    maven {
        url "https://io.terraforged.com/repository/maven/"
    }
}

dependencies {
    implementation fg.deobf("com.terraforged:TerraForged:1.16.4-${version}")
}
```

Obtain a `${version}` from the [repository tags](https://github.com/TerraForged/TerraForged/releases)
(versions 0.0.1 to 0.1.2 inclusive are currently unavailable).

#### Usage

TerraForged fires a number of setup events each time its chunk generator is created. These events expose certain
components of the generator allowing for world-gen content to be configured, modified, or added to dynamically.

See the `com.terraforged.api.TerraEvent` class for the available events.

All events are fired on the `FORGE` event bus.

repository: adoxentor/TerraForged

repo_name: adoxentor/TerraForged