text:
# @swim/dataflow

[![package](https://img.shields.io/npm/v/@swim/structure.svg)](https://www.npmjs.com/package/@swim/dataflow)
[![documentation](https://img.shields.io/badge/doc-TypeDoc-blue.svg)](http://docs.swim.ai/js/latest/modules/_swim_dataflow.html)
[![chat](https://img.shields.io/badge/chat-Gitter-green.svg)](https://gitter.im/swimos/community)

`@swim/dataflow` implements a compiler from
[`@swim/structure`](https://www.npmjs.com/package/@swim/structure) selectors,
operators, and functions, to continuously updated data structures driven by
[`@swim/streamlet`](https://www.npmjs.com/package/@swim/streamlet) dataflow
graphs.  `@swim/dataflow` turns dynamic data structures into living documents.
`@swim/dataflow` is written in TypeScript, but can be used from either
TypeScript or JavaScript.  `@swim/dataflow` is part of the
[`@swim/core`](https://www.npmjs.com/package/@swim/core) framework.

## Overview

A live updated data structure is represented as a `RecordScope`, which extends
`Record` from `@swim/structure`.  An ordinary `Record` can be recursively
compiled into a `RecordScope` by invoking the `RecordScope.from` factory method.
A compiled `RecordScope` has all of its nested expressions replaced by their
evaluated state.  But unlike evaluating a `Record` with an `Interpreter`, if a
member of a `RecordScope` changes, all expressions that transitively depend on
that member get flagged for recomputation, which occurs the next time
`reconcileInput` gets invoked on the `RecordScope`.

The `Dataflow.compile` method can also be used to compile an arbitrary
`@swim/structure` expression into an `Outlet` that updates whenever the state
of any of its transitively dependend expressions changes.

## Installation

### npm

For an npm-managed project, `npm install @swim/dataflow` to
make it a dependency. TypeScript sources will be installed into
`node_modules/@swim/dataflow/main`. Transpiled JavaScript and TypeScript
definition files install into `node_modules/@swim/dataflow/lib/main`.
And a pre-built UMD script can be found in
<EMAIL_ADDRESS>
### Browser

Browser applications can load `swim-core.js`, which comes bundled with the
`@swim/dataflow` library, directly from the Swim CDN.

```html
<script src="https://cdn.swim.ai/js/latest/swim-core.js"></script>
```

Alternatively, the standalone `swim-system.js` script may be loaded
from the Swim CDN, which bundles `@swim/dataflow` along with all other
[`@swim/system`](https://www.npmjs.com/package/@swim/system) libraries.

```html
<script src="https://cdn.swim.ai/js/latest/swim-system.js"></script>
```

## Usage

### ES6/TypeScript

`@swim/dataflow` can be imported as an ES6 module from TypeScript and other
ES6-compatible environments.

```typescript
import * as dataflow from "@swim/dataflow";
```

### CommonJS/Node.js

`@swim/dataflow` can also be used as a CommonJS module in Node.js applications.

```javascript
var dataflow = require("@swim/dataflow");
```

### Browser

When loaded by a web browser, the `swim-core.js` script adds all
`@swim/dataflow` library exports to the global `swim` namespace.

The `swim-system.js` script also adds all `@swim/dataflow` library exports
to the global `swim` namespace, making it a drop-in replacement for
`swim-core.js` when additional `@swim/system` libraries are needed.

repository: j-shaver/swim

repo_name: j-shaver/swim


text:
# Password Generator

### Credits:
* [Font Awesome](https://fontawesome.com/)
* [Wallpaper](https://wallpapersden.com/desert-sun-day-minimalism-wallpaper/2932x2932/)
* W3schools
* Bootstrap
* Traversy Media Javascript Tutorials

### View My Web App
[Click Here](https://everetthumphreys.github.io/password-generator/)

![Screenshot](https://raw.githubusercontent.com/everetthumphreys/password-generator/master/assets/Screenshot.png)

repository: everetthumphreys/password-generator

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: everetthumphreys/password-generator


text:
---
layout: post
title: Be the Light
description: "Life In Lights gets interactive"
headline: "Community becomes part of the art"
categories:
tags:
  - lifeinlights
  - community
  - art
  - education
image:
  feature: "lifeinlights-logo.png"
comments: false
mathjax: null
#featured: true
published: true
---

>"There is light in the world, and it is us!"
>Eliezer Yudkowsky

**Visit the sidewalks of North Main Street in Downtown Winchester every evening between dusk to 10pm to experience dynamic community-created art and games.**

Life In Lights is excited to debut its second exhibit of community art titled *Be the Light* beginning March 3 on North Main Street in Downtown Winchester. *Be the Light* will feature new community art, including playful and interactive art installations.

The *First Light* exhibit, which continues its current run through Wednesday March 2, showcases vibrant digital artwork produced by local community members as part of Life In Lights and a series of free computer graphics programming workshops titled "Create: By the Numbers".

Life In Lights is a community-focused art, education and livability project with a goal of bringing light and positive engagement with our downtown. It transforms empty downtown storefronts into light based art installations; providing the community opportunities to come together to create and share engaging art.

You are invited to participate in Life In Lights. See [Get Involved](/get-involved), [Workshops](/workshops) to attend an upcoming free workshop or write to us at [lifeinlightswin<EMAIL_ADDRESS>to learn more!


text:
# poipoi

![](https://img.shields.io/github/license/yasukotelin/poi)

poipoi provides to get your project directories command-line tool.

This tool is inspired ghq. Only access function to the project directory!!

> v1 called this tool "poi". v2 recreated by Rust and rename to "poipoi".

## Description

poipoi is selector with fuzzy finder the git projects from specified directory path by poipoi.yml.

The selected path will be standard output.

```poipoi.yml
# projects - you can specify the directories had projects managed by git.
projects:
  - ~/AndroidStudioProjects
  - ~/IdeaProjects
  - ~/source
  - ~/go/src
```

## Installation

```
cargo install poipoi
```

Second, you shoud be put a `~/.config/poipoi/poipoi.yml` setting file.

```poipoi.yml
# projects - you can specify the directories had projects managed by git.
projects:
  - ~/AndroidStudioProjects
  - ~/IdeaProjects
  - ~/source
  - ~/go/src

# others - you can specify the non project directories that are printed as is.
others:
  - ~/.config/nvim
  - ~/.config/poi
```

`projects:` is target the root directory path to search projects.
poipoi will find the git project. And standard output them.

`others:` is target the non project directories that are printed as is.
If you want to include non project directory in your result, specify this.

## Update

```
cargo install -f poipoi
```

## Usage

Just only use `poipoi` command!

### Move project directory

Use poipoi with cd command.

```
> cd $(poipoi)
```

If you use options.

```
> cd $(poipoi --color light)
```

and you define alias, so useful.

```.bashrc
alias poi='cd $(poipoi)'
```

## Cache

```
poipoi cache
```

If you want to launch more quickly, you can use `poipoi cache`.
poipoi search projects and write results to cache file and `poipoi` command use cache file.

Update cache file, you should run `poipoi cache` everytime.

## Options

### Fuzzy finder color

poipoi using fuzzy finder library is [skim](https://github.com/lotabout/skim).

You can use `poipoi --color [skim color option]` and poipoi calls skim with --color option.

Example, if use light background terminal.

```
poipoi --color light
```

and more custom color.

```
poipoi --color=light,fg:232,bg:255,current_bg:116,info:27
```

If you want to more infomation, see [skim readme page](https://github.com/lotabout/skim).

## Height

Change fuzzy finder height. Default height is 30%.

```
poipoi --height 100%
```

## No fuzzy find

If you don't use fuzzy find. `--noskim` option is only output project paths.

```
> poipoi --noskim
```

## With fzf or peco

If you want to use fzf or peco.

```
> poipoi --noskim | fzf
```

## Author

yasukotelin

## Licence

MIT Licence

license: MIT

repository: yasukotelin/poi

gha_language: Rust

gha_license_id: MIT

repo_name: yasukotelin/poi


text:
# Golang docker's 🐨📦🥰

This repository contains Dockerfiles to build docker images based on golang official `alpine` images and includes `git`.

# How can i use those images? 🚧

They are public in the docker container registry, so just search for `golang` and **YouClap**

You can also see them in our [docker hub organization page](https://cloud.docker.com/u/youclap)

# About

With ❤ from [YouClap](https://youclap.tech) [Development team](mailto://development@youclap.tech)

repository: YouClap/golang-docker

repo_name: YouClap/golang-docker


text:
# Spazzy

#### Http high traffic clf log monitor
Spazzy monitors an access-log file being written to by other processes, and prints to the console during times of high traffic, and recovery.

## Usage

Ex:
```js
Spazzy.monitor({
    file: `${__dirname}/test/test-access.log`,
    statsInterval: 1000,
    alertTriggerDuration: 3500,
    alertThresholdPerSecond: 10
});
```

#### Options
- `file` - string - path to the file to monitor
- `statsInterval` - number - output stats every 'statsInterval' milliseconds
- `alertTriggerDuration` - number - time in milliseconds to average traffic over
- `alertThresholdPerSecond` - number - amount of logs per second that are allowed before issuing an alert
- `testMode` - boolean - silence stats output during testing

## Log generator
Useful for testing

See `scripts/start-log-generator` for an example

#### Options
- `file` - string - path to the file to write to
- `script` - [{ amount: number, duration: number }] - will generate logs according to every item in the array in sequence
    - `amount` - amount of logs to generate
    - `duration` - milliseconds to take to write these logs
- `silent` - boolean - don't log anything to the console -- (used in testing)

## Testing
Pull down the project and run `npm install && npm test`

#### Utility npm scripts
- `npm run gen` – will start the log generator, configured at `scripts/start-log-generator`
- `npm run dev` – will start spazzy monitoring, configured at `scripts/start-spazzy`

repository: wswoodruff/spazzy

repo_name: wswoodruff/spazzy


text:
# Laravel Date Scopes

Provides date scopes for Laravel Eloquent models

## Requirements

* Composer
* Laravel or Lumen
* PHP >= 7.1

## Installation

Install composer package
```
composer require codekj/laravel-date-scopes
```

## Usage

Use `DateScopes` trait in model

```
<?php

namespace App;

use CodeKJ\Laravel\Traits\DateScopes\DateScopes;

class User extends Model
{
    use DateScopes;

    /* ... */
}
```

### Methods

> Default date field: `created_at`. All methods can have custom date field parameter, example `today('updated_at')`

| Scope method         | Description                             |
|----------------------|-----------------------------------------|
| `thisSecond()`       | Records in this second                  |
| `lastSecond()`       | Records in last second                  |
| `secondAgo()`        | Records second ago until this moment    |
| `secondsAgo($count)` | Records x seconds ago until this moment |
| `thisMinute()`       | Records in this minute                  |
| `lastMinute()`       | Records in last minute                  |
| `minuteAgo()`        | Records minute ago until this moment    |
| `minutesAgo($count)` | Records x minutes ago until this moment |
| `thisHour()`         | Records in this hour                    |
| `lastHour()`         | Records in last hour                    |
| `hourAgo()`          | Records an hour ago until this moment   |
| `hoursAgo($count)`   | Records x hours ago until this moment   |
| `today()`            | Records today                           |
| `yesterday()`        | Records yesterday                       |
| `dayAgo()`           | Records day ago until this moment       |
| `daysAgo($count)`    | Records x days ago until this moment    |
| `thisWeek()`         | Records this week                       |
| `lastWeek()`         | Records last week                       |
| `weekAgo()`          | Records week ago until this moment      |
| `weeksAgo($count)`   | Records x weeks ago until this moment   |
| `thisMonth()`        | Records this month                      |
| `lastMonth()`        | Records last month                      |
| `monthAgo()`         | Records month ago until this moment     |
| `monthsAgo($count)`  | Records x months ago until this moment  |
| `thisYear()`         | Records this year                       |
| `lastYear()`         | Records last year                       |
| `yearAgo()`          | Records year ago until this moment      |
| `yearsAgo($count)`   | Records x years ago until this moment   |

### Examples

```
// Get records only from today
$todayUsers = User::today()->get();
```
```
// Get records from last minute (previous minute)
// Example: if time is 10:30, you will get records ONLY from 10:29
$lastMinuteUsers = User::lastMinute()->get();
```
```
// Get records from an hour ago until this moment
// Example: if time is 10:30, you will get records from 09:30 until 10:30
$hourAgoUsers = User::hourAgo()->get();
```
```
// Get records from 2 weeks ago until this moment
// Example: if date is 2020-08-30 10:30:00, you will get records from 2020-08-16 10:30:00 until 2020-08-30 10:30:00
$weeksAgoUsers = User::weeksAgo(2)->get();
```

## License

The MIT License (MIT)

repository: superern/laravel-date-scopes

repo_name: superern/laravel-date-scopes


text:
Consul Integration
==================

Send alerts based on [consul](https://www.consul.io/). health checks,
triggered by [consul-alerts](https://github.com/AcalephStorage/consul-alerts)

For help, join [![Slack chat](https://img.shields.io/badge/chat-on%20slack-blue?logo=slack)](https://slack.alerta.dev)

Prerequisites
-------------

Consul and [consul-alerts](https://github.com/AcalephStorage/consul-alerts)
is installed and running.

Installation
------------
    $ pip install python-consul alerta --upgrade
    copy script to somewhere accessible by consul-alerts, make sure its executable

Clone the GitHub repo and run:

    $ python setup.py install

Or, to install remotely from GitHub run:

    $ pip install git+https://github.com/alerta/alerta-contrib.git#subdirectory=integrations/consul

Configuration
-------------

Define these keys in consul KV store:

        consul-alerts/config/notifiers/custom/alerta:<path>/consul-alerta.py
        alerta/apikey:'api-key' // alerta key for api access (MUST)
        alerta/apiurl:'api-url' // alerta api url (MUST)
        alerta/timeout:900 // alarm timeout in alerta (default 900)
        alerta/max_retries:3 // max api call attemps (default 3)
        alerta/sleep:2 // sleep between attemps (default 2)
        alerta/origin:consul // alert origin (default consul)
        alerta/defaultenv:Production // default alert environment (optional - default Production)
        alerta/env/{hostname}:Testing // exceptions for env of specific nodes (optional)
        alerta/alerttype:ConsulAlerts // alert type (default ConsulAlerts)
        consul-alerts/config/notif-profiles/default: { "Interval": 10 } // will keep active alerts "open" in alerta, before timeout removes them (must)

References
----------

  * https://www.consul.io/
  * https://github.com/hashicorp/consul
  * https://github.com/AcalephStorage/consul-alerts

License
-------

Copyright (c) 2016 Marco Supino. Available under the MIT License.

repository: alerta/alerta-contrib

gha_language: Python

repo_name: alerta/alerta-contrib


text:
[![Build Status](https://travis-ci.org/FalconSocial/pre-commit-python-sorter.svg?branch=master)](https://travis-ci.org/FalconSocial/pre-commit-python-sorter)
[![Coverage Status](https://img.shields.io/coveralls/FalconSocial/pre-commit-python-sorter.svg)](https://coveralls.io/r/FalconSocial/pre-commit-python-sorter)

Pre-commit python module sorter
===============================

This is a [pre-commit](https://github.com/pre-commit) hook that will sort your
imports for you (or show you how it should be done).

* [pre-commit](https://github.com/pre-commit)
* [isort](https://github.com/timothycrosley/isort)

Add this to your ``.pre-commit-config.yaml`` file

    - repo: git://github.com/FalconSocial/pre-commit-python-sorter
      sha: 1.0.4
      hooks:
      - id: python-import-sorter
        args: ['--silent-overwrite']

Available flags:

* ``--silent-overwrite``: The hook won't fail if it has to change files. It will
    just do it.
* ``--check-only``: The hook will not change any files.
* ``--diff``: If imports are not ordered correctly, print a diff of required
    changes to fix the import order.

The hook supports [isort's configuration files](https://github.com/timothycrosley/isort#configuring-isort) - Please refer to the isort documentation for reference

Development: ``pip install -r requirements-dev.txt``

Testing: ``py.test --cov pre_commit_hook tests/``

repository: Patreon/pre-commit-python-sorter

repo_name: Patreon/pre-commit-python-sorter


text:
# Search Comparison

## Breadth First Search
*ES: Búsqueda en anchura*

```
          [1]
         /   \
      [2]     [3]
     /   \   /   \
  [4]   [5] [6]  [7]
```

Optimal to find the shortest path?
[x] Yes
[ ] No

Yes because it is always expanding in the shortest paths first. Wherever the goal is hiding, it will find it by examining no longer paths. (In other words, always checks short paths first).

## Cheapest First / Uniform Search

```
          [1]
        5/   \2
      [4]     [2]
    3/   \2  4/   \2
  [7]   [6] [5]   [3]
```

Optimal to find the shortest path?
[x] Yes
[ ] No

## Depth First Search
*ES: Búsqueda en profundidad*

```
          [1]
         /   \
      [2]     [5]
     /   \   /   \
  [3]   [4] [6]   [7]
```
Optimal to find the shortest path?
[ ] Yes
[x] No

It goes as deep as it can first. It does not necessary find the shortest past, since it can find the goal in node 4, for instance, while there is a shortest path that ends up in node 7.


text:
# [Developing Scalable Apps in Python](https://www.udacity.com/course/developing-scalable-apps-in-python--ud858)

## Course Description

You will learn about challenges of building applications that can serve hundreds of thousands of users, and how you can prepare for them as a developer.

repository: zacharytamas/udacity-courses

repo_name: zacharytamas/udacity-courses


text:
Welcome to Task Maker 👋

>Task Maker is simple Todo list maker app built on React Native with multiple theme customizations, gesture support and syncing data with MongoDB database.

# Screenshots
## Onboarding
!['Onboading'](https://raw.githubusercontent.com/iamshadmirza/TaskMaker/master/onboarding.jpg)

## Themes
!['Onboading'](https://raw.githubusercontent.com/iamshadmirza/TaskMaker/master/themeshow.jpg)

## Preview
!['Preview'](https://raw.githubusercontent.com/iamshadmirza/TaskMaker/master/taskmaker.gif)

## Install

```sh
npm install
```

## Usage

```sh
react-native run-android
```

## Key features
* Slide right to mark task completed
* Slide left to mark task uncompleted
* Long press on task to edit task
* Choose theme from 10 different color combination

## Author

👤 **Mohd Shad Mirza**

* Twitter: [@iamshadmirza](https://twitter.com/iamshadmirza)
* Github: [@iamshadmirza](https://github.com/iamshadmirza)

repository: JasonCruz-Dev/TaskMaker

repo_name: JasonCruz-Dev/TaskMaker


text:
# switchto

switch between dev and prod environments from command line.

# Installation

`pip install switchto`

# How it works

It edits your hosts file locally on Windows, Linux and Mac.

# Usage

## Add entry

`switchto -s my.website.com dev:<IP_ADDRESS> team:<IP_ADDRESS> prod:`

This will create 3 entries for your website domain, named "dev", "team" and "prod".
An empty string indicates to remove the entry from the hosts file once you run switchto that rule.

## Switching from production to dev environment and back

`switchto dev`

Will add the following entry to your hosts:

`<IP_ADDRESS> my.website.com`

Once you want to go back to production, you can:

`switchto prod`

## Remove entries

You cannot remove entires from the config file, you can however set the rule to an empty string:

`switchto -s my.website.com team:`

Note: settings are saved in .s2.json on HOME or HOMEPATH directory.

## Listing config

`switchto -l`

To list everything, or:

`switchto -l regex`

Which will list all rules matching that regex.

## CNAMEs

Currently, switchto works only via hosts, which do not support redirecting domains to other domains, but only by IP address.
You can create a rule with a target domain, but it will be resolved once you create the rule, and also you would have to pass "-y" to confirm this:

`switchto -y -s my.website.com dev:my.website.local dev`

Note the "dev" at the end, which specifies to make the switch instantly, rather than running "switchto dev" afterwards.

repository: hananbeer/switchto

branch_name: refs/heads/main

repo_name: hananbeer/switchto


text:
# flask-chatbot
is example chatbot using flask and pyaiml
you can install pyaiml and flask with this command
# pip install flask, aiml

you can start wit command # python main.py
and you visit http://localhost:5000

# online Demo

http://flask-chatbot.herokuapp.com/

repository: mushonnip/flask-chatbot

repo_name: mushonnip/flask-chatbot


text:
# Change Log

All notable changes to the "postcode" extension will be documented in this file.

Check [Keep a Changelog](http://keepachangelog.com/) for recommendations on how to structure this file.

### 1.3.9

- automattically use http protocol if none is specified
- make font size relative to vscode editor font size

### 1.3.8

- display response time in response window

### 1.3.7

- add request options for strict ssl

### 1.3.6

- add beautify button for post body

### 1.3.5

- fix basic auth functionality

### 1.3.4

- Add headers tab for response

### 1.3.3

- Improve load time by pre-rendering

### 1.3.2

- Remove excess scroll

### 1.3.1

- Add copy button to code editor

### 1.3.0

- Support code-snippet generation

### 1.2.1

- Clear error when response is updated

### 1.2.0

- Support GraphQL requests

### 1.1.0

- Support formating of responses based on language

### 1.0.0

- Initial release

repository: fx-fusion/postcode

repo_name: fx-fusion/postcode


text:
# Agents and Agencies

Technically, the majority of the book is agents/agencies. Better shove all my notes into this single file.

### Agents

Agents, despite sometimes being discussed otherwise, are essentially equivalent to codelets. In the Society of Mind architecture, agents are the independent pieces that the whole is built from. Of particular interest is the ways that these parts of combined -- as this is what gives meaning to the emergent structure. In fact, the entirety of Society of Mind is simply discussing either kinds of agents, or methods for organizing them.

"We can only explain the mind in terms of things that have no thoughts or feelings of their own, otherwise we'll have gone in a circle" (18)

Read this in the context (if you didn't already know) that Marvin Minsky considers common sense the most important part of thinking:
"Common sense is not a simple thing. Instead, it is an immense _society_ of hard-earned practical ideas -- of multitudes of life-learned rules and exceptions, dispositions and tendencies, balances and checks" (22).

Minsky will later apply this to several other ideas. Essentially, most things in the mind are composed of smaller parts. Who could disagree with that?

### Agencies

"It is not enough to explain only what each separate agent does. We must also understand how these parts are interrelated -- that is, how groups of agents can accomplish things" (23).

Agency-agents simply turn smaller agents on and off, the same way that neurons excite or inhibit. However, most composite agencies do not have comprehension.

See 2.3 and 2.4 as well:

"The mind still holds its mystery, because we know so little about how mental agents _interact_ to accomplish the things that they do" (28).

On heterarchies (3.4):
"[Loops] are impossible in simple heirarchies.. Later we'll see more cross-connected rings and loops -- when we are forced to consider the need for memory, which will become a constant object of concern in this book... If we have enough memory, we can arrange our agents into circular loops and thus use the same agents over and over again to do parts of different jobs at the same time" (35).

"We're always enmeshed in causal loops" (48).

"You can never find a final cause, since you must always ask one question more: 'What caused this cause?'" (49). However, "Circular thinking can lead to growth when it results, at each return, in deeper and more powerful ideas" (49).

Some restatements:

"To get a good idea, one must engage huge organizations of submachines that do a vast variety of jobs" (66)

"Each specialized agency must learn to call on other specialists that can serve its purposes. Certain sections of the brain distinguish the sights of faces from other types of objects. No one knows how many different such organs lie in our brains. But it is almost certain that they all employ somewhat different types of programming and forms of representation: they share no common language code" (66). Quite the claim here.. _nothing_ is shared? This is worth debating.

repository: LSaldyt/source-notes

repo_name: LSaldyt/source-notes


text:
---
title: Telerik.Web.UI.RadAjaxLoadingPanel
page_title: Telerik.Web.UI.RadAjaxLoadingPanel
description: Telerik.Web.UI.RadAjaxLoadingPanel
---

# Telerik.Web.UI.RadAjaxLoadingPanel

Telerik.Web.UI.RadAjaxPanel is one of the two major controls of the Telerik RadAjax suite.
            The other one is Telerik.Web.UI.RadAjaxManager . The Telerik.Web.UI.RadAjaxPanel control provides the easiest
            way to AJAX-enable ASP.NET web control(s). To do this you simply need to place
            the controls that you want ajaxified into Telerik.Web.UI.RadAjaxPanel and Telerik RadAjax takes
            care of the rest. Best of all this happens transparently to the framework and the
            controls that are being ajaxified.

## Inheritance Hierarchy

* System.Object
* System.Web.UI.Control
* System.Web.UI.WebControls.WebControl
* System.Web.UI.WebControls.Panel
* Telerik.Web.UI.RadAjaxLoadingPanel : IControl, IControlResolver, IScriptControl, ISkinnableControl

## Properties

###  AnimationDuration `Int32`

Gets or sets animation duration in milliseconds. Default value is 0, i.e. no animation.

###  BackgroundPosition `AjaxLoadingPanelBackgroundPosition`

Gets or sets the position of the skin background image. Default value is center.

###  BackgroundTransparency `Int32`

Gets or sets transparency of the loading panel without affecting the icon. Default value is 0 percents.

###  EnableAjaxSkinRendering `String`

Gets or sets the value, indicating whether to render the skin CSS files during Ajax requests

#### Remarks
If EnableAjaxSkinRendering is set to false you will have to register the needed control base CSS file by hand when adding/showing the control with Ajax.

###  EnableAriaSupport `Boolean`

When set to true enables support for WAI-ARIA

###  EnableEmbeddedBaseStylesheet `Boolean`

Gets or sets the value, indicating whether to render the link to the embedded base stylesheet of the control or not.

#### Remarks
If EnableEmbeddedBaseStylesheet is set to false you will have to register the needed control base CSS file by hand.

###  EnableEmbeddedScripts `Boolean`

Gets or sets the value, indicating whether to render script references to the embedded scripts or not.

#### Remarks
If EnableEmbeddedScripts is set to false you will have to register the needed Scripts files by hand.

###  EnableEmbeddedSkins `String`

Gets or sets the value, indicating whether to render links to the embedded skins or not.

#### Remarks
If EnableEmbeddedSkins is set to false you will have to register the needed CSS files by hand.

###  EnableSkinTransparency `Int32`

Defines whether the transparency set in the skin will be applied.
            Default value is True.

###  InitialDelayTime `Int32`

Gets or sets a value specifying the delay in milliseconds, after which the
            RadAjaxLoadingPanel will be shown. If the request returns before this time,
            the RadAjaxLoadingPanel will not be shown.

###  IsSkinSet `String`

For internal use.

###  IsSticky `Boolean`

The IsSticky property of the Loading Panel controls where
                the panel will appear during the AJAX request. If this property is set to
                true, the panel will appear where you have placed it on your
                webform. If this property is set to false, the Loading panel will
                appear on the place of the updated control(s).By default this property is set to false.

###  MinDisplayTime `Int32`

Gets or sets a value that specifies the minimum time in milliseconds that the
            RadAjaxLoadingPanel will last. The control will not be updated before this
            period has passed even if the request returns. This will ensure more smoother interface
            for your page.

###  Modal `Boolean`

Gets or sets the value, indicating whether the loading panel will be displayed over the entire visible area of the page.

###  OnClientHiding `String`

###  OnClientShowing `String`

###  Overlay `Boolean`

Gets or sets a value indicating whether the loading panel will create an overlay element to ensure popups are over a flash element or Java applet.

###  RegisterWithScriptManager `Boolean`

Gets or sets the value, indicating whether to register with the ScriptManager control on the page.

#### Remarks
If RegisterWithScriptManager is set to false the control can be rendered on the page using Web Services or normal callback requests/page methods.

###  RenderMode `RenderMode`

Specifies the rendering mode of the control. Setting the mode to Lightweight will yield
            HTML 5/CSS 3 html and css.

#### Remarks
Lightweight rendering mode might change the outlook of the component in some older browsers
            that don't support CSS3/HTML5.

###  ResolvedRenderMode `RenderMode`

Returns resolved RenderMode should the original value was Auto

###  RuntimeSkin `String`

Gets the real skin name for the control user interface. If Skin is not set, returns
            an empty string, otherwise returns Skin.

###  Skin `String`

Gets or sets the skin name for the control user interface.

#### Remarks
If this property is not set, the control will not use any skin (backwards compatibility)
            If EnableEmbeddedSkins is set to false, the control will not register a skin CSS file automatically.

###  Transparency `Int32`

Gets or sets transparency in percentage. Default value is 0 percents.

###  ZIndex `Int32`

Gets or sets the z-index of the loading panel. Default value is 90,000.

## Methods

###  GetEmbeddedSkinNames

Returns the names of all embedded skins. Used by Telerik.Web.Examples.

#### Returns

`System.Collections.Generic.List`1`

###  PreferredRenderMode

For internal use only

#### Parameters

#### browser `Telerik.Web.UI.RenderModeBrowserAdaptor`

RenderModeBrowserAdaptor instance

#### Returns

`Telerik.Web.UI.RenderMode` Returns the preferred RenderMode

###  RegisterCssReferences

Registers the CSS references

#### Returns

`System.Void`

repository: telerik/ajax-docs

gha_language: C#

repo_name: telerik/ajax-docs


text:
# Basic-auth

A full stack application using handlebars, express, passport and knex.

First, you will need a database (the current configuration expects postgres but this can be changed) running. Postgres setup guide: https://wiki.postgresql.org/wiki/Detailed_installation_guides

Then, you will need a .env file in the root directory to store database credentials. You will also need a key value pair for the session secret. Example .env file:
```
DB_USER=admin
DB_PASS=password
DB_NAME=dbname
DB_HOST=<IP_ADDRESS>
SESSION_SECRET=sessionsecret
```
The session secret is used by express-session for authenticating sessions. Docs: https://github.com/expressjs/session

Now, if the database is set up correctly (make sure it's an empty database) you should run ```npm run database``` which runs the knex migrations and seeds, essentially setting up the tables in your database for you. Knex docs: http://knexjs.org/

```npm start``` to run the express server on localhost:3000.

```npm run dev``` to run with nodemon.

```npm test``` to run tests with Tape.

## What it does:

A user can register. This will add the user to the database with a bcrypted password. Bcrypt is standard for password encryption at the time of this writing. Docs: https://www.npmjs.com/package/bcryptjs. Note that I chose the pure JS lib instead of the standard 'bcrypt' with c++ bindings. This means that the encryption is less efficient in terms of speed, however the tradeoff is that your environment will be pure Javascript and much less of a headache to deal with in production, and you don't need the ```node-gyp``` dependency. If you are very concerned about efficiency, https://www.npmjs.com/package/bcrypt.

A user can log in with their credentials. This will start a session that exits when the browser is closed.

The logged in user can see their own page displaying their username, but no other users' pages.

Passport is used in conjunction with a 'local' strategy. Docs: http://passportjs.org/

## Technologies

- Passport/Passport-local
- Bcrypt
- Express/Express-session
- Handlebars
- Knex/Postgres
- Tape/Tap-spec

Note that this is a very opinionated, 'batteries included' template, so only use it if you feel happy and comfortable with the technologies used.

repository: danielkermode/project-starter-dan

repo_name: danielkermode/project-starter-dan


text:
# Data for http://jaw.io

This is the data for my personal site. Rake tasks convert haml/sass into
layouts and styles, then jekyll finishes creating the static site when pushed
to github. See http://pages.github.com/ for more info in general and feel free
especially to copy the layout of the files here and the Rakefile/Gemfile if you
need to do something similar.

# License / Copyright

The following directories and their contents are Copyright (c) Joseph Wecker.
All rights are reserved:

* \_posts/
* images/
* \_misc/

All other directories and files are MIT Licensed. If you use anything a link
back to https://github.com/josephwecker/josephwecker.github.com would be
appreciated but not required.


text:
### **Gifter** is a gift tracking app to help keep you in the giving spirit.

# What can **Gifter** do?

### Keep track of your friends and family
* **Add** as many potential gift recipients as you like.
* **Store relevent information,** like their birthday, anniversary, even their shipping address.
* **Best friend finishing college?** Edit their info at any time to add new important dates like graduation.

### Remember that great gift idea you had
* **Find something online** you know your sister would love? Add a gift idea to her page so you don't forget by the time her birthday comes around.
* **Want to wait for a better deal?** Add pricing information or a direct link to the product online that you can check whenever you want.
* **Mark your gift as purchased** when it's time to buy. Or, simply delete it if you found something better.

### Provide a personal dashboard
* **Giving may be better than recieving,** but you deserve something nice, too. **Gifter** can help you put together your own wish list.
* **Never forget those important occasions.** Gifter will remind you any time there's a big date coming up, so you'll always be prepared.

gha_language: HTML


text:
# Welcome

Hello! Welcome to the Unofficial MCP Docs! In these docs, you will learn necessarry functions that you will need to get started on coding your mod.

If you get stuck at any point, you can ask a question in the **\#mcp** channel on the [Discord server](https://dsc.gg/coders).

repository: Ghalib-craftLeProgrammeur/mcp-docs

repo_name: Ghalib-craftLeProgrammeur/mcp-docs


text:
# A simple proxy

This is an Node/Express based simple proxy. It will take a query for `term` and do a request to `https://itunes.apple.com/search?term=` and respond with the response from Apple, if the requester is from CodePen or localhost.
It has been created as part of a blog post on dev.to: [Small API based web app](https://dev.to/netsi1964/small-api-based-web-app-10mh).

The POC using this service can be seen here: [POC from post on dev.to: Small API based web app](https://codepen.io/netsi1964/pen/BayZOyM)

gha_language: JavaScript


text:
TwitchHelixAPI
=======================

Use Twitch Helix API

<!-- TOC -->

- [Motivation](#motivation)
- [See](#see)
- [Installation](#installation)
- [Loading and configuration](#loading-and-configuration)
- [Common Usage](#common-usage)
- [Contact](#contact)

<!-- /TOC -->

## Motivation

Creating a Unity Asset to allow Unity developers to make interactive projects that allow viewers in a Twitch chat room to manipulate the game/application.
Add to the above statement this project add API access via a User Access Token

## See
- Twitch API Helix [Twitch Authentication](https://dev.twitch.tv/docs/authentication)

- Twitch Developer Console[Twitch Authentication](https://dev.twitch.tv/console)

## Installation
```sh
C# Solusion - Download and include in your peoject
```

## Contact
- [Contact caLLowCreation](http://callowcreation.com/home/contact-us/)
- [https://www.twitch.tv/callowcreation](https://www.twitch.tv/callowcreation)
- [https://twitter.com/callowcreation](https://twitter.com/callowcreation)

## License

MIT

repository: callowcreation/TwitchHelixAPI

repo_name: callowcreation/TwitchHelixAPI


text:
---
title: "Node.js and Asynchronous JavaScript"
date: "2019-07-25 19:45:00"
author: "Han Sim"
category: "Web"
tags:
  - JavaScript
  - Asynchronous
  - NodeJS
---

If you need to know more about Asynchronous, you can see related posts here: http://blog.hansim.dev/tag/asynchronous

# What is Node.js?

Node.js is a runtime environment for executing JavaScript code, outside of browser. This is used to build a back-end services(API; application programming interface) that power our client-side applications such as web app, mobile app, etc.

- Easy to start and requires relatively fewer lines of code
- Super fast and highly scalable
- Suitable for data-intensive and real-time apps
- JavaScript everywhere!
  - more consistent codebase is possible because we use JavaScript in client-side and back-end. i.e. same naming conventions, same best practices
- Large eco system including open-source libraries

## again, Node.js is a runtime environment

Every browser includes its own JS engine such as v8 engine in Chrome browser. This is why sometimes same code behaves differently on other browser.

**Browser provides runtime environment to JS code. i.e. window, document object. These objects allow us to work with an environment in which our codes are running.**

**Node.js took v8 engine from Chrome browser, and put it into C++ program instead of a browser. That is Node.js. So it works similar with browsers, but it provides certain runtime environment for the JS code.** For example, instead of window, Node.js provides global object. It gives many useful environment (modules) such as `os`, `fs`, `http`, and so on.

## Asynchronous JavaScript and Node.js

Node.js is highly scalable thanks to the Asynchronous nature of JavaScript; a single thread can work on multiple requests, instead of finishing first request and after moving on to the second request.

### Problem of Blocking or Synchronous architecture

i.e. ASP.NET, Ruby on Rails, etc.

These frameworks has blocking architecture. One thread is sitting on one request until the request is done. For example, say we need to query database to handle the request and of course it takes time. When a thread is assigned to this request, it just wait until it fetches all the data and deliver it to the browser. So if there is another request, we need another thread to handle that request.

If your web site become more popular, and at some point, server cannot handle the large number of requests. So the company needs to buy another server. This is not scalable, because in this synchronous way, we cannot utilize our resource effectively.

Of course, we can write asynchronous code with ASP.NET, but it requires a bunch of extra work while node.js is asynchronous by default.

### Node application is asynchronous by default

**Node application is single-threaded**.

> NodeJS is single threaded, but this is a half truth, actually it is event-driven and single-threaded with background workers. The main event loop is single-threaded but most of the I/O works run on separate threads, because the I/O APIs in Node.js are asynchronous/non-blocking by design, in order to accommodate the event loop. [Click...](https://codeburst.io/how-node-js-single-thread-mechanism-work-understanding-event-loop-in-nodejs-230f7440b0ea)

Back to the previous example, we needed to fetch data upon request, which takes quite some time. Instead of waiting for fetching, Node application put a message in message queue. Node.js is continuously watching and listening on this message queue; when Node hear back from message queue that the data is ready, it takes the result out and process the request again.

> In this process, it doesn't block event loop at all; it just interrupts the loop when the data is ready.

This asynchronous architecture makes node highly scalable and ideal for **I/O intensive applications** that includes a lot of disk or network access. We can serve more client without the need to throw more hardware.

However, when the application is **CPU-intensive** such as video encoding service, Node is not suitable since its single-threaded.

# The Beauty of Asynchronous

https://trello.com/c/5TzQwzMJ/80-what-is-asynchronous-programming-and-why-is-it-important-in-javascript

Synchronous programming means that, barring conditionals and function calls, code is executed sequentially from top-to-bottom, blocking on long-running tasks such as network requests and disk I/O.

**Asynchronous programming means that the engine runs in an event loop. When a blocking operation(that takes time to finish i.e. fetch) is needed, instead of blocking the event loop, the request is just started while the code keeps running without blocking for the result. When the response is ready, an interrupt is fired, which causes an event handler to be run, where the control flow continues.** In this way, **a single program thread can handle many concurrent operations.**

User interfaces are asynchronous by nature, and spend most of their time waiting for user input to interrupt the event loop and trigger event handlers.
Node is asynchronous by default, meaning that the server works in much the same way, waiting in the event loop for a network request, and accepting more incoming requests while the first one is being handled.

This is important in JavaScript, because it is a very natural fit for user interface code, and very beneficial to performance on the server.

Good to hear:

- An understanding of what blocking means, and the performance implications.
- An understanding of event handling, and why its important for UI code.

Red flags:

- Unfamiliar with the terms asynchronous or synchronous.
- Unable to articulate performance implications or the relationship between asynchronous code and UI code.

# References

- Event Loop: https://flaviocopes.com/javascript-event-loop/#blocking-the-event-loop


text:
## What is Unikname Connect?

[Unikname Connect](/integration/connect/) is the easiest and safest authentication solution for any SAAS platforms and mobile apps.

This solution have been designed for Saas platforms with users sensitive to the protection of their privacy, who want to be sure not to be tracked, and fleeing Facebook Connect or Sign In with Apple.

Integrating [Unikname Connect](/integration/connect/) to your platforms will increase value proposition for your visitors, and will improve security.
No more need to manage and to secure user's passwords and database!

repository: unik-name/help-unikname

repo_name: unik-name/help-unikname


text:
Collection2
=========================

A smart package for Meteor that extends Meteor.Collection to provide support for specifying a schema and then validating against that schema when inserting and updating. Also adds support for virtual fields.

## Basic Usage

When defining your models, use `new Meteor.Collection2()` instead of `new Meteor.Collection()`. It works the same, but you can specify `schema` and `virtualFields` properties in the options.

## Example

Define the schema for your collection when creating it:

```js
Books = new Meteor.Collection2("books", {
    schema: {
        title: {
            type: String,
            label: "Title",
            max: 200
        },
        author: {
            type: String,
            label: "Author"
        },
        copies: {
            type: Number,
            label: "Number of copies",
            min: 0
        },
        lastCheckedOut: {
            type: Date,
            label: "Last date this book was checked out",
            optional: true
        },
        summary: {
            type: String,
            label: "Brief summary",
            optional: true,
            max: 1000
        }
    }
});
```

Do an insert:

```js
Books.insert({title: "Ulysses", author: "James Joyce"}, function(error, result) {
  //The insert will fail, error will be set,
  //and result will be undefined because "copies" is required.
  //
  //The list of errors is available by calling Books.simpleSchema().invalidKeys()
});
```

Or do an update:

```js
Books.update(book._id, {$unset: {copies: 1}}, function(error, result) {
  //The update will fail, error will be set,
  //and result will be undefined because "copies" is required.
  //
  //The list of errors is available by calling Books.simpleSchema().invalidKeys()
});
```

## Schema Format

The schema object format is actually dictated by the [simple-schema](https://github.com/aldeed/meteor-simple-schema) package,
which is installed when you install `collection2`. See that documentation. If
you need to get the actual SimpleSchema for any reason, such as to access any
of the methods on it or pass it to `checkSchema()`, you can do so by calling
`MyCollection2.simpleSchema()`.

For example:

```js
checkSchema(doc, MyCollection2.simpleSchema());
```

## Why Use It?

In addition to getting all of the benefits provided by the [simple-schema](https://github.com/aldeed/meteor-simple-schema) package,
Collection2 sets up automatic property filtering, type conversion, and,
most importantly, validation, on both the client and the server, whenever you do
a normal `insert()` or `update()`. Once you've defined the schema, you no longer
have to worry about invalid data. Collection2 makes sure that nothing can get
into your database if it doesn't match the schema.

Collection2 (more specifically, SimpleSchema) probably can't support every insert or update object you throw at it,
but it can support the most common scenarios. Normal objects as well as $set and $unset
objects are supported. It understands basic dot notation in your $set and $unset keys.
See the SimpleSchema documentation for more details.

### SmartCollections

If you want to use a SmartCollection, provided by the
[smart-collections](https://github.com/arunoda/meteor-smart-collections) package,
you can. Create the SmartCollection object, and then pass it as the first argument
of the Collection2 constructor function.

```js
BooksSC = new Meteor.SmartCollection("books");
Books = new Meteor.Collection2(BooksSC, {
    schema: {
        //keys
    }
});
```

Then use `Books` instead of `BooksSC` throughout your code, and you will gain the
benefits of both SmartCollection and Collection2.

### AutoForms

Another great reason to use Collection2 is so that you can use the [autoform](https://github.com/aldeed/meteor-autoform) package.
AutoForm makes use of Collection2 to help you quickly develop forms that do complex inserts
and updates with automatic client and server validation. Refer to the [autoform](https://github.com/aldeed/meteor-autoform)
documentation for more information.

## What Happens When The Document Is Invalid?

The callback you specify as the last argument of your `insert()` or `update()` call
will have the first argument (`error`) set to a generic error. Generally speaking,
you would probably use the reactive methods provided by SimpleSchema to display
the specific error messages to the user somewhere. The autoform package provides
some handlebars helpers for this purpose.

## More Details

For the curious, this is exactly what Collection2 does before every insert or update:

1. Removes properties from your document or $set object if they are not explicitly listed in the schema.
2. Automatically converts some properties to match what the schema expects, if possible.
3. Validates your document or $set or $unset objects.
4. Performs the insert or update like normal, only if it was valid.

In reality, Collection2 is simply calling SimpleSchema methods to do these things. The following
is the gist of the entire package:

```js
//clean up doc
doc = schema.filter(doc);
doc = schema.autoTypeConvert(doc);
//validate doc
schema.validate(doc);

if (schema.valid()) {
    //perform insert or update
} else {
    //pass error to callback or throw it
}
```

## Virtual Fields

You can also implement easy virtual fields. Here's an example of that:

```js
Persons = new Meteor.Collection2("persons", {
    schema: {
        firstName: {
            type: String,
            label: "First name",
            max: 30
        },
        lastName: {
            type: String,
            label: "Last name",
            max: 30
        }
    },
    virtualFields: {
        fullName: function(person) {
            return person.firstName + " " + person.lastName;
        }
    }
});
```

This adds the virtual field to documents retrieved with `find()`, etc., which means you could now do `{{fullName}}` in your HTML as if fullName were actually stored in the MongoDB collection.


text:
# ToM Skills Editor

## Usage:
Selecting a skill under a character's tab will display the data on the right side of the
app:

![Update data on selection of skill](https://github.com/pyroll/ToM-Skills-Editor/blob/master/img/img_for_readme/data_on_selection.png)

* Link ability: Set to true to make a link ability.
* Traning Points Required: Set the amount of TP required to unlock for that class of the selected character.

### Editing:
Edits are done on a **per skill** basis.
This will populate the edits tree in the lower left part of the program:

![Adding edits to the edits tree](https://github.com/pyroll/ToM-Skills-Editor/blob/master/img/img_for_readme/add_edit_to_tree.png)

Any changes made to that same skill after saving your edits will overwrite the previous changes. Click **Remove Selection** to remove a
specific edit or a skill entirely from the edits tree. Do this process for every skill you would like to change.

### Saving & Loading config files
Config files can be saved and loaded for convenience. The files are in yaml format and are stored in the config folder of the mod's main directory.
They can be viewed and optionally edited in any text editor of your choice.

When the program is started, you will start with a new config file, which is displayed in the lower right:

![display current config](https://github.com/pyroll/ToM-Skills-Editor/blob/master/img/img_for_readme/display_current_config.png)

If you would like to save your edits for use at a later time, select **Save Config File -> Save** under the File menu. You can also input 'ctrl+s'
as a shortcut. This will bring up a dialog for you to name it and save in the Config folder. Do not save these files anywhere else as the program
won't be able to locate them.

The **Finish** button in the lower left performs **Create Edited Files Without Saving**, which is explained below.

Loading a config file reads the data from it and inserts the edits into the edits tree. You should see the current config file label update in the
lower right as well. Select **Load Config File -> Load Into Edits Tree** to do so. You may use 'ctrl+l' as a shortcut.

## Other Menu options
* **Create Edited Files Without Saving** - Creates final edited files without saving the current edits in the edits tree
* **New Config File** - Clears edits tree as if you had just started up the program
* **Save Config File -> Save As..** - Save current edits to a new file (won't overwrite the currently loaded config file)
* **Save Config File -> Save and Create Edited Files** - Save current edits to a config file and immediately created edited files after
* **Load Config File -> Load and Create Edited Files** - Select a config file to load edits from and immediately created edited files after

### Creating a pak file for the game
Once you've selected to create edited files, the program will show you a notice popup saying that a folder called **ToM_Skills_Edit_P** was created in the mod's main directory. This folder needs to be converted to a pak file to be used as a mod.

Download UnrealPak from this link: https://mega.nz/file/VVlwwCLL#TDBl3WBB2uEHKFhiXpLdynRZ6irUiLW82HmltmoTW8M

Ensure that both 'UnrealPak.exe' AND 'UnrealPak-Without-Compression.bat' are in the same directory. Drag and drop the created **ToM_Skills_Edit_P** folder over 'UnrealPak-Without-Compression.bat'. This should yield **ToM_Skills_Edit_P.pak** in the same location. Ensure that the file size is not 0 kb, as that would indicate an error.

Create a folder named something like '~mod' in Trials of Mana's steam directory if you haven't already. Place **ToM_Skills_Edit_P.pak** in that folder and you should be good to go.

### Oddities/Notes:
- I need to tweak things before I can have each class for each character nicely displayed in the app (instead of just saying Class 1A...etc.). In the meantime if you're unsure of exactly what class to change, I recommend just changing the stat value for each 'level' class you want. For example: If you want to unlock a skill early for Hawkeye's Rogue class, just change the stat value for every 'Class 3' (Class 3A, 3B, etc.).
- Setting a stat boost such as 'Luck +10' to a link ability will have a strange visual effect and doesn't seem to actually apply to status boost to each character. So avoid doing this if possible.
- Some skills are unable to be converted to a link ability (the ability to change the link status is disabled in the skills editor). The game wasn't nice enough to provide a unique id that I need in the game files for some skills, so they need to be left as is.
- In some limited testing on a maxed out ng+ save file, edited skills didn't show in the skills list. Perhaps it doesn't update if a character's stat in fully upgraded?

### Future Plans:
- Add ability to change what stat a skill is assigned to
- Add editing for magic/arts
- Add ability to assign mp cost of magic
- Various usability improvements for the app

### *** Final Note - A Request ***
If anyone wants to volunteer to help make the skills more readable, I could use a list of
all the skill names that are shown in game. I used the skill names from the game's files, but
it still isn't clear exactly which skill it's referring to (the Mania difficulty mod has
the same issue). Essentially what I'd need is some kind of txt file that links each skill
name in the skills editor with the English skill name that shows in game.

For example:

    Duran:
    - AttackUp = Strength +5
    - etc.
    - etc.

    Angela:
    - etc.

This is very time consuming as there are likely ~200 skills total, and I don't really have
the resources nor the desire to fix it anytime soon. So if anyone would like to contribute
in this way, feel free to contact me in the discord.

repository: pyroll/ToM-Skills-Editor

repo_name: pyroll/ToM-Skills-Editor


text:
# pcr-primer-finder
A command-line tool that find optimized PCR-primer for a given fasta file region.

### Functionalities
Results of this tool follows somes rules:
* 17 to 25 nucleotids-long primer
* Primer has to end with a C or G
* Both primer need to have the same hybridation temps

To be implemented:
* addition of restriction sites
* addition of promotor

### How to use
```bash
python main.py -f filename.fasta -b [begining of region interest] -e [end of region of interest]
```
Example:
```bash
python main.py -f test.fasta -b 10 -e 200
```
(python3)

### Screenshot (with test.fasta)
![Screenshot of the Application](https://i.imgur.com/Wxf2Zfe.png)

repository: lambda-science/pcr-primer-finder

repo_name: lambda-science/pcr-primer-finder


text:
# AppPermissions
[![Language](http://img.shields.io/badge/language-swift-brightgreen.svg?style=flat)]
(https://developer.apple.com/swift)
[![CocoaPods compatible](http://img.shields.io/cocoapods/v/AppPermissions.svg?style=flat)]
(https://cocoapods.org/pods/AppPermissions)

## Installation

iOS 8:
`pod 'AppPermissions'`

iOS 7:
from Source Files

### Preconfiguration

in `applicationDidBecomeActive`  in `AppDelegate` add:

```swift
func applicationDidBecomeActive(application: UIApplication) {

        if let root = self.window?.rootViewController {
            AppPermissionsViewController.restoreControllerIfNeeded(root)
        }
    }
```

if iOS 7 add:
```swift
func application(application: UIApplication, didFinishLaunchingWithOptions launchOptions: [NSObject: AnyObject]?) -> Bool {

        ...

        self.window?.rootViewController?.modalPresentationStyle = UIModalPresentationStyle.CurrentContext;
        return true
    }
```
### Present permissions controller

```swift
AppPermissionsViewController.present(self, types: [.Calendars, .Camera, .Contacts]) { success in
        if success {
            ...
        }
```

### Available permissions
* PermissionType.AssetsLibrary
* .Bluetooth
* .Calendars
* .Camera
* .Contacts
* .Events
* .LocationAlways
* .LocationInUse
* .Microphone
* .Notifications
* .Photos
* .Reminders

#### About Location Permission

add in `info.plist` rows `NSLocationAlwaysUsageDescription` and `NSLocationWhenInUseUsageDescription` for description in dialog message (required)

#### About Bluetooth Permission

add in `info.plist` row `NSBluetoothPeripheralUsageDescription` and enable `background-modes` in the `capabilities` section and check the `Acts as a Bluetooth LE accessory` checkbox (required)

repository: DigitalExpansion/AppPermissions

gha_language: Swift

repo_name: DigitalExpansion/AppPermissions


text:
# K.I.T

Keep In Touch! KIT is simple, users can send messages in public groups or privately to other users.

[Video Walkthrough](https://www.youtube.com/watch?v=wUWpgFARa8o&feature=youtu.be)

## Getting Started

Clone the project and start the server to get up and running.

```
rails s
```

## Built With

Rails 5.2.3

## Contributing

Not accepting contributions at this time.

## Authors

* **Derek Cerretani** - [drkjc](https://github.com/drkjc)

## License

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

## Acknowledgements

*  Initally created for Flatiron School Rails/Javascript Portfolio Project

repository: drkjc/kit

gha_language: Ruby

repo_name: drkjc/kit


text:
# Calyculosphaeria tetraspora (Nannf.) F. San Martín SPECIES

#### Status
ACCEPTED

#### According to
Index Fungorum

#### Published in
Acta Bot. Mexicana 36: 46 (1996)

#### Original name
Nitschkia tetraspora Nannf.

### Remarks
null

repository: mdoering/backbone

repo_name: mdoering/backbone


text:
---
title: Batch conversion of media containers using FFMpeg on Windows
author: Brad McCormack
type: post
date: 2015-06-02T09:58:34+00:00
url: /uncategorized/batch-conversion-of-media-containers-using-ffmpeg-on-windows/
spacious_page_layout:
  - default_layout
dsq_thread_id:
  -<PHONE_NUMBER>
categories:
  - Uncategorized

---
* This is an old post that I didn’t finish. I’m putting it up out of prosperity

I happen to have a lot of MKV files on my NAS. I’d like to stream them around my home without transcoding. Unfortunately the MKV container is not suited to streaming in my environment. I use a mixture of SMB and DLNA streaming. Some of my DLNA clients are pretty abysmal when it comes to container/codec support.

I’m lucky enough that the majority of my media has supported codecs so I’d like to just fix up the incompatabilities with the containers.

FFMPEG to the rescue!

Usage – (FIX ME)

ffmpeg -i cool-song.flv \ # Specify the input file

> -acodec copy \ # I want to copy the audio track

> -vcodec copy \ # I want to copy the video track too

> cool-song.mkv # specify the output filename and container

However I don’t want to be doing this by hand for hundreds of files so I’ll be using Window’s equivalent of Xargs which I would use on Unix.

So in this case I’ll be using forfiles (provide link)

To get help on forfiles specify

forfiles /?

forfiles /S /p D:Video /M r*.mkv /C “cmd /c ffmpeg -i @file -acodec copy -vcodec copy -y @fname.m4v -loglevel panic”

You could also look at keeping the ffmpeg output and redirecting it to a log (append for all copy between containers via)

(confirm the above)

forfiles /S /p D:Video /M r*.mkv /C “cmd /c ffmpeg -i @file -acodec copy -vcodec copy -y @fname.m4v 2>&1 | something >> log.txt

To show the current file converting , time started converting , convert it and delete the original mkv file you could use

forfiles /S /p D:Video /M *.mkv /C “cmd /c echo converting @file &

& time /t && ffmpeg -i @file -acodec copy -vcodec copy -y @fname.m4v -loglevel panic && del

@file”

repository: bradmccormack/blog

repo_name: bradmccormack/blog


text:
# Activity 1
In this activity, we'll experiement with Bootstrap's [components](https://getbootstrap.com/docs/4.0/components/buttons/), [utilities](https://getbootstrap.com/docs/4.0/utilities/borders/), and [grid layout](https://getbootstrap.com/docs/4.0/layout/grid/). Follow the instructions in the comments of your `index.html` file to complete the activity. We'll achieve our desired styles _without_ writing our own CSS (instead, we'll just apply the Bootstrap styles).

Here is the page **without** Bootstrap styles:

![page without bootstrap styles](imgs/without_styles.png)

And here is the page **with** Bootstrap styles:

![page bootstrap styles](imgs/with_styles.png)

I suggest you open the [Bootstrap CSS File](https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0-beta/css/bootstrap.css) in your browser so you can see what styles get applied to each class as you go along. See `complete` branch for answers.


text:
ebooks-tools
============

VM with tools for converting Djvu to PDF, OCR for text layer creation.

Quick start
===========

1. Before start you need install [Vagrant](https://www.vagrantup.com/downloads).
2. Clone this repository `git clone git@github.com:torinaki/ebooks-tools.git`
3. Start VM `cd ./ebooks-tools; vagrant up`
4. Connect to VM via SSH `vagrant ssh; cd ./share`

Now you are ready.

Convert DJVU to PDF
===================
1. Put DJVU file to `./ebooks-tools` folder. Then it will be accesable on VM because this folders shares via your computer and VM
2. Start convertion `sh ./convert.sh your_ebook.djvu converted_ebook.pdf`

Create DJVU text layer with OCR tool
====================================
1. Put DJVU file to `./ebooks-tools` folder.
2. Start text recognition process
   `ocrodjvu --engine tesseract --language=rus -o your_ebook_with_text_layer.djvu  your_ebook.djvu`

repository: dbalabka/ebooks-tools

repo_name: dbalabka/ebooks-tools


text:
# _Von Dubinhaus Rescue Shepherds_

##### _www.vondubinhaus.com_
##### _A website built in Rails for a German Shepherd Dog Rescue located in Portland, Oregon_

#### By _**Brandon Seroyer**_

## Description

_This application is the home to Von Dubinhaus Rescue Shepherds._
_Using this app, users can:_
* _Create user accounts, set admin privileges_
* _Create, view, edit rescue dogs currently available for adoption_
* _Create and view rescue dogs previously adopted_
* _Destroy dog profiles once erroneous_
* _Submit adoption applications for rescue dogs_
* _Donate to the rescue via Stripe API_
* _View index of donations and adoption applications, destroy as needed_
* _Share Animal profiles via Facebook and Twitter_
* _Comment feature for individual rescue profile_
* _Receive email notifications when comments, donations, or adoption apps are submitted_

## Setup

* _visit online at www.vondubinhaus.com_

_or to view on local machine:_
* _Open this repository on GitHub and clone the files within to your computer._
* _Run the following commands in the terminal on your computer._

```
bundle install      # installs necessary gem dependencies the app relies on
postgres            # starts the postgres server in background
rake db:init        # runs rake db:drop, :create, :migrate, :seed and :test:prepare
rails server        # starts the rails server
```

## Technologies Used

_Ruby, Rails, PostgreSQL, Active Record, Devise Encryption, AJAX, Bootstrap, Stripe API, Amazon S3_

_Testing was preformed with RSpec and Capybara_

### Legal

Copyright (c) 2016 **_Brandon Seroyer_**

This software is licensed under the MIT license.

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

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

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

This software is licensed under the MIT license.