text:
# Facebook Search Results Scraper
![MIT License](https://poser.pugx.org/pugx/badge-poser/license.svg)

Scrape thousands of Facebook search places results.

[Facebook Graph API](https://developers.facebook.com/docs/graph-api) has a limit of 400~450 results per query so this why I have decided to make this bot and extract all results without limits.

- [Installation](#installation)
  - [Usage](#usage)
  - [How the bot works](#how-the-bot-works)
- [Debugging](#debugging)
- [Disclaimer](#disclaimer)
![Fb Search Results Bot Scraper](https://i.imgur.com/Vac1qCi.png)

# Installation

**This project requires to [have Node.js installed](https://nodejs.org).**

Clone the repository in your machine
```
$ git clone https://github.com/alfonbots/fb-search-results.git
$ cd fb-search-results/
```
Install the needed packages
```
$ npm install
```
Add a valid Facebook.com account
```
$ echo "user@email.com;password" > account_data.txt
```
Run the app
```
$ node fb.js
```
### Usage
- **Target url**
  - The target url must follow this format:
 [**https://m.facebook.com/search/str/**](https://m.facebook.com/search/str/keyword here/keywords_places)``keyword here``[**/keywords_places**](https://m.facebook.com/search/str/keyword here/keywords_places)
  - Example of a valid target url: **https://m.facebook.com/search/str/Bartending%2BService%2BColorado/keywords_places**
- **Adjust bot speed**
  - Depending of your machine environment you will need to increment/decrease the wait time (``525ms`` by default) an incorrect value (too low) will result in less results scraped (you can find this variable ``var WAIT_CONST = 525`` in line [**107**](https://github.com/alfonbots/fb-search-results/blob/master/fb.js#L107))

### How the bot works

I'll try to simplify how the bot works, if you want to know how it works exactly, take a look to the [**code**](https://github.com/alfonbots/fb-search-results/blob/master/fb.js).

**Behavior:**

The bot prompts for a ``target url``, logins to Facebook.com with the account data from ``account_data.txt`` file, if the bot logins successfully then verifies the ``target url``, if the ``target url`` is valid then navigates to the ``target url``, now will scrape all current visible results, scroll down in the page to load more results, hide the previous visible results scraped changing their CSS display property class to 'none', check if ``endOfResultsDetected`` is true (if it isn't true then will keep repeating the same actions until ``endOfResultsDetected`` is true), if it's true then will save the scraped results to a .txt file and display in the terminal the total results scraped number and the duration time of the scraping operation (in milliseconds).

# Debugging
There are two ways to get more information and know what's happening inside the bot.

1. ``node fb.js --debug``
2. ``DEBUG=nightmare node --harmony fb.js --debug`` (on Windows use ``DEBUG=nightmare & node fb.js --debug``)

The first option shows a window of the bot working, so you can see what's doing.

The second option does the same like the previous option but this option also will give you more depth information about the bot actions.

# Disclaimer
This bot is only for educational purposes. Read [Facebook.com scraping policy](https://www.facebook.com/apps/site_scraping_tos_terms.php) before use it.


text:
# Chaetoporus ambiguus (Bres.) Bondartsev & Singer, 1941 SPECIES

#### Status
SYNONYM

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

#### Published in
Annls mycol. 39(1): 51 (1941)

#### Original name
Poria ambigua Bres., 1897

### Remarks
null

repository: mdoering/backbone

path: /life/Fungi/Basidiomycota/Agaricomycetes/Hymenochaetales/Schizoporaceae/Oxyporus/Oxyporus latemarginatus/ Syn. Chaetoporus ambiguus/README.md

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: mdoering/backbone


text:
## Features

The main feature of this project is to compute the molecular mass of a given molecule and a given data base of element mass.

The element mass data base is described by a simple json file.

## Ultimate features & Current status

The ultimate goals of the project aims to provide a rich syntax to express any molecule.

##### Isotopes

Current version only support simple molecules without isotopes. But the feature is among the final objectives.

##### Free syntax

Currently supports case-sensitive mode (default mode).
All second character of two-characters elements should be upper case.

Fully indexed mode also exists (deprecated), for example CH4 is not allowed but C1H4 is allowed.

I will later add the support for a more 'natural' syntax to support a more free syntax, with more precise syntactic analysis
indicating readable error to help user.

In fact, the name (case-insensitive) of all discovery elements is not a LL(2) language. However, without some rare cases, it may form a LL(2) language.

So i will add several mode: fully indexed, free but case-sensitive, or case-insensitive without some elements.

List of not supported elements in case-insensitive mode:
Si, Sc, Co, Ni, Cu, Nb, In, Sn, Sb, Cs, Hf, Os, Pb, Bi, Po, Bh, Hs, Cn, Nh,
Ho, Yb, Np, Pu, Bk, Cf, No.

The case-sensitive mode will be the default mode.

license: MIT


text:
# Info

This is a very minimal proof of concept of how one could trigger a houdini render with variables from a web interface served by a node.js server.

POSTing a value to the node.js server calls _renderScript.py_ with the submitted value. In the _renderScript.py_ you can see how you can load the _cliRender.hipnc_ file and access its nodes and values. In this case a random seed is being set and apllied to the height of some boxes. Files will be rendered to ./render_output.

It was succesfully tested on:

```
local dev setup:
macOS High Sierra 10.13.4
2.6 GHz Intel Core i5
16 GB 1600 MHz DDR3
Intel Iris 1536 MB

Chrome          	v69.0.3497.81
node            	v8.4.0
npm             	v5.8.0
Houdini Apprentice 	v16.0.504.20
```

# Dependencies

- Houdini (free Apprentice version is sufficent)
- Python
- Node.js + NPM

#Install

```bash
> git pull
> npm install
```

Additionally you need to have the houdini env Variables initialized so either [add them to you bash profile](https://houdinitricks.com/quicktip-os-x-environment-setup-for-houdini-2/) or run houdini_setup from the houdini resource folder.

#Run

```bash
> node app.js
```

- go to _localhost:3000_
- set a random seed and submit

repository: all-in-one-of/houdini-cli-web-trigger

repo_name: all-in-one-of/houdini-cli-web-trigger


text:
# About
This library provides a helper `ExtensionHelper` class that is used in other `locustjs-extensions` libraries.

## Options
`ExtensionHelper` constructor has two parameters:

```javascript
ExtensionHelper(options, logger)
```

### constructor parameters

| Parameter | Type | Required |
|-----------|------|----------|
| `options` | `object`, `string`, `array` | yes |
| `logger` | `object` | no |

Structure of `options` as an object is as follows:
```json
{
    "include": [...],
    "exclude": [...]
}
```

`include` specifies list of function names that are going to be extended on a target object. The default value is `*`. It says all functions should be extended.

`exclude` specifies list of function names that should be skipped or ignored and should be extended on the target obejct.

If a `string` or `array` is passed as `options` parameter to `ExtensionHelper` constructor, it is used as a value for `includes` property.

### methods

| method | description |
|-----------|----------------|
| `configure(options)` | gets an `options` argument in the form of `object`, `string` or `array`, validate it and returns an options object |
| `shouldExtend(fnName)` | Based on an options passed to current `ExtensionHelper` instance, checks whether given `fnName` should be extended or not and returns `true` or `false`. |
| `extend(obj, fnName, fn)` | Checks whether `fnName` function could be extended or not and if so, extends `fn` function with the name `fnName` on given `obj` object. |

## Example
```javascript
const eh = new ExtensionHelper('min, max')

eh.extend(Array, 'min', function () {
    ...
})
```

repository: ironcodev/locustjs-extensions-options

repo_name: ironcodev/locustjs-extensions-options


text:
# Contributing

As Sequentia is an open source library, any contributions from the community are greatly appreciated. This document details the guidelines for making contributions to Sequentia.

## Reporting issues

Prior to reporting an issue, please ensure:

- [ ] You have used the search utility provided on GitHub issues to look for similar issues.
- [ ] You have checked the documentation (for the version of Sequentia you are using).
- [ ] You are using the latest version of Sequentia (if possible).

Issues may be one of four different types listed below. Please use the respective [issue template](/.github/ISSUE_TEMPLATE) when creating an issue:

- **Error or warning** ([template](/.github/ISSUE_TEMPLATE/error-or-warning.md))
For reporting an error or warning generated by Sequentia.
- **Unexpected or incorrect functionality** ([template](/.github/ISSUE_TEMPLATE/unexpected.md))
For reporting something that doesn't seem to be working correctly or is unexpected.
- **Improvement to an existing feature** ([template](/.github/ISSUE_TEMPLATE/improvement.md))
For suggesting an improvement to a feature already offered by Sequentia.
- **Suggesting a new feature** ([template](/.github/ISSUE_TEMPLATE/new-feature.md))
For proposing a new feature to Sequentia that would be beneficial.

## Making changes to Sequentia

- **Add specs**: Your pull request won't be accepted if it doesn't have any specs.

- **Document any change in behaviour**: Make sure the README and all other relevant documentation is kept up-to-date.

- **Create topic branches**: Will not pull from your master branch!

- **One pull request per feature**: If you wish to add more than one new feature, please make multiple pull requests.

- **Meaningful commit messages**: Make sure each individual commit in your pull request has a meaningful message.

- **De-clutter commit history**: If you had to make multiple intermediate commits while developing, please squash them before making your pull request.

### Branch naming conventions

Branch names must be of the form `type/short-phrase-or-description`, where `type` is either a:

- `patch`: Making a change (including removal) of an existing feature.
- `feature`: Adding a new feature.

Branches should typically feature only one main change. If making multiple unrelated changes, please create separate branches and open separate pull requests.

### Making pull requests

**Ensure you use the [pull request template](/.github/PULL_REQUEST_TEMPLATE.md).**

Pull request titles must be of the form `[type:specifier] Pull request title`, where `type` is the same as the branch type (read above).

The `specifier` should be one of:

- `pkg`: Changes to any core package configuration.
- `lib`: Changes to any library code.
- `ci`: Changes to `.travis.yml`.
- `tests`: Changes to any test code.
- `git`: Changes to any Git-related code, such as `.gitignore`.
- `docs`: Changes to any documentation such as `README.md`, `CONTRIBUTING.md`, `LICENSE` or `CHANGELOG.md`.

Continuous integration (Travis CI) builds must pass in order for your pull request to be merged.

## License

By contributing, you agree that your contributions will be licensed under the same [MIT License](/LICENSE) that covers this repository.

## License

By contributing, you agree that your contributions will be licensed under the same [MIT License](/LICENSE) that covers this repository.

repository: thundree/sequentia

repo_name: thundree/sequentia


text:
### [CVE-2016-4486](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2016-4486)
![](https://img.shields.io/static/v1?label=Product&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Version&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Vulnerability&message=n%2Fa&color=brighgreen)

### Description

The rtnl_fill_link_ifmap function in net/core/rtnetlink.c in the Linux kernel before 4.5.5 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel stack memory by reading a Netlink message.

### POC

#### Reference
- https://www.exploit-db.com/exploits/46006/

#### Github
- https://github.com/ARPSyndicate/cvemon
- https://github.com/bcoles/kasld

repository: trickest/cve

branch_name: refs/heads/main

gha_language: HTML

gha_license_id: MIT

repo_name: trickest/cve


text:
# feathers-memory [![Build Status](https://travis-ci.org/feathersjs/feathers-memory.svg?branch=master)](https://travis-ci.org/feathersjs/feathers-memory)[![Code Climate](https://codeclimate.com/github/feathersjs/feathers-memory.png)](https://codeclimate.com/github/feathersjs/feathers-memory)

> An in memory CRUD service for [feathers](http://feathersjs.com)

## Getting Started

Install the module with: `npm install feathers-memory --save`

```js
var feathers = require('feathers');
var memory = require('feathers-memory')();

app.configure(feathers.rest()).use('/users', memory);
```

## Documentation

#### API

The feathers-memory service follows the same convention as all the other services. Therefore, it provides the following methods:

`find`, `get`, `create`, `update`, `patch`, `remove` and `setup`.

```js
var memoryService = {
  find: function(params, callback) {},
  get: function(id, params, callback) {},
  create: function(data, params, callback) {},
  update: function(id, data, params, callback) {},
  patch: function(id, data, params, callback) {},
  remove: function(id, params, callback) {},
  setup: function(app) {}
}
```

#### Usage:

```js
var feathers = require('feathers');
var memory = require('feathers-memory')();
var app = feathers();

app.configure(feathers.rest())
   .use('/users', memory)
   .listen(8080);
```

#### Extending:

You can also extend any of the feathers services to do something custom.

```js
var feathers = require('feathers');
var memory = require('feathers-memory')();
var app = feathers();

var myUserService = memory.extend({
  find: function(params, cb){
    // Do something awesome!

    console.log('I am extending the find method');

    this._super.apply(this, arguments);
  }
});

app.configure(feathers.rest())
   .use('/users', myUserService)
   .listen(8080);
```

#### Advanced Querying

You are probably also going to want to filter your data. You can do that by passing options via the body or in a query string.

## Contributing
In lieu of a formal styleguide, take care to maintain the existing coding style. Add unit tests for any new or changed functionality. Lint and test your code using [Grunt](http://gruntjs.com/).

## Release History
__0.3.0__

- Fixing how the module is exported.
- Adding `PATCH` support back in

__0.2.2__

- Minor bug fixes

__0.2.1__

- Now utilizing [feathers-errors](https://github.com/feathersjs/feathers-errors)
- Proper documentation

__0.2.0__

- Unknown

__0.1.2__

- Unknown

__0.1.1__

- Unknown

__0.1.0__

- Initial release

## License
Copyright (c) 2014 [Eric Kryski](https://github.com/ekryski)
Licensed under the [MIT license](https://github.com/feathersjs/feathers-memory/blob/master/LICENSE-MIT).

gha_language: JavaScript


text:
---
metaTitle: "Android - EditText"
description: "Working with EditTexts, Customizing the InputType, Hiding SoftKeyboard, Icon or button inside Custom Edit Text and its action and click listeners., `inputype` attribute"
---

# EditText

## Working with EditTexts

The EditText is the standard text entry widget in Android apps. If the user needs to enter text into an app, this is the primary way for them to do that.

**EditText**

There are many important properties that can be set to customize the behavior of an EditText. Several of these are listed below. Check out the official text fields guide for even more input field details.

**Usage**

An EditText is added to a layout with all default behaviors with the following XML:

```java
<EditText
    android:id="@+id/et_simple"
    android:layout_height="wrap_content"
    android:layout_width="match_parent">
</EditText>

```

**Note that an EditText is simply a thin extension of the TextView and inherits all of the same properties.**

**Retrieving the Value**

**Getting the value of the text entered into an EditText is as follows:**

```java
EditText simpleEditText = (EditText) findViewById(R.id.et_simple);
String strValue = simpleEditText.getText().toString();

```

Further Entry Customization

**We might want to limit the entry to a single-line of text (avoid newlines):**

```java
<EditText
  android:singleLine="true"
  android:lines="1"
/>

```

**You can limit the characters that can be entered into a field using the digits attribute:**

```java
<EditText
  android:inputType="number"
  android:digits="01"
/>

```

**This would restrict the digits entered to just "0" and "1". We might want to limit the total number of characters with:**

```java
<EditText
  android:maxLength="5"
/>

```

**Using these properties we can define the expected input behavior for text fields.**

**Adjusting Colors**

You can adjust the highlight background color of selected text within an EditText with the `android:textColorHighlight` property:

```java
<EditText
    android:textColorHighlight="#7cff88"
/>

```

Displaying Placeholder Hints

**You may want to set the hint for the EditText control to prompt a user for specific input with:**

```java
<EditText
    ...
    android:hint="@string/my_hint">
</EditText>

```

**Hints**

**Changing the bottom line color**

Assuming you are using the AppCompat library, you can override the styles colorControlNormal, colorControlActivated, and colorControlHighlight:

```java
<style name="Theme.App.Base" parent="Theme.AppCompat.Light.DarkActionBar">
    <item name="colorControlNormal">#d32f2f</item>
    <item name="colorControlActivated">#ff5722</item>
    <item name="colorControlHighlight">#f44336</item>
</style>

```

If you do not see these styles applied within a DialogFragment, there is a known bug when using the LayoutInflater passed into the onCreateView() method.

The issue has already been fixed in the AppCompat v23 library. See this guide about how to upgrade. Another temporary workaround is to use the Activity's layout inflater instead of the one passed into the onCreateView() method:

```java
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
        View view = getActivity().getLayoutInflater().inflate(R.layout.dialog_fragment, container);
  }

```

**Listening for EditText Input**

Check out the basic event listeners cliffnotes for a look at how to listen for changes to an EditText and perform an action when those changes occur.

**Displaying Floating Label Feedback**

Traditionally, the EditText hides the hint message (explained above) after the user starts typing. In addition, any validation error messages had to be managed manually by the developer.

With the `TextInputLayout` you can setup a floating label to display hints and error messages. You can find more [details here](http://stackoverflow.com/documentation/android/5652/textinputlayout#t=201609101109491325049).

## Customizing the InputType

Text fields can have different input types, such as number, date, password, or email address. The type determines what kind of characters are allowed inside the field, and may prompt the virtual keyboard to optimize its layout for frequently used characters.

By default, any text contents within an `EditText` control is displayed as plain text. By setting the [`inputType`](https://developer.android.com/reference/android/widget/TextView.html#attr_android:inputType) attribute, we can facilitate input of different types of information, like phone numbers and passwords:

```java
<EditText
    ...
    android:inputType="phone">
</EditText>

```

Most common input types include:

|Type|Description
|---|---|---|---|---|---|---|---|---|---
|textUri|Text that will be used as a URI
|textEmailAddress|Text that will be used as an e-mail address
|textPersonName|Text that is the name of a person
|textPassword|Text that is a password that should be obscured
|number|A numeric only field
|phone|For entering a phone number
|date|For entering a date
|time|For entering a time
|textMultiLine|Allow multiple lines of text in the field

The `android:inputType` also allows you to specify certain keyboard behaviors, such as whether to capitalize all new words or use features like auto-complete and spelling suggestions.

Here are some of the common input type values that define keyboard behaviors:

|Type|Description
|---|---|---|---|---|---|---|---|---|---
|textCapSentences|Normal text keyboard that capitalizes the first letter for each new sentence
|textCapWords|Normal text keyboard that capitalizes every word. Good for titles or person names
|textAutoCorrect|Normal text keyboard that corrects commonly misspelled words

You can set multiple `inputType` attributes if needed (separated by '|').

Example:

```java
<EditText
    android:id="@+id/postal_address"
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:hint="@string/postal_address_hint"
    android:inputType="textPostalAddress|
                       textCapWords|
                       textNoSuggestions" />

```

You can see a list of all available input types [here](https://developer.android.com/reference/android/widget/TextView.html#attr_android:inputType).

## Hiding SoftKeyboard

Hiding Softkeyboard is a **basic requirement** usually when working with EditText. The softkeyboard by **default** can only be closed by pressing back button and so most developers use [InputMethodManager](https://developer.android.com/reference/android/view/inputmethod/InputMethodManager.html) to force Android to hide the virtual keyboard calling [hideSoftInputFromWindow](http://developer.android.com/reference/android/view/inputmethod/InputMethodManager.html#hideSoftInputFromWindow%28android.os.IBinder,%20int%29) and passing in the token of the window containing your focused view. The code to do the following:

```java
public void hideSoftKeyboard()
{
        InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE);
        inputMethodManager.hideSoftInputFromWindow(getCurrentFocus().getWindowToken(), 0);
}

```

The code is direct, but another major problems that arises is that the hide function needs to be called when some event occurs. What to do when you need the Softkeyboard hidden upon pressing anywhere other than your EditText? The following code gives a neat function that needs to be called in your onCreate() method just once.

```java
public void setupUI(View view)
{
        String s = "inside";
        //Set up touch listener for non-text box views to hide keyboard.
        if (!(view instanceof EditText)) {

            view.setOnTouchListener(new View.OnTouchListener() {

                public boolean onTouch(View v, MotionEvent event) {
                    hideSoftKeyboard();
                    return false;
                }

            });
        }

        //If a layout container, iterate over children and seed recursion.
        if (view instanceof ViewGroup) {

            for (int i = 0; i < ((ViewGroup) view).getChildCount(); i++) {

                View innerView = ((ViewGroup) view).getChildAt(i);

                setupUI(innerView);
            }
        }
}

```

## Icon or button inside Custom Edit Text and its action and click listeners.

This example will help to have the Edit text with the icon at the right side.

>

Note: In this just I am using setCompoundDrawablesWithIntrinsicBounds,
So if you want to change the icon position you can achieve that using
setCompoundDrawablesWithIntrinsicBounds in setIcon.

```java
public class MKEditText extends AppCompatEditText {

    public interface IconClickListener {
        public void onClick();
    }

    private IconClickListener mIconClickListener;

    private static final String TAG = MKEditText.class.getSimpleName();

    private final int EXTRA_TOUCH_AREA = 50;
    private Drawable mDrawable;
    private boolean touchDown;

    public MKEditText(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
    }

    public MKEditText(Context context) {
        super(context);
    }

    public MKEditText(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

    public void showRightIcon() {
        mDrawable = ContextCompat.getDrawable(getContext(), R.drawable.ic_android_black_24dp);

        setIcon();
    }

    public void setIconClickListener(IconClickListener iconClickListener) {
        mIconClickListener = iconClickListener;
    }

    private void setIcon() {
        Drawable[] drawables = getCompoundDrawables();

        setCompoundDrawablesWithIntrinsicBounds(drawables[0], drawables[1], mDrawable, drawables[3]);

        setInputType(InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_PASSWORD);
        setSelection(getText().length());
    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        final int right = getRight();
        final int drawableSize = getCompoundPaddingRight();
        final int x = (int) event.getX();
        switch (event.getAction()) {
            case MotionEvent.ACTION_DOWN:
                if (x + EXTRA_TOUCH_AREA >= right - drawableSize && x <= right + EXTRA_TOUCH_AREA) {
                    touchDown = true;
                    return true;
                }
                break;
            case MotionEvent.ACTION_UP:
                if (x + EXTRA_TOUCH_AREA >= right - drawableSize && x <= right + EXTRA_TOUCH_AREA && touchDown) {
                    touchDown = false;
                    if (mIconClickListener != null) {
                        mIconClickListener.onClick();
                    }
                    return true;
                }
                touchDown = false;
                break;

        }
        return super.onTouchEvent(event);
    }
}

```

>

If you want to change the touch area you can change the
EXTRA_TOUCH_AREA values default I gave as 50.

And for Enable the button and click listener you can call from your Activity or Fragment like this,

```java
MKEditText mkEditText = (MKEditText) findViewById(R.id.password);
mkEditText.showRightIcon();
mkEditText.setIconClickListener(new MKEditText.IconClickListener() {
            @Override
            public void onClick() {
              // You can do action here for the icon.

            }
        });

```

## `inputype` attribute

`inputype` attribute in `EditText` widget: **(tested on Android 4.4.3 and 2.3.3)**

```java
<EditText android:id="@+id/et_test" android:inputType="?????"/>

```

**textLongMessage=** Keyboard: alphabet/default. Enter button: Send/Next. Emotion: yes. Case: lowercase. Suggestion: yes. Add. chars: **,** and **.** and everything

**textFilter=** Keyboard: alphabet/default. Enter button: Send/Next. Emotion: yes. Case: lowercase. **Suggestion: no**. Add. chars: **,** and **.** and everything

**textCapWords=** Keyboard: alphabet/default. Enter button: Send/Next. Emotion: yes. **Case: Camel Case**. Suggestion: yes. Add. chars: **,** and **.** and everything

**textCapSentences=** Keyboard: alphabet/default. Enter button: Send/Next. Emotion: yes. **Case: Sentence case**. Suggestion: yes. Add. chars: **,** and **.** and everything

**time=** Keyboard: numeric. Enter button: Send/Next. Emotion: no. Case: -. **Suggestion: no**. Add. chars: :

**textMultiLine=** Keyboard: alphabet/default. **Enter button: nextline**. Emotion: yes. Case: lowercase. Suggestion: yes. Add. chars: **,** and **.** and everything

**number=** **Keyboard: numeric**. Enter button: Send/Next. Emotion: no. Case: -. Suggestion: no. **Add. chars: nothing**

**textEmailAddress=** Keyboard: alphabet/default. Enter button: Send/Next. **Emotion: no**. Case: lowercase. **Suggestion: no**. Add. chars: **@** and **.** and everything

**(No type)=** Keyboard: alphabet/default. **Enter button: nextline**. Emotion: yes. Case: lowercase. Suggestion: yes. Add. chars: **,** and **.** and everything

**textPassword=** Keyboard: alphabet/default. Enter button: Send/Next. Emotion: no. Case: lowercase. **Suggestion: no**. Add. chars: **,** and **.** and everything

**text=** Keyboard: Keyboard: alphabet/default. Enter button: Send/Next. Emotion: yes. Case: lowercase. Suggestion: yes. Add. chars: **,** and **.** and everything

**textShortMessage=** Keyboard: alphabet/default. **Enter button: emotion**. Emotion: yes. Case: lowercase. Suggestion: yes. Add. chars: **,** and **.** and everything

**textUri=** Keyboard: alphabet/default. Enter button: Send/Next. Emotion: no. Case: lowercase. **Suggestion: no**. Add. chars: **/** and **.** and everything

**textCapCharacters=** Keyboard: alphabet/default. Enter button: Send/Next. Emotion: yes. **Case: UPPERCASE**. Suggestion: yes. Add. chars: **,** and **.** and everything

**phone=** **Keyboard: numeric**. Enter button: Send/Next. Emotion: no. Case: -. **Suggestion: no**. Add. chars: *** # . -  / () W P N , +**

**textPersonName=** Keyboard: alphabet/default. Enter button: Send/Next. Emotion: yes. Case: lowercase. Suggestion: yes. Add. chars: **,** and **.** and everything

Note: `Auto-capitalization` setting will change the default behavior.

Note 2: In the `Numeric keyboard`, ALL numbers are English<PHONE_NUMBER>.

Note 3: `Correction/Suggestion` setting will change the default behavior.

repository: haifenghuang/generate

repo_name: haifenghuang/generate


text:
# iam2tf

### Synopsis

Converts AWS IAM policies into Terraform's `aws_iam_policy_document` format.

### Usage

Given a JSON IAM policy document on stdin, it will produce an equivalent terraform document on stdout:

```shell
$ ruby iam2tf.rb < example.json
```

It is also available as a [docker image](https://hub.docker.com/r/aasmith/iam2tf/):

```shell
$ docker run -i aasmith/iam2tf < example.json
```

#### Example Output

```tf
data "aws_iam_policy_document" "iam2tf" {

  statement {
    sid    = ""
    effect = "Allow"

    actions = [
      "sts:AssumeRole"
    ]

    principals {
      type = "Service"

      identifiers = [
        "ecs-tasks.amazonaws.com"
      ]
    }

  }

}
```

#### Example Input

```javascript
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "",
      "Effect": "Allow",
      "Principal": {
        "Service": "ecs-tasks.amazonaws.com"
      },
      "Action": "sts:AssumeRole"
    }
  ]
}
```

#### Running Tests

Current status: better than nothing.

```bash
for i in test/*.json; do echo $i; ruby iam2tf.rb < $i || break; done
```

#### TODO

 * Improve error handling
 * Add command line options to accept multiple files, etc.

#### References

 * [Terraform IAM Policy Document](https://www.terraform.io/docs/providers/aws/d/iam_policy_document.html)
 * [IAM Policy Grammar](http://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_grammar.html)


text:
JC2-MP Garbage Cleanup plugin
===================

This plugin was created by [Catlinman](https://twitter.com/Catlinman_) for the [Just Cause 2: Multiplayer mod](http://jc-mp.com).

The Garbage Cleanup plugin is used to remove all unmanaged and unused vehicles from the server to reduce the amount of physics calculations the server has to perform. An example of an unmanaged vehicle would be for instance, when a plugin like the [example metatank script](http://wiki.jc-mp.com/Lua/Tutorials/Intermediate/A_tank_that_shoots_tanks) spawns a new vehicle. This vehicle is unmanaged and remains on the server until a player enters it and destroys it. This plugin ensures that such vehicles are removed.

The plugin runs on a timer which will trigger a cleanup cycle after 30 minutes. The time between cycles can be set by editing 'garbage_cleanup.lua' and changing the value of interval variable. The interval is measured in minutes.

This plugin requires a modified freeroam plugin, the reason for this being that the vehicles spawned by freeroam are managed by freeroam alone. We don't want to remove these as they won't be respawned otherwise. Freeroam sends the vehicle it spawns to a list of vehicles inside of the Garbage Cleanup plugin. If a vehicle is in this list it won't be removed in a cleanup cycle.

Commands
--------
All commands require admin status

    /cleanup
    Forces a cleanup cycle

    /cleanup time
    Prints the time until the next cleanup cycle

    /cleanup reset
    Resets the cleanup cycle

    /cleanup enable
    Enables the cleanup cycle

    /cleanup disable
    Disables the cleanup cycle

Admins
--------

In the plugin's server folder, make sure to insert the admin's SteamId into the file admins.txt

You can also temporarily disable an admin by adding '--' infront of the admin's SteamId.


text:
---
layout: default
---

# 1994-11-30 - Re: The Market for Crypto--A Curmudgeon's View

## Header Data

From<EMAIL_ADDRESS>(Lucky Green)

To<EMAIL_ADDRESS>Message Hash: 9f166e6f72e8db7cbb52983a6b310e0ec50487e66dc3110aa44514d2e892421a

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1994-11-30 17:59:13 UTC

Raw Date: Wed, 30 Nov 94 09:59:13 PST

## Raw message

```
{% raw  %}From<EMAIL_ADDRESS>(Lucky Green)
Date: Wed, 30 Nov 94 09:59:13 PST
To<EMAIL_ADDRESS>Subject: Re: The Market for Crypto--A Curmudgeon's View
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

Sandy wrote:

>
>Here's my suggestion.  Eric should unilaterally impose his first
>step, i.e., all unsigned messages and messages with spoofed
>signatures will henceforth be flagged as such.  Let's see what
>effect, if any, that has on the way people post their messages.
>After the protocol has been in effect for some time, we can
>re-open the topic for further discussion.

It seems we have pretty much reached a consensus. Eric should implement a
way to flag un signend posts. [Loved the various headers in Eric's post.
They were real funny.] After this is implemented lets se how it works and
see what else should be done.

However, I agree that this is Eric's list and Eric's rules. If he decides
that it would be a Good Thing to incentivise us Cypherpunks to use more
crypto when posting to the list, he is free to do so with our without
anyone's consent.

-- Lucky Green<EMAIL_ADDRESS>   PGP encrypted mail preferred.

"The very atmosphere of firearms anywhere and everywhere restrains evil
interference - they deserve a place of honor with all that's good." <George
Washington>

{% endraw %}
```

## Thread

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

+ Return to<EMAIL_ADDRESS>(Lucky Green)](/authors/shamrock_at_netcom_com_lucky_green_)"

+ 1994-11-30 (Wed, 30 Nov 94 09:59:13 PST) - Re: The Market for Crypto--A Curmudgeon's View -<EMAIL_ADDRESS>(Lucky Green)_


text:
# process-batches

Asynchronously process series in batches.

This module allows you to process series of jobs in chunks of predefined size.
It can process them in parallel.

[![Build Status](https://travis-ci.org/Janpot/process-batches.svg?branch=master)](https://travis-ci.org/Janpot/process-batches)

## Example

```js
var processBatches = require('process-batches');
var BATCH_SIZE = 100;

processBatches(i => {
  var offset = i * BATCH_SIZE;
  var limit = BATCH_SIZE;
  return db.getUsers(offset, limit);
}, {
  concurrency: 5
}, users => {
  console.log(`sending email to ${users.length} users`);
  return Promise.all(users.map(user => {
    return mailSvc.sendEmail(user.email);
  }));
})
  .then(() => {
    console.log('done sending emails');
  });
```

## API

### `processBatches`

```js
processBatches(fetchFn, [options], processFn)
```

Returns a promise that is fulfilled when all the batches are processed.

#### `fetchFn`

```
Function(number index) -> Promise<Array>|Array
```

Function that takes one parameters, the `index` of the batch.
It is used to fetch the batches. It can either return an array or a promise for an array.
To signal the end, either return `null` or an empty array.

#### `options`

This parameter is optional.

```
Object {
  number concurrency = 1
}
```

Configuration for processing. `size` determines the batch sizes.
Use `concurrency` to specify how many batches should be processed in parallel.
Alternatively you can also just pass the batch size as a number.

#### `processFn`

```
Function(Array batch, number index) processFn -> Promise
```

The function that will process the batch. It is passed the current `batch` and `index` of the batch.
If you return a promise, the module will wait until the promise is fulfilled before starting the next batch.

### `processBatches.fromArray`

Same as `processBatches` but accepts an array as the first parameter.
Batches will be constructed from this array. The `options` object accepts a `size` parameter which controls the size of the array chunks to be processed.
The `options` parameter can also be passed as a number as a shorthand for the size.

**Example:**

```js
processBatches.fromArray([1, 2, 3, 4, 5, 6, 7], 3, batch => {
  console.log(`this batch: [${batch.join(', ')}]!`);
});
// prints:
//   this batch: [1, 2, 3]!
//   this batch: [4, 5, 6]!
//   this batch: [7]!
```

repository: Janpot/process-batches

repo_name: Janpot/process-batches


text:
# supply-chain-dapp

## In this assignment, you will be building a real-world Supply chain decentralized application by following the steps:

### Step 1:

The first thing we need is a Management Smart Contract, where we can add items.

`ItemManager.sol`

```js
// SPDX-License-Identifier: MIT

pragma solidity ^0.6.10;

contract ItemManager{
    enum SupplyChainSteps{Created, Paid, Delivered}

    struct S_Item {
        ItemManager.SupplyChainSteps _step;
        string _identifier;
        uint _priceInWei;
    }

    mapping(uint => S_Item) public items;
    uint index;

    event SupplyChainStep(uint _itemIndex, uint _step);

    function createItem(string memory _identifier, uint _priceInWei) public {
        items[index]._priceInWei = _priceInWei;
        items[index]._step = SupplyChainSteps.Created;
        items[index]._identifier = _identifier;
        emit SupplyChainStep(index, uint(items[index]._step));
        index++;
    }

    function triggerPayment(uint _index) public payable {
        require(items[index]._priceInWei <= msg.value, "Not fully paid");
        require(items[index]._step == SupplyChainSteps.Created, "Item is further in the supply chain");
        items[_index]._step = SupplyChainSteps.Paid;
        emit SupplyChainStep(_index, uint(items[_index]._step));
    }

    function triggerDelivery(uint _index) public {
    require(items[_index]._step == SupplyChainSteps.Paid, "Item is further in the supply chain");
    items[_index]._step = SupplyChainSteps.Delivered;
    emit SupplyChainStep(_index, uint(items[_index]._step));
    }
}
```

Its purpose is to add items and pay them, move them forward in the supply chain and trigger a delivery. Instead, we can just give the user a simple address to send money to.

### Step 2:

Add another contract called `Item.sol`

`Item.sol`

```js
// SPDX-License-Identifier: MIT

pragma solidity ^0.6.10;

import "./ItemManager.sol";
contract Item {
    uint public priceInWei;
    uint public paidWei;
    uint public index;
    ItemManager parentContract;
    constructor(ItemManager _parentContract, uint _priceInWei, uint _index) public {
        priceInWei = _priceInWei;
        index = _index;
        parentContract = _parentContract;
    }

    receive() external payable {
        require(msg.value == priceInWei, "We don't support partial payments");
        require(paidWei == 0, "Item is already paid!");
        paidWei += msg.value;
        (bool success, ) = address(parentContract).call.value(msg.value)(abi.encodeWithSignature("triggerPayment(uint256)", index));
        require(success, "Delivery did not work");
    }

    fallback () external {
    }
}
```

And change the ItemManager Smart Contract to use the Item Smart Contract instead of the `struct` only:

```js
// SPDX-License-Identifier: MIT

pragma solidity ^0.6.10;

import "./Item.sol";

contract ItemManager {
    struct S_Item {
    Item _item;
    ItemManager.SupplyChainSteps _step;
    string _identifier;
    }

    mapping(uint => S_Item) public items;
    uint index;
    enum SupplyChainSteps {Created, Paid, Delivered}

    event SupplyChainStep(uint _itemIndex, uint _step, address _address);

    function createItem(string memory _identifier, uint _priceInWei) public {
        Item item = new Item(this, _priceInWei, index);
        items[index]._item = item;
        items[index]._step = SupplyChainSteps.Created;
        items[index]._identifier = _identifier;
        emit SupplyChainStep(index, uint(items[index]._step), address(item));
        index++;
    }

    function triggerPayment(uint _index) public payable {
        Item item = items[_index]._item;
        require(address(item) == msg.sender, "Only items are allowed to update themselves");
        require(item.priceInWei() == msg.value, "Not fully paid yet");
        require(items[index]._step == SupplyChainSteps.Created, "Item is further in the supply chain");
        items[_index]._step = SupplyChainSteps.Paid;
        emit SupplyChainStep(_index, uint(items[_index]._step), address(item));
    }

    function triggerDelivery(uint _index) public {
        require(items[_index]._step == SupplyChainSteps.Paid, "Item is further in the supply chain");
        items[_index]._step = SupplyChainSteps.Delivered;
        emit SupplyChainStep(_index, uint(items[_index]._step), address(items[_index]._item));
    }
}
```

Now with this, we just have to give a customer the address of the Item Smart Contract created during createItem and he will be able to pay directly by sending X wei to the Smart Contract. But the smart contract isn’t very secure yet. We need some sort of owner functionality.

### Step 3:

Add `onlyOwner` Modifiers and `Ownable` Functionality.
You could add the OpenZeppelin Smart Contracts with the Ownable Functionality.

`Ownable.sol`

```js
// SPDX-License-Identifier: MIT

pragma solidity ^0.6.10;

contract Ownable {
    address public _owner;

    constructor () internal {
        _owner = msg.sender;
    }

    /**
    * @dev Throws if called by any account other than the owner.
    */
    modifier onlyOwner() {
        require(isOwner(), "Ownable: caller is not the owner");
        _;
    }

    /**
    * @dev Returns true if the caller is the current owner.
    */
    function isOwner() public view returns (bool) {
        return (msg.sender == _owner);
    }
}
```

Modify `ItemManager.sol` by adding an `Ownable` contract.

```js
// SPDX-License-Identifier: MIT

pragma solidity ^0.6.10;

import "./Ownable.sol";
import "./Item.sol";

contract ItemManager is Ownable {
    //...
    function createItem(string memory _identifier, uint _priceInWei) public onlyOwner {
        //...
    }
    function triggerPayment(uint _index) public payable {
        //...
    }

    function triggerDelivery(uint _index) public onlyOwner {
        //...
    }

    // ....
}
```

### Step 4:

Installing truffle and unboxing the project
If you do not have installed truffle globally then Run

```sh
$ npm install -g truffle
```

Create a directory called module7_assignment go inside that directory using

```sh
$ cd ./module7_assignment
```

Unbox the react project running following command

```sh
$ truffle unbox react
```

This command should download a repository and install all dependencies in the current folder. Open the project in your favourite IDE. We will be showing the steps assuming [Visual Studio Code](https://code.visualstudio.com/).

### Step 5:

Now you’ll add the contracts created in previous steps and remove `SimpleStorage.sol`.

And add the files created previously:

Now modify the migration file:

`Migrations.sol`

```js
const ItemManager = artifacts.require("./ItemManager.sol");
module.exports = function (deployer) {
  deployer.deploy(ItemManager);
};
```

Modify the `truffle-config.js` file to lock in a specific compiler version:

`truffle-config.js`

```js
const path = require("path");
module.exports = {
  // See <http://truffleframework.com/docs/advanced/configuration>
  // to customize your Truffle configuration!
  contracts_build_directory: path.join(__dirname, "client/src/contracts"),
  networks: {
    develop: {
      port: 8545,
    },
  },
  compilers: {
    solc: {
      version: "0.6.10",
    },
  },
};
```

Run the truffle develop console to check if everything is alright and can be migrated:
On the terminal run:

```sh
$ truffle develop
$ truffle migrate
```

### Step 6:

- Modify the HTML to add the Items to ItemManager
- Open `client/App.js` and modify the beginning of the file:

```js
import React, { Component } from "react";
import ItemManager from "./contracts/ItemManager.json";
import Item from "./contracts/Item.json";
import getWeb3 from "./getWeb3";
import "./App.css";
class App extends Component {
    state = {cost: 0, itemName: "exampleItem1", loaded:false};

    componentDidMount = async () => {
        try {
            // Get network provider and web3 instance.
            this.web3 = await getWeb3();
            // Use web3 to get the user's accounts.
            this.accounts = await this.web3.eth.getAccounts();
            // Get the contract instance.
            const networkId = await this.web3.eth.net.getId();
            this.itemManager = new this.web3.eth.Contract(
                ItemManager.abi,
                ItemManager.networks[networkId] && ItemManager.networks[networkId].address,
            );
            this.item = new this.web3.eth.Contract(
                Item.abi,
                Item.networks[networkId] && Item.networks[networkId].address,
            );
            this.setState({loaded:true});
        } catch (error) {
            // Catch any errors for any of the above operations.
            alert(`Failed to load web3, accounts, or contract. Check console for details.`,);
            console.error(error);
        }
    };

    //.. more code here ...
```

Then add in a form to the HTML part on the lower end of the `App.js` file, in the `render` function:

```js
render() {
    if (!this.state.loaded) {
        return <div>Loading Web3, accounts, and contract...</div>;
    }
    return (
        <div className="App">
        <h1>Simply Payment/Supply Chain Example!</h1>
        <h2>Items</h2>
        <h2>Add Element</h2>
        Cost: <input type="text" name="cost" value={this.state.cost} onChange={this.handleInputChange} />
        Item Name: <input type="text" name="itemName" value={this.state.itemName} onChange={this.handleInputChange} />
        <button type="button" onClick={this.handleSubmit}>Create new Item</button>
        </div>
    );
}
```

And add two functions, one for `handleInputChange`, so that all input variables are set correctly. And one for sending the actual transaction off to the network:

```js
handleSubmit = async () => {
    const { cost, itemName } = this.state;
    console.log(itemName, cost, this.itemManager);
    let result = await this.itemManager.methods.createItem(itemName, cost).send({
        from:this.accounts[0]
        });
    console.log(result);
    alert("Send "+cost+" Wei to "+result.events.SupplyChainStep.returnValues._address);
    };

    handleInputChange = (event) => {
        const target = event.target;
        const value = target.type === 'checkbox' ? target.checked : target.value;
        const name = target.name;
        this.setState({
            [name]: value
        });
    }
```

Open another terminal (leave the one running) and go to the client folder and run
```sh
$ npm start
```
This will start the development server on port 3000 and should open a new tab in your browser:

> Do not worry about the error message that the network wasn’t found or the contract wasn’t found under the address provided. Follow along in the next step where you change the network in MetaMask! As long as there is no error in your terminal and it says “Compiled successfully” you’re good to go.

### Step 7:
Connect Metamask and add Private key to MetaMask

First, connect with MetaMask to the right network.

- When we migrate the smart contracts with Truffle Developer console, then the first account in the truffle developer console is the “owner”.
- So, either we disable MetaMask in the Browser to interact with the app or we add in the private key from truffle developer console to MetaMask.
- In the Terminal/Powershell where Truffle Developer Console is running scroll to the private keys on top:

Copy the Private Key and add it into MetaMask:

- Then your new Account should appear here with ~100 Ether in it.
- Now let’s add a new Item to our Smart Contract. You should be presented with the popup to send the message to an end-user.

### Step 8:
- Listen to payments

- Now that you know how much to pay to which address you need some sort of feedback. Obviously, you don’t want to wait until the customer tells you that he paid, you want to know right on the spot if a payment happened.
- There are multiple ways to solve this particular issue. For example, you could poll the Item smart contract.
- You could watch the address on a low-level for incoming payments. We will wait for the event “SupplyChainStep” to trigger with _step == 1 (Paid).
Let’s add another function to the `App.js` file:

```js
listenToPaymentEvent = () => {
    let self = this;
    this.itemManager.events.SupplyChainStep().on("data", async function(evt) {
    if(evt.returnValues._step == 1) {
        let item = await self.itemManager.methods.items(evt.returnValues._itemIndex).call();
        console.log(item);
        alert("Item " + item._identifier + " was paid, deliver it now!");
    };
    console.log(evt);
    });
}
```

And call this function when we initialize the app in `componentDidMount`:

```js
//...
this.item = new this.web3.eth.Contract(
    ItemContract.abi,
    ItemContract.networks[this.networkId] && ItemContract.networks[this.networkId].address,
);
// Set web3, accounts, and contract to the state, and then proceed with an
// example of interacting with the contract's methods.
this.listenToPaymentEvent();
this.setState({ loaded:true });
} catch (error) {
// Catch any errors for any of the above operations.
alert(
`Failed to load web3, accounts, or contract. Check console for details.`,
);
console.error(error);
}
//...
```

Whenever someone pays the item a new popup will appear telling you to deliver. You could also add this to a separate page, but for simplicity, we will just add it as an alert popup to showcase the trigger-functionality:

Take the address, give it to someone telling them to send `100 wei` (`0.0000000000000001 ether`) and a bit more gas to the specified address. You can do this either via MetaMask or via the `truffle console`:

```sh
web3.eth.sendTransaction({to: "ITEM_ADDRESS", value: 100, from: accounts[1],
gas: 2000000});
```

Then a popup should appear on the website

### Step 9:
Unit test functionality
Unit testing is important, that’s out of the question. You will implement a simple unit test. First of all, delete the tests in the `/test` folder. They are for the simplestorage smart contract which doesn’t exist anymore. Then add new tests:

`itemmanager.test.js`

```js
const ItemManager = artifacts.require("./ItemManager.sol");
contract("ItemManager", accounts => {
    it("... should let you create new Items.", async () => {
        const itemManagerInstance = await ItemManager.deployed();
        const itemName = "test1";
        const itemPrice = 500;
        const result = await itemManagerInstance.createItem(itemName, itemPrice, { from: accounts[0] });
        assert.equal(result.logs[0].args._itemIndex, 0, "There should be one item index in there")
        const item = await itemManagerInstance.items(0);
        assert.equal(item._identifier, itemName, "The item has a different identifier");
    });
});
```

Mind the difference: In web3js you work with `instance.methods.createItem` while in truffle-contract you work with `instance.createItem`. Also, the events are different. In web3js you work with `result.events.returnValues` and in truffle-contract you work with `result.logs.args`. Keep the truffle development console open and type in a new terminal window:

```sh
$ truffle test
```

It should bring up a test like this:

Your assignment is completed. Zip the truffle project and submit to the dropbox. Do not include the `node_modules` folder in the zip else you’ll receive 0 (but you can resubmit).

### Bonus Step
- Remove the files under the `test` directory.
- Add a new file called `ItemManager.test.js` and write the test scripts for testing `ItemManager.sol` contract.
- Add code coverage for solidity. (Follow this [readme](https://github.com/sc-forks/solidity-coverage#solidity-coverage) to add solidity coverage plugin to the project.)

repository: bhatt-deep/supply-chain-dapp

repo_name: bhatt-deep/supply-chain-dapp


text:
Level 0:
  - name / race / abilities
  - Core Skills I - III

Level 15:
  - Crafting Skill I

Level 30:
  - Choose role: Tank, DPS, Healer
  - Role Skill I

Level 45:
  - Basic Tactics
  - Crafting Skill II

Level 60:
  - Role Skill II
  - Core Skill IV

Level 75:
  - Advanced Group Tactics
  - Crafting Skill III

Level 90:
  - Role Skill III

Level 100:
  - Paragon Skill

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

Core Skills: 5 / 16
Crafting Skills: 3 / 9
Role Skills: 3 / 5
Paragon Skills: 1 / 6
Race: 1 / 5
Major Skill: 1 / 4
Minor Skill: 1 / 3

Total Distinct Character Builds
  = (16 5) * (9 3) * (5 3) * 6 * 5 * 4 * 3
  = 4368 * 84 * 10 * 360
  = 1,320,883,200


text:
# MetaboShiny
Welcome to the info page on MetaboShiny! I am still working on a proper readme, please have patience with me :-)
We are currently on BioRXiv and the paper itself is somewhat of a guide to how to use the software.

http://biorxiv.org/cgi/content/short/734236v1

Please report any issues and feedback on the Issues page here, along with suggestions! =)

# STEP 0: install docker

# STEP 1: pull from docker
docker pull jcwolthuis/metaboshiny

# STEP 3: run the following on command line/terminal
docker run -p 8080:8080 -v ~/MetaboShiny/:/root/MetaboShiny/:cached --rm -it jcwolthuis/metaboshiny Rscript startShiny.R

# STEP 4: navigate to http://localhost:8080

# STEP 5: you're in!


text:
# L314
This is a language for building pie charts.

## Making an artcompiler

### Steps include

* Get, build and start the Graffiticode host app (https://github.com/graffiticode/graffiticode).
* Clone and initialize the starter artcompiler (L314) as a new language (e.g. L314).
  * `$ git clone git@github.com:landonbedell/L314.git`
  * `$ cd L314`
  * `$ npm install`
* Start your compiler as a local service to make sure that all is well.
  * `$ cd ../L314`
  * `$ make`
* Make sure everything is good.
  * Visit your local GC server (e.g. http://localhost:3000/lang?id=314) to test.
  * Paste into the code view: `"hello, world!"..`.
  * See "hello, world!" in the form view.
* Design a language that allows you to say things that are interesting and beautiful.
* Edit ./src/lexicon.js to define a vocabulary for that language.
* Edit ./src/compiler.js to translate the ASTs produced from GC into object code that expresses the output of that language.
* Edit ./src/viewer.js to render that object code in an interesting and beautiful way.
* Test your changes.
  * `$ make`
  * Edit the code in the code view.
* Repeat to taste.

## Example Code
### Basic Donut Graph
`
pie "Test" [
  slice "A" 7 "#f00",
    slice "B" 5 "#00f",
    slice "C" 10 "#0f0",
] {width:600, height:400, donut:true}..
`


text:
# speedy_resizer
Simple command-line tool or module for fast bulk resizing of images using Pillow & multiprocessing

# requirements
python >=3.5
Pillow or Pillow-SIMD for further speedup

# useage
```
python3 resize.py [-h] -dir DIR [-dest DEST] [-subf] -w W -hi HI [-a] [-p] [-r RESAMPLE] [-q QUALITY]

optional arguments:
-h, --help            show this help message and exit
-dir DIR              Pass directory to resize the images in
-dest DEST            Pass directory to save resized the images in, if not specified dest will be ./resize/
-subf                 include images in subfolders
-w W                  width of resized images
-hi HI                height of resized images
-a, --aspect          resized images will retain aspect ratio
-p, --padding         adds black padding to resized images (when --aspect flag is set) so imgs will be of size target_size
-r RESAMPLE, --resample RESAMPLE specify resampling methods from PIL: LANCZOS, NEAREST, BILINEAR, BICUBIC are valid options
-q QUALITY, --quality QUALITY specify jpg quality for resized images from 0 to 95; default 80
```


text:
# Windows virtio drivers

Purpose of this document is to explain how to install virtio drivers for
Microsoft Windows running in a fully virtualized guest.

## Do I need virtio drivers?

Yes. Without the virtio drivers, you cannot use paravirtualized hardware properly. It would either not work, or will have a severe performance penalty.

For more information about VirtIO and paravirtualization, see [VirtIO and paravirtualization](https://wiki.libvirt.org/page/Virtio)

For more details on configuring your VirtIO driver please refer to [Installing VirtIO driver on a new Windows virtual machine](https://docs.openshift.com/container-platform/4.10/virt/virtual_machines/virt-installing-virtio-drivers-on-new-windows-vm.html) and [Installing VirtIO driver on an existing Windows virtual machine](https://docs.openshift.com/container-platform/4.10/virt/virtual_machines/virt-installing-virtio-drivers-on-existing-windows-vm.html).

## Which drivers I need to install?

There are usually up to 8 possible devices that are required to run
Windows smoothly in a virtualized environment. KubeVirt currently
supports only:

- **viostor**, the block driver, applies to SCSI Controller in the
    Other devices group.

- **viorng**, the entropy source driver, applies to PCI Device in the
    Other devices group.

- **NetKVM**, the network driver, applies to Ethernet Controller in
    the Other devices group. Available only if a virtio NIC is
    configured.

Other virtio drivers, that exists and might be supported in the future:

- Balloon, the balloon driver, applies to PCI Device in the Other
    devices group

- vioserial, the paravirtual serial driver, applies to PCI Simple
    Communications Controller in the Other devices group.

- vioscsi, the SCSI block driver, applies to SCSI Controller in the
    Other devices group.

- qemupciserial, the emulated PCI serial driver, applies to PCI Serial
    Port in the Other devices group.

- qxl, the paravirtual video driver, applied to Microsoft Basic
    Display Adapter in the Display adapters group.

- pvpanic, the paravirtual panic driver, applies to Unknown device in
    the Other devices group.

> **Note**
>
> Some drivers are required in the installation phase. When you are
> installing Windows onto the virtio block storage you have to provide
> an appropriate virtio driver. Namely, choose viostor driver for your
> version of Microsoft Windows, eg. does not install XP driver when you
> run Windows 10.
>
> Other drivers can be installed after the successful windows
> installation. Again, please install only drivers matching your Windows
> version.

### How to install during Windows install?

To install drivers before the Windows starts its install, make sure you
have virtio-win package attached to your VirtualMachine as SATA CD-ROM.
In the Windows installation, choose advanced install and load driver.
Then please navigate to loaded Virtio CD-ROM and install one of viostor
or vioscsi, depending on whichever you have set up.

Step by step screenshots:

![Windows install](../assets/virtio_custom_install_0.png)

![Custom install](../assets/virtio_custom_install_1.png)

![Disk install](../assets/virtio_custom_install_2.png)

![Choose medium](../assets/virtio_custom_install_3.png)

![Choose driver](../assets/virtio_custom_install_4.png)

![Continue install](../assets/virtio_custom_install_5.png)

### How to install after Windows install?

After windows install, please go to [Device
Manager](https://support.microsoft.com/en-us/help/4026149/windows-open-device-manager).
There you should see undetected devices in "available devices" section.
You can install virtio drivers one by one going through this list.

![Unknown devices](../assets/virtio_driver_install_0.png)

![Select driver by id](../assets/virtio_driver_install_1.png)

![Install driver](../assets/virtio_driver_install_2.png)

![Driver installed](../assets/virtio_driver_install_3.png)

For more details on how to choose a proper driver and how to install the
driver, please refer to the [Windows Guest Virtual Machines on Red Hat
Enterprise Linux 7](https://access.redhat.com/articles/2470791).

## How to obtain virtio drivers?

The virtio Windows drivers are distributed in a form of
[containerDisk](./disks_and_volumes.md#containerdisk),
which can be simply mounted to the VirtualMachine. The container image,
containing the disk is located at:
<https://quay.io/repository/kubevirt/virtio-container-disk?tab=tags> and the image
be pulled as any other docker container:

    docker pull quay.io/kubevirt/virtio-container-disk

However, pulling image manually is not required, it will be downloaded
if not present by Kubernetes when deploying VirtualMachine.

## Attaching to VirtualMachine

KubeVirt distributes virtio drivers for Microsoft Windows in a form of
container disk. The package contains the virtio drivers and QEMU guest
agent. The disk was tested on Microsoft Windows Server 2012. Supported
Windows version is XP and up.

The package is intended to be used as CD-ROM attached to the virtual
machine with Microsoft Windows. It can be used as SATA CDROM during
install phase or to provide drivers in an existing Windows installation.

Attaching the virtio-win package can be done simply by adding
ContainerDisk to you VirtualMachine.

    spec:
      domain:
        devices:
          disks:
            - name: virtiocontainerdisk
              # Any other disk you want to use, must go before virtioContainerDisk.
              # KubeVirt boots from disks in order ther are defined.
              # Therefore virtioContainerDisk, must be after bootable disk.
              # Other option is to choose boot order explicitly:
              #  - https://kubevirt.io/api-reference/v0.13.2/definitions.html#_v1_disk
              # NOTE: You either specify bootOrder explicitely or sort the items in
              #       disks. You can not do both at the same time.
              # bootOrder: 2
              cdrom:
                bus: sata
    volumes:
      - containerDisk:
          image: quay.io/kubevirt/virtio-container-disk
        name: virtiocontainerdisk

Once you are done installing virtio drivers, you can remove virtio
container disk by simply removing the disk from yaml specification and
restarting the VirtualMachine.

repository: kubevirt/user-guide

gha_language: Makefile

repo_name: kubevirt/user-guide


text:
# Face-Off

[![Build Status](https://travis-ci.org/excellalabs/face-off.svg?branch=master)](https://travis-ci.org/excellalabs/face-off)
[![Coverage Status](https://coveralls.io/repos/github/excellalabs/face-off/badge.svg?branch=master)](https://coveralls.io/github/excellalabs/face-off?branch=master)

=======================

A Yammer/Django Application application built for the gamification of learning the names of your fellow colleagues.
One difficult part of joining a new company is putting names to faces. Utilizing Yammer OAuth, this webapp can make the learning process more fun.

# Quick-Start Guide
-----
### 1. Yammer Client Application
* [Register An App With Yammer](https://developer.yammer.com/v1.0/docs/app-registration)
* **Note** the Redirect URI & Javascript Origins field
    * Dev:
        * Redirect URI - `http://localhost:8111/complete/yammer/`
        * Javascript Origins - `http://localhost:8111`
    * Production:
        * replace dev fields with respective hostname
    * Once you register, you'll receive a `Client ID` and `Client Secret`. Copy these keys, as you'll need to plug them into your application settings.

### 2. Development Environment Setup
* Clone this repo
* Copy `face_off/settings/local.py.example` to `face_off/settings/local.py`
* Add your keys (created in step 1) to `face_off/settings/local.py`
* Install [Vagrant](https://www.vagrantup.com/) and [Virtualbox](https://www.virtualbox.org/)
* Initialize the vagrant box - `vagrant up`
* Log into the server - `vagrant ssh`
* Create a super user using the command `python manage.py createsuperuser`
* Install & Start [Redis Cache server](http://redis.io/) prior in a separate shell - `redis-server`
* Launch the app - `python manage.py runserver <IP_ADDRESS>:8000`
* Access the app in your browser - `http://localhost:8111`

### 3. Heroku Deployment (Optional)
---
**Required Items**
* Redis Server
* AWS Bucket
* Postgres Server

--------------
####Steps
* `heroku create {appName}`
* `heroku config:add BUILDPACK_URL=https://github.com/ddollar/heroku-buildpack-multi.git`
* `git push heroku master`
* `heroku addons:add heroku-postgresql`
* Create a [RedisToGo](https://redistogo.com) account
    * `heroku addons:add redistogo`
    * `heroku config:add REDISTOGO_URL={instanceName}`
        *  i.e instanceName = redis://redistogo:xxxx@test.redistogo.com:10355/
* Create an [AWS account](http://aws.amazon.com/s3/) to have access to an [AWS Bucket](http://docs.aws.amazon.com/AmazonS3/latest/gsg/CreatingABucket.html)
    * Create environment variables specific for the created aws bucket:
        *  AWS_ACCESS_KEY_ID
        *  AWS_SECRET_ACCESS_KEY
        *  AWS_STORAGE_BUCKET_NAME
* `heroku ps:scale web=1`
* `heroku run python manage.py syncdb`

####**Required Environment Variables Checklist**

|Environmental Variable Name|Value (example)|
|---------------------------|:-------------:|
|SOCIAL_AUTH_YAMMER_KEY|xxxxxxx|
|SOCIAL_AUTH_YAMMER_SECRET|xxxxxxx|
|NPM_CONFIG_PRODUCTION|true|
|DJANGO_SETTINGS_MODULE|face_off.settings.production|
|REDISTOGO_URL|redis://redistogo:xxxx@test.redistogo.com:10355/|
|AWS_ACCESS_KEY_ID|xxxx|
|AWS_SECRET_ACCESS_KEY|xxxx|
|AWS_STORAGE_BUCKET_NAME|xxx-bucket|

## Tests
---
### Unit Tests
* Load test fixture data `./manage.py loaddata "core/fixtures/core-test.json"`
    * Applying fixtures pushes pre-populated data into your application.
* Run unit-tests - `python manage.py test`

#### Selenium Tests w/ Behave
* start behave instance - `behave core/features`

## Data Stored
* Yammer related Data
    * First Name
    * Last Name
    * Email
    * Yammer profile page link
    * Network Name


text:
---
layout: issue-1
title: Studies in Whatevernessless
author: graveolens
author_links:
    '@graveolens': https://twitter.com/graveolens
    'youtube: diproton': https://www.youtube.com/user/diproton/
---

***Editor's note:** This piece is described by the author as a work of "keyboard play". The author used two esoteric keyboard layouts, "karovd" (mirrored [dvorak](https://en.wikipedia.org/wiki/Dvorak_keyboard_layout)) and "poiuyt" (mirrored [qwerty](https://en.wikipedia.org/wiki/QWERTY)), to type the piece from scratch. The author also provided [this repo](https://github.com/graveolensa/thallassophrenomai) with the layout files.*
{: style="font-size: 12px;" }

smectic sprucing generalizing countryside abutments charging centralist

tendencies to isostatic resplendences or calcium muttering recollections

pondering pneumismatic ichneumon motilities or calcifications drifting

tenon tensioning generic chapterplane mpemba acrochordon notorious

pluckingly plectrum mothballing entropy spraying nominative vaporous

tension or mafic chinook kinestheticos to attempt dullly atrociously

silently symbolically arbitrary mutant star goat garnet decor,

avuncular unguent umbrage postsnarky genuflectional parturition

centromere tuning forgetful spasmodic medullary tension to restate

utter moduli space reperfusion or tendentious reminders to clavier

bakelite atropine clocking samarium pastry scholasticism mutterin

tension frond rebarbative vinculum mortalizing gneiss sopresata

accumulation repairing horocontenxt ablution engineering stromatalite

oxidation cleverly told domicile practicalities auscultation frond

notional cleavage or disorganized grapefruit fumaroles quaking

sententious or seditions albumen or clocking stereotactic

cnidarian ctenophore for chthonic acceleration rheophore appropriations

monumentalist schlage or surprising dentition retuning morose mechanical

meleleuca, a driftwood perplexification, dromes and drones in

coffee fenestrata, some marker or detail lachrymose and copacetic,

bathed in bricolage, to entangle, to fend, some febrile feckless

snarklarking scythean sisipheian ziziphus skylarking monodromy,

monodromio, abstractioning glyph rheophore candelabra some custard

relapsing repairing border stability amplified crustose merriment

provoking great alarum, a la alacrity refocusing normative,

prescriptions to circular impressions, a copal opal, a typeless

typhimurium, lostwithiel, accordion concordance disunities

retroreflecting evident station or abraded countryspallation,

quandaries, darmstadt, diligent terpsichorean antherism, asterisms

relay ichor or pungent punctualities, by the river, rife with

meritorious bombast, ripe with the squalene intermediaries or

laminated practical catastrophe phentermine adulations and

adumbrations, merit to manifent to persimmon bona fide flashy

apparatus consuming morraine nonads, orpiment clerestory forges,

fortify the flamingo, carotene surplus bovine verificationalist

stampedes bridging striations or plactic monoidal loopback

attenuation over capstone and signature fronds whew, whereas

the chatty lime mimes, and totes tomes. Critical

opalescence duress to durable promontory refrigeration,

flecks of irritated mud borne in on cackling glabrous chemistries,

abrupt piscine imagos, intaglio madrigal frittilary porch

penchants absquatulated mustard chimingly meretricious

and or vomitorious malfeasances aching, daisy stellation

foraminifera accellerating nickel plated chromium inserts or

vacuum vapor deposition, somnolescenct molecular beam

epitaxies, anoxic coteries of citationalist stimulation

magnify accumulation chem, chamfered grievingly vapor

rambunctiously stateless erratic cimetrodon dormition,

scalene, slippery, pachelbel priory priorly parlay vous

a la Snan Snangelcisco, summatory yesterday actioneering

gravid choriocytoma, nonlinearizing gematria capping

ventricular revestibulations, the kinesthetic clementine

acklins to umbrage, extents, echologue to refind, spines, spar,

fickle contractual misnavigation affricate sorghum

mundial proactive vector posit stirrup por favor or

for gator favorites flavorites, sprainingly gensyms

fromage monocle chess stemming centralist symbologies

accrete wood, frighten interior decor, yell postulatums

and old possum's bloke of impracticable cats, smaller,

Culloden, Strathcona, Invercargill, articulatory

circulatory sarcomere copacetic bricolage or the

complementary Western Civilization's lost it again!

uncial respective vomeronasal vehemences, cementing

galactosidase abridgements, tonorous, sonorous

',.lrcgfyp/=\\

snthdiueoa-

;zvwmbxkjq

allowing the laboratory frame fraught, aorist tensions

bedeckants or spirited cocycle coccidiosis in the

cocina, cocooning fenestral or cadastral spans,

afferent aqueous slipping famishingly underengineered,

fascinating patellar or phenomenological lastly,

psoriasis, reperfision or tare a positional itinerant

tsallis appellation surrounding gypsum moccasin

nagging free energy proclivities surrounding iatrophore

ecliptic anopheles or striational pandimensional

lavishingly labrador omerta or orestes, or oresme with

the disme, dismal disme, san dimas, pausing

intermediate dynamism merriment testy ebulliences

extrusion application, plated denaturing immersive

espadrilles, aconitate essent, aggregate opposition

aggressive parturition psilofuturist mythopoeiome

affective asperities supporting loquacious and

azeotropically discontiguous innovation for

topologically nontrivial invitations accusative

pasta anther lovings, prudent tentacular ranitidine

some flaxseed dimming establishing pruning facultative

aspersions to inspire to respire tn perspire to

Senegal, no potato seven potato five potato nine potato,

psittacosis, K'Veer, juxtapose contrariwise slick

kapton orbital lamellar rostrum lamina, algorithmic

cup product apollo stellate enchiridion stemming

gaspra geminga allotment testy pyrolisk kasteborous,

acclimating terrestrial lapland hierarchicalizing

foveal foliations snappy snood distancing gorgeous

saltpeter framework filigree accompaniment tomographical

pinion otter respighi animated demersal so dismal

packet savvy yesterday alignment overlapping

gurning falteringly pastoral or oxidative repression

subsampling tocatta alpha adsorbing allee escutcheon,

scalene promontories accents stentorian classical

lanthanum mystique compassinate electrically parsimonious

slippery contrivances slaloming gyrating fenestrations

or lithiated destinies, alas, spume contrails in a gunky

reexpression technical addendum missing the point tepid

tapir raster clancies sopping wet teffa agglutinative,

augmenting adhesive concord desultories allantoin

',.lrcgfyp/=\\

snthdiueoa-

;zvwmbxkjq

jentacular qualities sopresata ancillary cirrus sphagnum

montana archibald draping dapper stanchions, anopheles,

effecting glassy pallid droning garrulous swoffordships,

apparent tefillen, appreciation fencing generic clapping,

zymurgist stole eoan nabbing namaskar raster congruences

forward derechos, placating snooping gallimimus satraps

rewarding gneiss saltpeter respiration underfoot topology

assurbanipal laredo operculum musty colonnades sprinting

gaggles ol penchant temerities in timorous convalescnt

testudinate allotments particular entrances sparser than

napthalene fricasse or other adornments, rapid lapidaries

onerous sapling geriatrics sobrieties of somnolescent

semolina oppressing operatic oyster ras, adding

goniochromatic aposematism moccasin systolic psilopartition

or thematic redress sanctification or loquacious

dromedaries or the willowy millet of mallet trams,

transoms or cemetary cendances, ceterisms and asterisms

immoderately anthem, meristematicocracy to feedline

Nova Scotia advantages to simulated alluvial fecundities,

lochlan nacirema asthenospherical languishing or

prolegomena to mapmaking stents, or another careless

elevator topoisomerase irritatingly anechoic

decompositions ulterior rascal lastly troubling

satieties passing fenestratorial or sartorial

disaffinities and dissaffectation, or more concretery

disinterest for the shekel lining event driven

rerailing passive osteological saprophytes or

aggressive vestibular randomness safrole, monday

yendred alluringly ingress supposing fantabulous

athenian nacreous horizons activating esters and

aggressive standardization froward in

deterministic development tiling striations beckon

nobilities to cascade epistratus, stationary

rachis bombardment listlessly acorn nematic liquid

crystal lintel prolapsing plopping propositional

parakeet orthokeet tisdale some persuasive mint

condition conifers sapphire quavering activationalist

lastly atelier ranunculoid prorogued assurbanipal

lachesis or lachrymoseying saccades, sachet

alloforms accrete oleaginous sorrell solecismatic

artiodactyl lenticular raccoons, slippery river

',.lrcgfyp/=\\

snthdiueoa-

;zvwmbxkjq

quickly serene, affordance steps syllogism

or peremptory facillitater-tots, egregious

pinning gappy isoclines asunder resuscitatingly

and reassuringly nonportable periphrastic abomasum

or flan ahimsa autonomically praseodymium moping

fan shaped dentition pasting pungent tassel

factory razing gelled dapple sparsities trod and

shod traditionalist normalizations appearing

phosphorescent tape sunrise accellerating

corolla inquisitive apple stenosis raffle plinth

spallation quenching lateral cellulase debalkanization

or enfolded coroplast stampede of desultory ochreous

sinter cast mold dalliances separations slow

and dependent taste receptors rerouting degaussing

trifecta agrumes spelling appalling sparring

garrulous and cantankerous sapphicities, glamorous

spirited denatured despondencies salps occurring

ruminatingly rustless listless sonorous soporific

somnabulist, somnolescent sonoluminescence,

assure francium mechanicalizing voracious clamato

questioning fencepost stanine glossary pinching fantastic

celeriac comestible elspeth sepal palette schematic

clammy panting gypsum morning pruning gnostic or

gnomonic compasses, serrated selecta, compacta,

composita, allergic spanning gesso surfaces positing

functorial lamella or Tocatta, massless prideless

acanthus safflower restitution fleeing canyon

stratigraphies foliatingly morose ambiguous deamplification

or ranchy, raunchy, dewar urticaria poriferous

manuscript tomographical listlessly wistful dromedary

pheremones retelling antimatter recollection or

normative eccentricities more immediately notable

contrivances reselect stents, tenons, occidental

lastly tonorities respiratingly annunciator repainting

repositioning quiescent template deinonychus scalene

scintilla remapping presumptuous barometric considerations

for derailed oppositional lastly lanthanide extrusions

transformations styling persistent stampeding stabilities

encoding intrinsic clerestory kernel licentiousness to

lastly parametrize affective voracious subshale

stochastic liniment trapezoidality arrestingly

nonobvious relaxation thimble stronger or

composite compartmentalizations relaying or

deamplification essential or socratic castlef

',.lrcgfyp/=\\

snthdiueoa-

;zvwmbxkjq

azeotropic clandestine erratic clapham complex projective

entombed dalliances pore bearing stiction aorist

oblate or obligate endorsements endomorphisms atropine

et ceterist tabernaculum mopt departmental stratigraphies

splanchic cermet tessellation transference establishing

concrete convincing demonstrated dynamic clan, twinning

bolide tomographies deportment tension doppelganger

rapscallion or turgid abundances pareidoliac cagey

caftan hybridomas spawning egregious sponsorship

agreements or plectra, aigrettes, directory tension

nomenclature clathrate magnification strobing pasta pasttimes

sonnet teichanopsia calques, hapax legolas, homologies,

raspy aluminium mesophyll, pharyngula, ecliptic tarmac

canula, kandinsky, epaulets, sinigrin, testy toasty

aorist atelier accidental propositional asthenes waking

baking geriatric clon clover tepid dynamism or passive

armamentarium moistening us, allantoin, orpiment, some

wheezy sidereal pruning gesso offering smilodon import

arena arete covariant convalescence splaying garnet

testy apparatus stationery ink spectres, appomatox

inchhorn catalecticant irid drift-attenuant tent stake

smaragd-trappist stent, conglomerate, aggregate,

accretant, aorta, plop, rhythmic sintering antibody

yesterday aporia scar scabrous benthos bonito benthic

allergic ctenosis, magpie edentune frothy fractionated

demurring decry damsel sestina amorous amoled deleterious

and riotous, fasting eclosion eclair establishing

gorging cantellated fantabulous shining principal

fortifications vouchsafe cornucopia, fancies cotyledons,

strictures bolder wallaby, sartre, comparison stalactite

arrow dispersion raffia accelleration spittal, celestial

bonhomie missives, withering ebullient toasty

anthem acumen for a wiry alligator renovation, innovation,

systemic sarsparilla atonal lazily interrogate the

mean opprobrium, selecta apositionalizing, Interior

collagen smectic arrivals to provide detuning,

magnanimous scleral neutrino echoes, traipses to the

footbridge, spilling uncorrellated inventory abruptness,

inapposite, apostate, acrimonious acrylica, accidental

affectation smiling drams urticaria access nightmarish

pencil fiber tremolo szechuan naxas,

',.lrcgfyp/=\\

snthdiueoa-

;zvwmbxkjq

jasper copal centralising feldspar insufficiencies planimetric

alcantara bespin nomostratigraphies sylleptic chanson hemostatic

alcohol lessening generating dalliances sephardic cholesky

factorization erratic plosive venial lastly aubergine hypothesis

or hypnotic eluctable eccentricities salps or conifer repairing

offerring poncho picnic cypra adorable erratic clinicalizing

atrocious samarium mnemosyne ephemeral lichen starry vantages

solely virtuous portentous troubadours sententious revising

clay straw amersham mantle espadrilles or foliatory pnictide

panels in frosty contrivances subsample subaltern nematode,

mirroring terroirific climatological lamentation or bolide

sparser frugal laser ringing perforating cavitation aspiration

quiescent temerities sleeping gneiss palomino strobing

pneumatic cistern approval or celerities shaken mainly

plectral competences sadly like interior meringue, the

feckless mordants or transition metal malarkey alhambral

some particular strain of bacteriophage mar wan licentiousness,

arraying diffidences in a plastic, foamy, wooden phosphorescence

in linear monadic dulcimer duplicitous ishtar rama, spying

spiny spinels, alongside spinor mulches and draping fantasist

tlaloc marimba stone scrutables like a passive vestibule or some

gazebo massive verging on conestoga apparitions avowing azure

averring meteoric salt tephra abominable neutrino osprey

jaunty vaulted varve evincing cumin nacreous placating

artiodactyl erroneous lorimar ancillary yesterday application

or mammal solfege like rinse-capstan-timbre estabishing

aberrant stirrup pemmican foundry pelagic cloning rascal

authorisation saponins less honorifics scant topological

taproot significances arrestingly pensive charybdis snooping

ictal laziness spry fenestratory acumen may eccentricise

roomy and lunatic occultists somniferous pimento tasty

vitalities apprehensively uffable orca alterities to

offering lapidary remonstrances or xeroacoustic affinities

allagash radagast stammering sorely vanishingly allure

rotates semantic pungencies socratic templating tomfoolery

like recondite and unconcerningly unamplifiable fallible

monotone central tinting galway yammering testy ferences

or punchline atropine stewardsheep passing garrulous,

possibly insane or obscene enteric clinamen radiolarian

namaskar ramirez zentropist starringly anechoic cassowaries

specialization or erring inimitably anoxic culminating astral

conker conway conveniences selachii impressionist stimulation

or yearsong gallimimus sestina promissory motionless sarsparilla

anodyne encabulatingly inferences wisecracking and dancing

gestational interlude or interrupting passive excruciatingly

nonobvious bypassing panniers or solfege listlessness

in practical all honker rigid deslunacies annealing

ataxic celestine monetization aggressive winnowing gesso ostrich

hypotenuse recollecting generalizations for striated

azide prolixities rotating argabuthon natrium mesothelioma

apparent or nonconditional seldom maintaining gassy emoluments

or sidecar attentionalites sapping bunching garrison

clonmult testy censorship psittacosis banal lastly

fecundities relaying stringent tenebral lagging protracted

scansion notional redress spelling kakistonomic plenitude

or anopheles discongruities centrally recencies sudden sullen

shallow wanna aclectic spirulina atorvastatin leading term

ambiguities sensor rappelling anterior parakeet stimulation

ayudarmelo nistral sincerities or other rather more

copacetic interferences mutate or repel slamming generic

cormorant manticore cherishing recent references to madden

to multiplex xenotactic casting limerick kit kinesthetic

magnanimity some retelling graphic artisanal lantern conch

allergic estimation or shunning glaxo bonhomie to abundant taproot

sleepy slippery insight testing glimmerings or basking otolithic

cicada axolotl amelioration starring patterning juncture

arrangement saturnine or sanguine sang-fraidy froody

intercalation snappy yellowing garnet testing

tinting astringent tepid dentalizing injurious sabetta

siltingly eccentrica atropine enstrophies micellar

or incessant tannin auror rarefaction stilling

momentous lunar ratio wisteria accolade nightmarish

gaetano gastrointestinal rotation roaring pemmican pectin

silting gopalan naming enacting generic smilodon nether

exciton nary a zany narwhal linting remnant orrery yelling

enol enormous spry quill sperry rand organizational

missteps setae ratification or secular perturbation

panicking gothic chums or chutney annunciator restoring

clementine oxidative erratic atal tepid tapir raster

lessening aconitate acroplankton accelleratingly composite

carbon

sparser than linear compositionality to redress foveal mismatches,

aye, the station snorted in demurring or demure recompense,

glittering embankments discarded cavalcades of sensitive,

cloaca, adornment muttering rehoboth magisterial comeuppance

or secondary pauses, pastoral laterality egressional splay,

like the silt or the salt should brocaded famished famine

relay percolation mafic tendencies you may readress the salt

tarmac should notable capstans restate shallow questions or sidereal

attunements breaking protracted clemencies to practical concerns, sherbet

succotash reminder unguent suppuruated puck punctual lantern eclosion

or the ventral captains of the understudy, the relational sulfurous

mountains like clerestory conditionals, relaying undertrodden

morphological decompostions or decontamination the reedy problemtic

xeroxylopheres retuning quiescent saliences timorous broth offering

other scalene oer copacetic in the marginal spondulickry to decry the

latent nascent ventral venial venous arteriole random ramification

provoking spirited declination or montane repairs to relapse chaotic

parturition, parthenogenetic dilly-dallying gentle gerontocrat might

victuals or claimants in partial station to utter sanguine and saturnine

composites, preferentially leading astray the miffed or mellifluent

tensions or sorghum or hearty durum heated debate acheing in corpuscular

tarmac macaddams lithiations repairing monolateral pecorino becalming

lenticular redress of grievances or other satraps abundances or

portable notional monumentalisms for scalar pensives or rather other

mustard commutatives, like jewelled adornments or plaid stereoscopies

or folded towel day diffeomorphisms relying on utter resampling scansion

station orrery necessity licentiousness irritating generic organizational

relationships orotic translational adumbrations sidle programmatically

abundant or spatial anisotropies rescaling nephrological consorts or the

acumen splaying spallational accordion nightmare relationships or

calming involuntary involutional inoculatory respawning tomographic

ecological disagreement in furtive cemented disarticulations or

disfluencies rescaling armamentaria for affricate argyll invariants to

prepared bibliographic excess or tonorous or sonorous timbral

scullion necessitating argumentaria some lariat the principled

doublet taming scleral sinigrin, repeating off-shored template summons

selecta, antonym prescription peremptory or peroratorio, the fineries

disabuse stale concentration or congressionalist instabilities to fond

or frayed scintillations, the absurd mirages rarefacting tension eigenwildebeest session promontory grackle tuning sickle corner union placating placard

stirring gaffe auxillary composites straying genteel pendragon moieties

bridging acaulescent temerities aforethought some drifty galactic barge

withdrawing somniloquy arborescences retuning bent temerities some

drab liniment or lawn ornament recalling topologically protected edge

modes edge mofos, sestina nimitz bravura extremadura composite

withdrawn periphrastic attennuation lacquering corralling laminated

taxon stanines or stercum to requisite largesse, fenestral larder,

the plenipotentiary arguments rescaling lemongrass tenon squirrel

prefontaine ochre or unbecoming lessenning geriatric centralizing

orpiment or annealing seams rebranding broadcast speleothems or railing

for portable murgatroyd fancies, some western interlude conserving

versimilitude, vicissitudes, cermet recentralization like boron in

a strange oxidation state, mutable metaphor or recast anaphors in amphorae

spirited repositioning stalling glossy copy, retellings by mustard

bearded bards to accomplish the unguent refrosting of life,

the universe, and everything, well aren't you a chatty normal mode

arbogast, the horticultural gardens in the proximity of Veraffo-Crunzayre,

or a motta from Maatuweyon, on, belayed periphrastic peroxidases

or plenary artiodactyl determinants resplending or languourous

laborous labor intensive redefinitions meristemocracy, mellifluent

peduncle lenticular arrighi, a fiducial contemporaneously order

of reexpression or notional discontiguities whereon nostril censure

would not parlay contrariana, les puyods, whatever Ebenezer Sensprutt

wasn't bemoaning or editorializing in the Gravy Regions, your collection

of weeds requires at least a ruminant or eighteen litres of triflic acid

to cope with and aren't we a smarmy snarky institutional review board

who is being accosted by aliens who are ridiculous rule followers and who

have paid off all the debts of the members of the irb so that they

can procede with their [hideous experiments on most but not all of

Denver]

aggregate tamofixen or accellerating germane slithering foamy

patterns renovating erected edifices old droning fallacies

in respecified denaturing gossamer pensive farcasting perceptive

fantomas steles scattering gosling bureaucracies squalene enterobacter

glossy yesterday laborious parities maintaining generic quisling

monthly onerous socorro horn nematode priory recreational planning

temerities favoring stepped and stellations, grim mensuration

aggressive agglomerations or strivingly periplasmic ondatsetron

nomenclatures restorative vestibule, cloistering monastic

chemistries reappraise or reallocate stirrup contrail

evaporative unprincipled demagogues reallocating gensym

coriander assemblages to constrain hepcat hepa flitter clutter

clue stronger javelin intaglio oleaginous shushing nomoserratus

composites replaying controversial lastly coda aster slamming

spastic chelonian nacreous slippery details or ventral scanning

under dimension slop, the derivation bridges serrations,

localizing ecliptic centurion namaskar adelaide adieu attometer

or metrical cones, sanguine esposito apposite deponent thallassemia

acroscale allende elated darmstadt telegraphical apparatus to yield

durable cocoa, cacophanations or utter cavitating transparencies

yelling stoma stationary smarmy propositional lanters augmentation

to pensive elliptic ctenophorgery, zentra-lentra, amoled

procrusteanists occurring generic clamato pet scan repercussions

in mond, pleural snappy motile seabed itinerant gassy weathering

aggressive kernel sumpsimus slogging through mala tensor formulations

or slim mensurations gessn slanted degradei derechos ostend

hoverport activating undernostrilled gorses, horologist stalactite

enhancing already treacherous conditions aether placation gestational

gamboge polity onerous slaloming kestrel loquacious samarium mechanistic

accessory yellow stingray prowess selecting gentle plasmonic

juddering semiotic filtering sullen menthol lomanaco ulterior

rouges essential lamprey yarrow oracle phoneme phenomenon reassign

problematic castle staggering munitions northern stiligrafica

allotment parade settings repadding fez cradle gesso restoration

to posit stemming glassy chest stampeding fitness or another

manner another annotation pellicle serendipitous regarding

listless pirahna sentimentalities it's all layered dental laredn

multipliers the wacky terroires punchy plectrum mesa allogracile

silent invocation atoll stentorian interludes especially esperanza

anobligatory pram, practical simulation sonorous ragged semantic

carnation imitating generic clabby acrolect tension to author

voluminous restraint tent poncho glaive grievances or

mall plastic tensioning gerrymandering positive western

nicitating membranes or pausing troubling eoan gespiro

lemniscate ellipses

apparent tentacular tetralapse goggling dishotelier disharmoniously

yes, myst setae storming redactingly localizations discozens

snappy ellision restoring gneiss lichen actor remainder tensions

ebulliences oh favored disgruntlingly amoxicillin terre haute

scholastic tensions micellar mutations relative vestry tensioning

graphical stylistic amortizing gyrating grandiose enol lozenge stalling

motile certitude bolder effortless prancing station fallacious

folding slowly recasting mutation into calmer territories ageless

reliances and demented ropy lopsided porosities recalling

elementalist staggering Staccato gleaming kestrel relationship

perestroika westron muttered dehiscent ahimsa automatically

centralizing ferruginious spasmodic clementine notional ominous

neutrino thermohaline endorsement suggesting ruminatingly

unruncinated stopgap managing steradian classificationalist

steam driven automata establishing substrate corrigenda

austerities or auspicious candelabra contentiousness replicating

exaggeratingly unmemorable striations or palaver laboratory

onerous contention recalculating combine combinatorial

sparsities reiterating and redecorating stimulating conversations

alas snippy enol lichen lecithinage or smarmier ventral

behemoths actualizing soggr propeller stunnung iatrogenic

selections sallow and wan nociception elation and famine, crispy

centralising cementing mapping

repository: spitz-dan-l/somnotica

repo_name: spitz-dan-l/somnotica


text:
# labcore

labcore contains essential tools for running experiments.

For installing, use a developer pip install:
```
pip install --no-deps -e /folder/to/labcore/
```


text:
---
layout: doc

title: Chronology
description: In hac habitasse platea dictumst. Curabitur scelerisque justo vitae nunc ultrices.
image:
---

# Chronology

## The origin

-ToDo-

## Milestones

### 'Placidus' version

![Placidus][Placidus]

The first stable release, codename *Placidus*, was launched in November 2014 to be hardily tested during the *[OSHWDEM A Coruña 2014][OSH01]* with every child who visited us in the event. Every Escornabot was kept in one piece after 2 intensive days playing with the children (and also with some aged people :)

This version mounted the first and second chassis models, both of them with the motor-driver boards at right and left sides and the button set on the top. The first Bluetooth interface was implemented in this version and it could be controlled sending text lines describing movement commands with an *Android Bluetooth terminal* app.

### 'Brivoi' version

![Brivoi][Brivoi]

It was launched on the [*Streets Science Day*][SCI01] in May 2015. The new chassis design is more compact reducing the plastic and printing time down to 50%. It incorporates the concept of modular hardware to join the parts with brackets to the electronics, batteries and other optional modules. Another interesting feature, due to its small size, is the possibility to make turns in square cells of 10cm x 10cm.

The firmware is able to detect long key press and doubling the functions for keypad, introduces the pause command and the code is simplified to allow extend the Escornabot behaviour easily.

Specific hardware boards were designed: the _Escornaboard_ integrating the Arduino Nano, a controller for two stepper motors, the buzzer and other useful connectors and switches in a 5cm x 5cm board; the _Escornashield Keypad_ simplifying the construction of the keypad and, an _Arduino Shield_ ready to connect to Arduino Uno/Mega

---------

[OSH01]: http://oshwdem.org/2014/11/se-acabo-pulpo/
[SCI01]: http://www.amigoscc.es/agend/?calendar_day=2015-05-09

<!-- Images -->
[Placidus]: https://escornabot.com/web/sites/default/files/node_attachs/placidus.jpg
[Brivoi]: https://escornabot.com/web/sites/default/files/node_attachs/brivoi.jpg

repository: escornabot/website

gha_language: CSS

repo_name: escornabot/website