text:
# logue

Some of these are my creations, and some are compiled from [the Unit index](https://korginc.github.io/logue-sdk/unit-index/) and streamlines for a single workflow.

## Pre-requisites

You'll need the Korg logue-sdk environment to start using these effects. The easiest way to do this is using Docker, but you can also do it using a local dev environment.

### Docker dev environment

You can build everything with Docker-initiated development environment. Make sure you have Docker 19.03+ and run

```
make
```

It will build all units into the `build/` folder. Re-run `make` to rebuild (Docker caches dev environment so its not slow). You can then upload them manually using the `logue-cli` (which is also built and stashed in the `build/` dir).

If you want to just build all and upload into specified slots you can do:

```
make -i upload
```

If you want to clear everything and upload all:

```
make -i reset
```

### Local dev environment

Clone this repository, and then install the [Korg's logue SDK](https://github.com/korginc/logue-sdk):

```bash
git clone https://github.com/schollz/logue
cd logue

# get SDK
git clone https://github.com/korginc/logue-sdk

# get CSMSIS libraries
cd logue-sdk && git submodule update --init

# install the logue-cli
cd ../tools/logue-cli
./get_logue_cli_linux.sh
chmod +x logue-cli-*/logue-cli
# put onto path
sudo mv logue-cli-*/logue-cli /usr/local/bin/

# get linux gcc compiler
# the following doesn't work in ubuntu 19+...they dropped 32-bit support
#cd logue-sdk/tools/gcc
#./get_gcc_linux.sh
# instead, do (from head of main repo)
sudo apt install gcc-arm-none-eabi
mkdir -p logue-sdk/tools/gcc/gcc-arm-none-eabi-5_4-2016q3/bin
ln -s /usr/bin/arm-none-eabi-gcc logue-sdk/tools/gcc/gcc-arm-none-eabi-5_4-2016q3/bin/arm-none-eabi-gcc
ln -s /usr/bin/arm-none-eabi-g++ logue-sdk/tools/gcc/gcc-arm-none-eabi-5_4-2016q3/bin/arm-none-eabi-g++
```

Now you can build effects using the local environment. Simple `cd` into a directory and run `make`:

```
cd simplepan && make
```

Then to upload into slot `0` do something like

```bash
INPORT=`logue-cli probe 2>&1 | grep NTS | grep "in " | sed "s/:.*//" | sed "s/in //" | sed 's/^ *//g'`
OUTPORT=`logue-cli probe 2>&1 | grep NTS | grep "out " | sed "s/:.*//" | sed "s/out //" | sed 's/^ *//g'`
logue-cli load -i $INPORT -o $OUTPORT -s 0 -u mod*.ntkdigunit
```

## Effects

### My effects

These are effects I've made (so far pretty simple).

#### simplepan (modfx)

[simplepan](https://github.com/schollz/logue/tree/master/simplepan) is a simple panning mod effect which allows you to control the depth and rate of a left/right pan.

#### distortion (modfx)

[distortion](https://github.com/schollz/logue/tree/master/distortion) has some very simple code doing distortion based on clip / clip boost / wave fold transfer functions.

- time knob = gain
- depth knob = wet/dry

### Forked effects

These are effects I've found from others that I've forked here and manipulated a little bit, and integrated into my workflow.

#### pitchshift (delfx)

[pitchshift](https://github.com/schollz/logue/tree/master/pitchshift) is a [fork from @centrevillage](https://github.com/centrevillage/cv_logue), which adds a delay pitch shifting effect. It is licensed under MIT (c) 2019 centrevillage.

#### tremelo (modfx)

A nice tremelo from [@ttaschke](https://github.com/ttaschke/tremoxd), licensed under BSD-3 (c) 2020, Tim.

#### tldy (delfx)

This is an awesome time delay [from @techno-cat](https://github.com/techno-cat/logue-user-delfx-tdly), licensed under MIT (c) 2019 Tomoaki Itoh.

Note for some reason [Ubuntu can't load this normally](https://github.com/korginc/logue-sdk/issues/37#issuecomment-627982850) to upload you can use

	make -i tldy

which will upload it into slot 1.

repository: schollz/logue

gha_language: Makefile

repo_name: schollz/logue


text:
---
title: "Signing in to an SSO team"
updated: 2023-02-06
---

> **[SSO is available on Postman Professional and Enterprise plans.](https://www.postman.com/pricing)**

When your [Team Admin](/docs/collaborating-in-postman/roles-and-permissions/#team-roles) has enabled single sign-on (SSO) for Postman, you can sign in to Postman with a [configured identity provider (IdP)](/docs/administration/sso/intro-sso/#identity-providers-supported).

Your Team Admin can share a **Login URL** that was generated during the SSO configuration. The **Login URL** will automatically redirect you to your configured IdP.

## Signing in to Postman with SSO

To [sign in to Postman](/docs/getting-started/installation/postman-account/#signing-in-to-postman) using the Postman desktop app, select **Sign In** in the upper-right corner or select **Home** in the upper-left corner, then **Sign In**. You can also go to [Postman's website](https://www.postman.com/) and select **Sign In** in the upper-right corner of the page.

When you sign in using the Postman desktop app, the app will open a new screen that directs you to sign in from your browser. Your default browser will automatically open a webpage asking you to sign in to Postman.

> Your browser will open within a few seconds. If it doesn't, select **open it manually** or **copy the URL** in Postman.

> You must finish signing in within five minutes once you start the process from Postman. If you go beyond this time, you must return to Postman and restart the sign in process.

To sign in to Postman with SSO, do the following:

1. On the sign in page, select **Sign in with SSO**.

1. Enter the team domain, then select **Continue**.

    > Select **Stay signed in for 30 days** if you want to remain signed in to your current session for 30 days before re-authenticating. If you don't want to remain signed in on the computer you are working on, clear this checkbox. Note that you will be prompted to sign in again after 30 minutes.

1. Select the authentication method you want to sign in with.

1. Postman will redirect you to the configured IdP. Enter your SSO details to sign in.

    > The first time you sign in to Postman, you may need to carry out extra steps to set up access to your IdP account. Sign in using SSO and follow the steps to [link your IdP account to Postman](/docs/getting-started/installation/postman-account/#linking-your-account-to-postman).

> If you're a member of multiple Postman teams with varying authentication methods, you must sign in to those teams separately. To do so, select your avatar in the upper-right corner, then select the team to proceed.

repository: postmanlabs/postman-docs

branch_name: refs/heads/develop

extension: md

gha_language: JavaScript

license_type: permissive

repo_name: postmanlabs/postman-docs


text:
# chrome-node-java

A docker image with Google Chrome, Node 12.14.1 & Java 8 for End to End Testing.

```
Google Chrome: 85 (latest stable)
Node 12.14.1
Java 8
Support international fonts e.g. Thai
```

### How to use

```
docker pull suncerberus/chrome-node-java:latest
```

### This image is ready for..

- [allure 2](https://github.com/allure-framework/allure2): A report framework

### Disclaimer

It always use tag `latest`. In security case. Decide to clone a Dockerfile and build it your own instead.

license: MIT

repository: Cerberus/chrome-node-java

branch_name: refs/heads/master

repo_name: Cerberus/chrome-node-java


text:
---
title: Receiving Focus
page_title: Receiving Focus - RadDateInput
description: Check our Web Forms article about Receiving Focus.
slug: raddateinput/features/receiving-focus
tags: receiving,focus
published: True
position: 5
---

# Receiving Focus

##

How a **RadInput** control behaves when it receives focus can be controlled by setting the **SelectionOnFocus** property. It can be set to any of the following values:

* **Telerik.Web.UI.SelectionOnFocus.CaretToBeginning**: When the **SelectionOnFocus** property is **CaretToBeginning**, the input caret appears at the beginning of the input control's value when it first gets focus. Text the user types is inserted at the beginning of the control's current value.

* **Telerik.Web.UI.SelectionOnFocus.CaretToEnd**: When the **SelectionOnFocus** property is **CaretToEnd**, the input caret appears at the end of the input control's value when it first gets focus. Text the user types is appended to the control's current value.

* **Telerik.Web.UI.SelectionOnFocus.SelectAll**: When the **SelectionOnFocus** property is **SelectAll**, the entire value of the input control is selected when it first gets focus. Text the user types replaces the control's current value.

* **Telerik.Web.UI.SelectionOnFocus.None**: When the **SelectionOnFocus** property is **None** (the default value), the browser determines the caret placement and selection when the control first gets focus.

All four **RadInput** controls support the **SelectionOnFocus** property. In addition, two of the **RadInput** controls, **RadDateInput** and **RadMaskedTextBox**, let you format their values differently, depending on whether they have focus.

>caption

| RadInput Control | Properties for formatting value with focus | Properties for formatting value without focus |
| ------ | ------ | ------ |
|RadDateInput|DateFormat|DisplayDateFormat|

>note You do not need to set both sets of properties. If you only set the properties for formatting a value with focus, the RadInput control uses them even if the control does not have focus.
>

# See Also

 * [Setting Focus]({%slug raddateinput/features/setting-focus%})

repository: telerik/ajax-docs

gha_language: C#

repo_name: telerik/ajax-docs


text:
# Change log

## Version 1.0.2

Release date: 2019-01-07

- Fixed a bug where `ReflectionList` and `ReciprocalSpaceSimulation` would not work with crystals that stored wavelength as a `Quantity`.
- Minor updates and changes in the documentation (thanks to Bianca Eifert for pointing out some of them).
- Added some missing auto-complete suggestions for `$CrystalData` (for the second argument).
- Added the option `AngleThreshold` to `BraggAngle` and `ReflectionList` for more efficient filtering by Bragg angle.


text:
Install

GitHub

`pip install git+https://github.com/yesyigitcan/SquareNeighborhoodClassifier`

PyPI

`pip install -i https://test.pypi.org/simple/ SquareNeighborhoodClassifier`

Inspiration

If you ever played GTA San Andreas, you know there are some gangs that capture neighborhoods. These captured neighborhoods are represented as squares in different colors. SquareNeighborhoodClassifier works similarly.

Method

In order to use this algorithm, you can only use two features for now. Let's assume we want to make predictions by using two features. We have a huge square map (or universe) that is limited by minimum and maximum values of the features. Now we divide it into smaller squares like we do in convolutional operation. Each small square has own class (belongs to a specific gang) which is determined by a kind of weighted (by count) euclidean distance.

Prediction

Now let's assume we have a data row to predict its class(or which gang it belongs to)

We find its square position in universe first.

Then check if its square has a determined class.

If it does, so the class of new data is the class of its square.

Else let's increase our visibility distance and search for neighbor squares and make a prediction by using neighbor squares' opinions like we do in random forest.

We have weightly determined classes in each square. But it is not enough. We also check count in each square to make another weighted prediction.

GTA San Andreas Map

!["GTA San Andreas Map"](gta-sa-map.webp)

Square Neighborhood Map

!["Square Neighborhood Map"](square-neighborhood-classifier.png)

Main

```python
import pandas
from SquareNeighborhoodClassifier import SquareNeighborhoodClassifier
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn import datasets

X_train = pandas.DataFrame(datasets.load_breast_cancer().data)[[0,1]]

y_train = datasets.load_breast_cancer().target

X_train, X_test, y_train, y_test = train_test_split(X_train, y_train, test_size=0.33, random_state=42)

model = SquareNeighborhoodClassifier(14, epoch=0, onlySetNone=True)
model.fit(X_train, y_train)
print("SNC Accuracy Score:", model.score(X_test, y_test))

model2 = KNeighborsClassifier(n_neighbors=225)
model2.fit(X_train, y_train)
print("KNN Accuracy Score:", model2.score(X_test, y_test))
```

```
Data points are being added to initial squares: 381/381 | Remaining: 00:00
Calculating value of each square: 196/196
Epoch (extended): 6/6
SNC Accuracy Score: 0.8936170212765957
KNN Accuracy Score: 0.851063829787234
```


text:
# NAME

Bot::ClueBot::Plugin::WebSocket - ClueBot plugin that provides a websocket interface to the bot's features

# VERSION

Version 0.02

# SYNOPSIS

When enabled, this plugin will listen for websocket connections to a given port (defaults to 9191),
through which you can execute commands on the bot.

You can connect ot the websocket interface using an endpoint url like `ws://hostname:port/$user/$token`.

The token can be requested by users from the WebToken plugin.

You can use the test script `cluebot-websocket-client` for test purposes:

    ./cluebot-websocker-client<EMAIL_ADDRESS>    Connected!
    Received message from endpoint:
        {"text":"Welcome, user@domain/ws0!"}
    {"command":"help", "params":{"command":"web_token"}}
    Sending {"command":"help", "params":{"command":"web_token"}}...
    Received message from endpoint:
        {"response":"Help for web_token:\nGenerate auth token for use with other bot services","seq":0}
    {"command":"list_chatrooms"}
    Sending {"command":"list_chatrooms"}...
    Received message from endpoint:
        {"response":{"testbot_log@conference.domain":{"autojoin":"1","password":null,"quiet":"0"}},"seq":1}

# OPTIONS

- port

    Port on which to listen for connections. Defaults to 9191.

# HELPERS

- ws\_connection( $user )

    Returns any websocket connections by the given user.

- ws\_send( $user, $data )

    Send a message to the user via webssocket.

# COMMANDS

- websocket\_status

    Reports all currently open websocket connections

repository: qrovira/cluebot

repo_name: qrovira/cluebot


text:
# Knockoff #

A simple prototype inspired by [Knockout.js](http://knockoutjs.com) to show how MVVM in Delphi can work.

### Observable ###

Core of the library is the Observable<T> type which is an anonymous method type which is overloaded. So it combines being getter and setter in one type. Following code example shows how to get and set the value of an observable.

```
#!delphi

var
  o: Observable<Integer>;
  i: Integer;
begin
  o := Observable.Create(42);
  i := o(); // calls the function: T overload
  o(i + 1); // calls the procedure(const value: T) overload
```

repository: FSharpCSharp/Knockoff

repo_name: FSharpCSharp/Knockoff


text:
---
published: true
---
## Action Research

Action Research is a methodology that is generally applied to the social sciences. It aims for transformative change via the simultaneous processes of taking action and doing research, which is then summarised with critical reflection.

Action Research in Organisational Development is the most applicable variant for an IT workspace. The process is broken into three major steps: Input, Transformation and Results.

The Input stage involves planning with preliminary diagnoses, data gathering, feedback of results and Action Planning.

The Transformation stage involves learning processes relevant to the organisation, more action planning and forming steps to perform the Action.

The Results stage involves summary via critical reflection; changes in behaviour of the system or its participants are analysed, data is gathered, and measurement of change is taken.

The Transformation and Output stages have the opportunity for a feedback loop; if the Action stage finds that more analysis and planning is necessary due to gaps in understanding then the processes are investigated again, and the Action steps may be modified.

Similarly, if the Results stage shows that little was gained, then more Action, or more Planning is needed.

A fitting application of Action Research for IT is the Change Management discipline of the Unified Process.

Action Research and the Unified Process are both iterative approaches, and a project following the Unified Process while employing Action Research for Change Management may improve on existing processes greatly.

Action Research may not be applicable to projects for new products following the Unified Process.
A weakness of Action Research is that it can be a heavily cyclic process and may need several iterations before it can be considered effective, resulting in a lengthy process.

On the other hand, its cyclic nature can also be a strength, as important information can be missed in any form of information gathering and planning. This may result in a more effective outcome compared to other methods of research where reflection does not occur after each stage.

[Comment Section](https://docs.google.com/document/d/1Sm8vqvVEl8TsfNqThyPn8wnUd73Kzq7mxf8FCijRscY/edit?usp=sharing)

repository: ClaudioTM/ClaudioResBlog

repo_name: ClaudioTM/ClaudioResBlog


text:
# CWeather
![Travis Badge](https://travis-ci.org/infa16/php-owm-widget.svg?branch=master "Build status")
![Scrutinizer Code Quality](https://scrutinizer-ci.com/g/infa16/php-owm-widget/badges/quality-score.png?b=master)
![Code Coverage](https://scrutinizer-ci.com/g/infa16/php-owm-widget/badges/coverage.png?b=master)

## Introduction
CWeather is a class for generating a weather-module that can be implemented on
whatever website you desire. It can be used with Anax-MVC but it is not dependent on it.

## License
This software is free software and carries a MIT license.

## How to install
To install the package, add the row below to your composer.json file:

```
"require": {
   "infa16/weather": "dev-master"
}
```

To add CWeather, the easiest way is to initialize it when/where you need it:

```
$weather = new \infa16\Weather\CWeather("<appid>", "<city>");
$html = $weather.view();
```

## How to use
You have to sign in and get a valid appid from http://openweathermap.org/
before you can use the service. When you have done that you also need to
set the city you want to get the weather-report from.

You can use the module with or without the css-file.


text:
---
layout: post
title: "Wrapper for amqp library for RabbitMQ"
location: "Japan"
tags: [go, amqp, rabbitmq]
comments: true
---

I uploaded a [simple wrapper](https://github.com/flowerinthenight/rmq) to [streadway/amqp](https://github.com/streadway/amqp) library for RabbitMQ with support for auto reconnections. This is a simplified version of what I'm using in production.

gha_language: SCSS

gha_license_id: MIT


text:
# ngx-foundation Starter Kit (Angular 7)

[![dependencies Status](https://david-dm.org/nthompson777/ngx-foundation-starterkit/status.svg)](https://david-dm.org/nthompson777/ngx-foundation-starterkit) [![npm version](https://img.shields.io/npm/v/ngx-foundation.svg)](https://npmjs.org/package/ngx-foundation)
[![GitHub license](https://img.shields.io/github/license/nthompson777/ngx-foundation-starterkit.svg)](https://github.com/nthompson777/ngx-foundation-starterkit/blob/master/LICENSE)
[![Twitter](https://img.shields.io/twitter/url/https/github.com/nthompson777/ngx-foundation.svg?style=social)](https://twitter.com/intent/tweet?text=The+best+way+to+quickly+integrate+Zurb+Foundation+for+Sites+components+with+Angular+6+or+7:&url=https%3A%2F%2Fwww.npmjs.com%2Fpackage%2Fngx-foundation)

A Starter Kit for ngx-foundation that uses Angular 7, the latest stable version of Foundation for Sites using the XY Grid and SCSS by default and ngx-foundation. The starter kit contains all of the basic assets to get your SPA up and running quickly.

The Starter Kit/Project is 99.9% style-agnostic and contains the flat/default Foundation for Sites styles, so you will have to add your own styles and change the variables in the `/src/assets/scss/_settings.scss` file yourself to give the project your own unique look. See the [SCSS Variables section below](#scss-variables) for more detailed information.

This project was generated with [Angular CLI](https://github.com/angular/angular-cli) version 7.

## Table of contents
1.  [Getting Started](#getting-started)
2.  [Install Angular CLI Globally and Packages](#install-angular-cli-globally-and-packages)
3.  [Imported ngx-foundation Modules](#imported-ngx-foundation-modules)
4.  [Development Server](#development-server)
5.  [API and Examples](#api-and-examples)
6.  [Code Scaffolding](#code-scaffolding)
7.  [Stylesheets and Assets](#stylesheets-and-assets)
8.  [SCSS Variables](#scss-variables)
9.  [Optional What-input](#optional-what-input)
10. [Build and Tests](#build-and-tests)
11. [Help](#help)
12. [License](#license)

## Getting Started

cd to the directory that you want to install this starter kit to, then do a git clone:

`git clone https://github.com/nthompson777/ngx-foundation-starterkit`

Then rename your project folder.

## Install Angular CLI Globally and Packages

Run `yarn global add @angular/cli` or `npm i -g @angular/cli`

### Install Packages

Simply run `yarn` or `npm install`

If you do not already have Yarn installed, install it globally [here](https://yarnpkg.com/en/docs/install).

### Imported ngx-foundation Modules

All ngx-foundation modules are imported by default and are globally available in your project: `/src/app/shared/ngx-foundation.module.ts`. Remove or comment out the modules that you do not need.

```
import {
  AccordionModule,
  AlertModule,        // Foundation Callouts
  ButtonsModule,
  CarouselModule,     // Foundation Orbit
  CollapseModule,
  BsDatepickerModule,
  BsDropdownModule,   // Foundation Dropdown Menus and Dropdown Panes
  ModalModule,        // Foundation Reveal
  OffcanvasModule,
  PaginationModule,
  ProgressbarModule,
  RatingModule,
  SortableModule,
  TabsModule,
  TimepickerModule,
  TooltipModule,
  TypeaheadModule,
} from 'ngx-foundation';
```

If you are implementing Lazy Loading or don't want to have all modules globally available in your project you will need to remove `import { NgxFoundationModule } from './shared/ngx-foundation.module';` located in `/src/app/app.module.ts` and then import whatever modules you need for each component in your route.

## Development Server

Run `yarn start` or `ng serve` for a dev server. Navigate to `http://localhost:4200/`. The app will automatically reload if you change any of the source files.

## API and Examples

Visit the [ngx-foundation](https://ngxfoundation.com) site to see examples with extensive code snippets.

## Code Scaffolding

Run `ng generate component component-name` to generate a new component. You can also use `ng generate directive|pipe|service|class|guard|interface|enum|module`.

## Stylesheets and Assets

The main stylesheet `/src/styles.scss` contains all of the needed base imports. All other stylesheets are located in the assets directory: `/src/assets/scss`. All Foundation components and the Motion UI Sass Library are imported by default, so be sure to comment out any unneeded Foundation components that you're not using in your project to keep your stylesheet file size smaller.

### SCSS Variables

Add your own unique styling by changing the variables in `/src/assets/scss/_settings.scss`. This overrides the Foundation variables without having to edit the Foundation for Sites settings source file which allows for a near seemless upgrade when updating Foundation.
### Optional What-input

`what-input.js` is imported as a dependency and can be implemented by adding it to the `scripts` array located in the `/angular.json` file. Be sure to add to both "build" and "test".
```
"scripts": [
  "./node_modules/what-input/dist/what-input.min.js"
]
```

## Build and Tests

Run `yarn build` or  `ng build` to build your project. The build artifacts will be stored in the `dist/` directory. Use the `-prod` flag for a production build.

### Running Unit Tests

Run `ng test` to execute the unit tests via [Karma](https://karma-runner.github.io).

### Running end-to-end tests

Run `ng e2e` to execute the end-to-end tests via [Protractor](http://www.protractortest.org/).

## Help

Visit the [ngx-foundation](https://ngxfoundation.com) site to see examples with extensive code snippets.

Reach out to me via Twitter: [@nthompson777](https://twitter.com/nthompson777)

To get more help on the Angular CLI use `ng help` or go check out the [Angular CLI README](https://github.com/angular/angular-cli/blob/master/README.md).

### License

MIT

repository: hector-moya/my-new-chroma

repo_name: hector-moya/my-new-chroma


text:
dotnet-serve
============

[![AppVeyor build status][appveyor-badge]](https://ci.appveyor.com/project/natemcmaster/dotnet-serve/branch/master)

[appveyor-badge]: https://img.shields.io/appveyor/ci/natemcmaster/dotnet-serve/master.svg?label=appveyor&style=flat-square

[![NuGet][main-nuget-badge]][main-nuget] [![MyGet][main-myget-badge]][main-myget]

[main-nuget]: https://www.nuget.org/packages/dotnet-serve/
[main-nuget-badge]: https://img.shields.io/nuget/v/dotnet-serve.svg?style=flat-square&label=nuget
[main-myget]: https://www.myget.org/feed/natemcmaster/package/nuget/dotnet-serve
[main-myget-badge]: https://img.shields.io/www.myget/natemcmaster/vpre/dotnet-serve.svg?style=flat-square&label=myget

A simple command-line HTTP server.

It launches a server in the current working directory and serves all files in it.

## Installation

The latest release of dotnet-serve requires the [2.1.300-preview1](https://www.microsoft.com/net/download/dotnet-core/sdk-2.1.300-preview1) .NET Core SDK or newer.
Once installed, run this command:

```
dotnet install tool --global dotnet-serve
```

## Usage

```
Usage: dotnet serve [arguments] [options]

Arguments:
  path  Base path to the server root

Options:
  -?|-h|--help            Show help information
  -p|--port <PORT>        Port to use [8080]. Use 0 for a dynamic port.
  -a|--address <ADDRESS>  Address to use [<IP_ADDRESS>]
  -o|--open-browser       Open a web browser when the server starts. [false]
  --path-base <PATH>      The base URL path of postpended to the site url.
```

repository: andrewlock/dotnet-serve

repo_name: andrewlock/dotnet-serve


text:
##PyFTP

PyFTP is a better FTP module for Python that builds on top of the default ftplib module. It aims to provide better access to the methods given in ftplib and reduce code repetitiveness.

This module is under development.

###Why build it?

Python's default `ftplib` module, altough fairly powerful, isn't intuitive and simple to use at all. Most of the default methods require using FTP commands as parameters and a lot more.

For Example, to upload a file in ftplib, you need to use the following code:

```
from ftplib import FTP

ftp = FTP(host='<IP_ADDRESS>')
ftp.login()
ftp.storbinary("STOR newname.jpg" , open('img.jpg','rb'))
```

Wait, what is STOR above? Can't Python write that out itself. There is a reason behind that, that is that We can supply another command in place of STOR above. Nice, but most of the time we will be using STOR itself. So there is no need for different commands. In the end, whenever we want to upload files, we will have to write more code.

That is where PyFTP fits in. The repetitiveness is handled by the module itself and you have simpler methods to work with.

In PyFTP, the above code becomes:

```
from ftp import ftp

con = ftp(host='<IP_ADDRESS>') #You are automatically logged in
con.writefile('img.jpg', newname='newname.jpg')
```

See, the entire usage pattern becomes much simpler. Similarly, PyFTP provides different and easier methods for working with ftplib.

Infact, my vision for PyFTP is somewhat like what requests is to urllib. requests is far more easier and better for accessing HTTP resources thatn urllib and PyFTP should become something like that too.

###Inheriting from FTP

In case, any API is not available in PyFTP, you can use the good old ftplib commands with PyFTP too. Because, the `ftp` class of PyFTP inherits from the `FTP` class of ftplib.

###About

PyFTP is under development. PyFTP will be extensively used in my upcoming program, Zoe which provides FTP access to git.

Created By Pradipta. Copyright 2015. MIT Licensed.

repository: geekpradd/PyFTP

repo_name: geekpradd/PyFTP


text:
# Bleak-54

Contrary to popular belief, this theme is not a modified bleak theme, but an extension of the default Casper.

As a result, assets are kept at minimum and properly documented, so it is lighter and easier to follow.

Source can be downloaded from [here](http://github.com/54chi/bleak-54)
You can see this theme running at [54chi.com](http://54chi.com)

# Casper

The default theme for [Ghost](http://github.com/tryghost/ghost/).

To download, visit the [releases](https://github.com/TryGhost/Casper/releases) page.

# Transition effects

Used the PageStackNavigation as a base:
https://github.com/codrops/PageStackNavigation/blob/master/css/demo.css

## Copyright & License

Copyright (c) 2013-2015 Ghost Foundation - Released 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.


text:
---
layout: post
title: Fair Trade Software
---

This is a list of software that I consider to be fairly priced for the user, considering both direct and ad-based revenue models. In general, they are some combination of:

1. Either a fixed price or a low monthly price that reflects the cost of maintainence development and necessary maintainence.
2. Not having monopolistic network effects that let's them exploit their users down the road
3. Not bundled with a content production arm, which tends to create high recurring costs.
4. Supportive of data exports and non-proprietary data formats.

<iframe class="airtable-embed" src="https://airtable.com/embed/shrB4Q47BTuAl7sXX?backgroundColor=purple&viewControls=on" frameborder="0" onmousewheel="" width="100%" height="533" style="background: transparent; border: 1px solid #ccc;"></iframe>

You can add to this list by using this [form](https://airtable.com/shr6VIRHr48Fsao9p). I don't have a financial interest in any software except Insight and Quora, neither of which falls into any category listed here.

repository: abhinavsharma/blog

repo_name: abhinavsharma/blog


text:
# switchlang - simplest way to internationalize your website in php from scratch

## Getting Started
switchlang is a class allowing to easily internationalize a website using json files.

## Prerequisites
PHP 5 >= 5.2.0, PECL json >= 1.2.0, PHP 7

## How to use
```composer init```

```php
<?php
//path : index.php

require 'vendor/autoload.php';
//...
```

2nd : create new Lang class (here, we use Lang(); in 'app/class/Lang.php')
```php
//...
$lang = new App\Lang();
$json = $lang->expose();
```
3rd : use $json->variable, that you define in your 'app/i18n/xx.json'
```php
<?= $json->homeTitle; ?>
```

## How to add languages ?

To add more languages, create a ```json``` file with the language name, keep the variables and replace the text

**Example**

* German : de.json
* Polish : pl.json

The end

repository: cradlenico/switchlang

repo_name: cradlenico/switchlang


text:
# Cli
Simple console cli

## cmd/example
```go
package main

import (
	"github.com/alexsuslov/cli"
	"os"
)

func main() {
	if err := cli.
		New("cli", "Example Cli").
		Action(os.Args); err != nil {
		panic(err)
	}
}
```

```.sh
> go run cmd/example/example.go
Example Cli
---
> cli help
return this help

```
### Add Action
AddAction

    - command   // string
    - action    // function func(args []string)error
    - help      // template help

```go
    New("covid-cli", "ECDC - RSS - COVID-19").
		AddAction("all", All(feedUrl), helpTemplate).
		AddAction("json", Json(feedUrl), helpJsonTemplate)
```

## cmd/example1
```bash
 go run cmd/example1/example.go json | jq

{
  "title": "ECDC - RSS - COVID-19",
  "link": "https://www.ecdc.europa.eu/en",
  "language": "en",
  "items": [
    {
      "title": "Rapid Risk Assessment: Resurgence of reported cases of COVID 19 in the EU/EEA, the UK and EU candidate and potential candidate countries",
      "description": "While decreasing trends in disease incidence are being observed in Europe overall (12% decrease in 14-day incidence of reported cases between 16 and 30 June), there is still community transmission reported in most EU/EEA countries, the UK and EU candidate and potential candidate countries. Additionally, some countries are reporting a resurgence of observed cases or large localised outbreaks.",
      "link": "https://www.ecdc.europa.eu/en/publications-data/rapid-risk-assessment-resurgence-reported-cases-covid-19",
      "published": "Thu, 02 Jul 2020 14:00:00 +0200",
      "publishedParsed": "2020-07-02T12:00:00Z",

```

repository: alexsuslov/cli

repo_name: alexsuslov/cli


text:
# SlackCommands
Random slack commands I have for personal usage

## Setup
Copy config.js.dist to config.js
```bash
cp config.js.dist config.js
```

And fill in the values indiciated by [CHANGEME]

## Commands

### /ualookup <user-agent-string>

**Example Usage:**
```
/ualookup Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; .NET CLR 1.1.4309)
```
**Example Response:**
```
OS: Windows XP
Device Type: Desktop
OS Version: Windows NT 5.1
Browser Name: Internet Explorer
Browser Version: 6.0
```

repository: mrferos/SlackCommands

repo_name: mrferos/SlackCommands


text:
This is my personal build of st.  I used a number of patches in this build to make st more "sensible" rather than "suckless."  The patches I added to this build include:
+ alpha (for transparency)
+ font2 (to allow setting more than one font, useful when the default font has missing glyphs)
+ scrollback (scrollback through terminal using Shift+PageUp/PageDown.)
+ scrollback mouse altscreen (allows scrolling using Shift+MouseWheel.)

# Installing st-distrotube on Arch Linux

All you need to do is download the PKGBUILD from this repository.  Then run the following command:

	makepkg -cf

This will create a file that ends in .pkg.tar.xz (for example, st-distrotube-git-6.2-1-x86_64.pkg.tar.xz).  Then run:

	sudo pacman -U *.pkg.tar.xz

Alternately, you could also install dwm-distrotube from the AUR using an AUR helper such as yay:

	yay -S st-distrotube-git

NOTE: Installing st-distrotube-git conflicts with the standard st package.  If you already have st installed, you will be asked if you want to remove st and install st-distrotube-git instead.

# Installing st-distrotube on other Linux distributions

Download the source code from this repository or use a git clone:

	git clone https://gitlab.com/dwt1/st-distrotube.git
	cd st-distrotube
    sudo make clean install

NOTE: Installing st-distrotube will overwrite your existing st installation so make a backup of your current config if you need it.


text:
### Creating an Issue

If you have a question on how something works, or its expected functionality, you might want to visit the [Ionic Forum](http://forum.ionicframework.com/) first.

If you think you have found a bug, or have a new feature idea, please start by making sure it hasn't already been [reported](https://github.com/ionic-team/ionic/issues?state=open). You can search through existing issues to see if someone's reported one similar to yours.

If not, then [create a codepen.io](http://codepen.io/ionic/public-list) that demonstrates the problem (try to use as little code as possible: the more minimalist, the faster we can debug it). Also, please do not group multiple topics into one issue, but instead each should be its own issue.

Next, [create a new issue](https://github.com/ionic-team/ionic/issues/new) that thoroughly explains the problem, how to reproduce the issue, and provide any additional information such as code examples and error logs.

 Issues that violate the open source spirit of this community, or  any of the guidelines listed here, may result in your Issue being deleted or reposted to our Forum, a better place for debate and discussion. If you wish to contribute, either make your response respectful or do not bother to respond. You’ll find it’s pretty ineffective.

Simply put: be respectful and act like an adult. Critiques are better made on the Forum. If you can’t do that, this isn’t a community  for you.

### Pull Request Guidelines

When in doubt, keep your pull requests small. To give a PR the best chance of getting accepted, do not bundle more than one "feature" or bug fix per PR. Doing so makes it very hard to accept it if one of the fixes has issues.

It's always best to create two smaller PRs than one big one.

### Style

Always use two spaces, no tabs. This goes for any HTML, CSS, or Javascript.

### License

By contributing your code to the ionic-team/ionic GitHub Repository, you agree to license your contribution under the MIT license.

## Ionic 1.x

Please read the contributing guide on the ionic website: http://ionicframework.com/contribute/

## Ionic 2.x

See the Ionic 2 [CONTRIBUTING](https://github.com/ionic-team/ionic/blob/2.0/CONTRIBUTING.md) file.

gha_license_id: NOASSERTION


text:
# Pretrained_Model_Pytorch
pytorch pretrained model
---
resnet [Deep Residual Learning for Image Recognition](https://arxiv.org/abs/1512.03385)
---
'resnet18': 'https://download.pytorch.org/models/resnet18-5c106cde.pth',
'resnet34': 'https://download.pytorch.org/models/resnet34-333f7ec4.pth',
'resnet50': 'https://download.pytorch.org/models/resnet50-19c8e357.pth',
'resnet101': 'https://download.pytorch.org/models/resnet101-5d3b4d8f.pth',
'resnet152': 'https://download.pytorch.org/models/resnet152-b121ed2d.pth',

densenet [Densely Connected Convolutional Networks](https://arxiv.org/abs/1608.06993)
---
'densenet121': 'https://download.pytorch.org/models/densenet121-a639ec97.pth',
'densenet169': 'https://download.pytorch.org/models/densenet169-b2777c0a.pth',
'densenet201': 'https://download.pytorch.org/models/densenet201-c1103571.pth',
'densenet161': 'https://download.pytorch.org/models/densenet161-8d451a50.pth',

inception_v3 [Rethinking the Inception Architecture for Computer Vision](https://arxiv.org/abs/1512.00567)
---
'inception_v3_google': 'https://download.pytorch.org/models/inception_v3_google-1a9a5a14.pth',

vgg [Very Deep Convolutional Networks for Large-Scale Image Recognition](https://arxiv.org/abs/1409.1556)
---
'vgg11': 'https://download.pytorch.org/models/vgg11-bbd30ac9.pth',
'vgg13': 'https://download.pytorch.org/models/vgg13-c768596a.pth',
'vgg16': 'https://download.pytorch.org/models/vgg16-397923af.pth',
'vgg19': 'https://download.pytorch.org/models/vgg19-dcbb9e9d.pth',
'vgg11_bn': 'https://download.pytorch.org/models/vgg11_bn-6002323d.pth',
'vgg13_bn': 'https://download.pytorch.org/models/vgg13_bn-abd245e5.pth',
'vgg16_bn': 'https://download.pytorch.org/models/vgg16_bn-6c64b313.pth',
'vgg19_bn': 'https://download.pytorch.org/models/vgg19_bn-c79401a0.pth',

squeezenet [SqueezeNet: AlexNet-level accuracy with 50x fewer parameters and <0.5MB model size](https://arxiv.org/abs/1602.07360)
---
'squeezenet1_0': 'https://download.pytorch.org/models/squeezenet1_0-a815701f.pth',
'squeezenet1_1': 'https://download.pytorch.org/models/squeezenet1_1-f364aa15.pth',

alexnet [ImageNet Classification with Deep Convolutional Neural Networks](https://papers.nips.cc/paper/4824-imagenet-classification-with-deep-convolutional-neural-networks.pdf)
---
'alexnet': 'https://download.pytorch.org/models/alexnet-owt-4df8aa71.pth',


text:
python-blitline
===============

```markdown
# supported on python >= 3
```

Python client for blitline service. It is a thin wrapper over the JSON API.

Install with pip:

    $ pip install python-blitline

Documentation
=============
There is no formal documentation, but this is an example:

```python
import blitline as b

# Your Application ID
BLITLINE_ID = "XXXXXXXXXXXXXXXXXXXX"

blitline_avatar = b.Job(
    b.ResizeToFit(
        width=165,
        height=165,
        save=b.S3Destination(
            bucket="my-s3-bucket",
            key='avatars/{username}.jpg',
            headers={
                'Content-Type': 'image/jpg',
            })))

for u in usernames:
    SRC_URL = "http://example.org/pics/{username}.jpg".format(username=u)
    res = blitline_avatar(BLITLINE_ID, SRC_URL, username=u)

    # You can do several things with a running job:

    # res.wait() -> wait for job end (default timeout: 5s)
    # res.open(DEST_IMAGE) -> open the specified destination image (streamed download)
    # res.download(DEST_IMAGE, output_file) -> download the specified image and write it to the output file
    # res.download_all(DIR) -> download all output images in the specified directory
```

repository: greenapes/python-blitline

gha_language: Python

repo_name: greenapes/python-blitline


text:
---
title: How to optimize online learning in the age of coronavirus
date: 2020-03-04T16:33:40.124Z
draft: false
---
The article deal with the solutions to optimize online learning with a five key. The article is from **phys.org** and was written by **Andrew Martin**.

Due to the spread of the new coronavirus, online learning for school students is increasing. In order to remedy this, the educational psychologist who wrote this article, propose five key considerations for educators : Instruction, Content, Motivation, Relationships, Mental Health.

1. **Instruction**

Regarding the principles of Load Reduction Instruction, online lessons must be very clear and well-structured, delivered in little chunks. When the the students have the basics, they can then provide more independent and self-directed online learning activities.

2. **Content**

Moreover, the material is very important. The teacher have to be sure to use the best material in order to provide the most comfortable lesson to the students. Also, it is important that the content is not too difficult too soon in order to not confusing the student early in the learning process.

3. **Motivation**

There is one area of motivation particularly relevant to online learning: self-regulation which is represented in the Wheel by self- and task-management, planning, and persistence.

4. **Relationships**

Concerning this point, in an online environment, it is recommended that teachers maintain contact with the class in different ways, for instance : via email, the school's online learning platform, video, blogs, and class chat-groups.

5. **Mental Health**

If mental health hurts, learning usually suffers. As a result, it is important that all students are clearly informed of who to contact inside or outside the school if they are in difficulties.

<https://phys.org/news/2020-03-optimize-online-age-coronavirus.html>

repository: lucas-clementei/english-blog

repo_name: lucas-clementei/english-blog


text:
# Smart Grid Metering Application

Table of Contents:
+ [Pre-requisits](#prerequisits)
+ [Architecture & Implementation](#architecture)
+ [Getting Started](#gettingstarted)

##  Pre-requisites
+ [Node.js >= v6.5.0](https://nodejs.org/en/)
+ [Serverless Framework](https://serverless.com/)
+ [AWS account](https://aws.amazon.com/)
+ [AWS Provider Credentials](https://serverless.comaws )

##  Architecture & Implementation

![SMGA Architecture](./documentation/sgma-architecture.jpg)

#### IngestValue Function (Lambda: [DOCS](https://aws.amazon.com/de/documentation/lambda/)/[SDK](http://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Lambda.html))
The IngestValue function accepts new meter values from meters. It checks
 new meter values for completeness and converts them into a canonical
 data format. Finally, meter values are pushed to downstream functions:
 PersistValue function and PredictValue function.

Example Client Input:
```
{
    "id": "DE00056366740S2031372170000000000010001080000",
    "timestamp":<PHONE_NUMBER>,
    "value": "+000000010+1"
}
```

Example Client Response:
```
{
    "statusCode": "202"
}
```
#### PersistValue Function (Lambda: [DOCS](https://aws.amazon.com/de/documentation/lambda/)/[SDK](http://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Lambda.html))
The PersistValue function persists new meter values without any
processing in the DynamoDB table Values. The PersistValue function is a
downstream function of the IngestValue function.

#### PredictValue Function (Lambda: [DOCS](https://aws.amazon.com/de/documentation/lambda/)/[SDK](http://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Lambda.html))
The PredictValue function predicts future values of a timeseries based
on measured values for n time intervals into the future. To derive
the model, missing values are loaded from the DynamoDB table Values.
Predictions are stored to the DynamoDB table Predictions. If a predicted
value increases or decreases by an absolute value that is higher as a
configurable threshold, a notification is pushed to a corresponding
Kinesis stream Predictions.

#### ReadValues Function (Lambda: [DOCS](https://aws.amazon.com/de/documentation/lambda/)/[SDK](http://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Lambda.html))
The ReadValues functions allows to query metered values in a time a
configurable time [start...end] interval. Timestamps are UNIX-Timestamps
with second precision.

Example Client Request:
```
{
    "id": "DE00056366740S2031372170000000000010001080000",
    "start":<PHONE_NUMBER>,
    "end":<PHONE_NUMBER>
}
```

Example Client Response:
```
[
    {
        "id": "DE00056366740S2031372170000000000010001080000",
        "value": "+000000040+1",
        "timestamp":<PHONE_NUMBER>
    },
    {
        "id": "DE00056366740S2031372170000000000010001080000",
        "value": "+000000010+1",
        "timestamp":<PHONE_NUMBER>
    }
]
```

#### ReadPredictions Function (Lambda: [DOCS](https://aws.amazon.com/de/documentation/lambda/)/[SDK](http://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Lambda.html))
The ReadPredictions functions allows to query predicted metered values
in a time a configurable time [start...end] interval. Timestamps are
UNIX-Timestamps with second precision.

Example Client Request:
```
{
    "id": "DE00056366740S2031372170000000000010001080000",
    "start":<PHONE_NUMBER>,
    "end":<PHONE_NUMBER>
}
```

Example Client Response:
```
[
    {
        "id": "DE00056366740S2031372170000000000010001080000",
        "value": "+000000017+1",
        "timestamp":<PHONE_NUMBER>
    },
    {
        "id": "DE00056366740S2031372170000000000010001080000",
        "value": "+000000019+1",
        "timestamp":<PHONE_NUMBER>
    },
    {
        "id": "DE00056366740S2031372170000000000010001080000",
        "value": "+000000019+1",
        "timestamp":<PHONE_NUMBER>
    },
    {
        "id": "DE00056366740S2031372170000000000010001080000",
        "value": "+000000016+1",
        "timestamp":<PHONE_NUMBER>
    }
]

```
#### ReadNotificatitons Function (Lambda: [DOCS](https://aws.amazon.com/de/documentation/lambda/)/[SDK](http://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Lambda.html))
The ReadPredictions functions allows to query predicted metered values
for timeseries of interest.

Example Client Request:
```
{
    "id": "DE00056366740S2031372170000000000010001080000",
    "start":<PHONE_NUMBER>
}
```

Example Client Response:
```
[
    {
        "id": "DE00056366740S2031372170000000000010001080000",
        "timestamp":<PHONE_NUMBER>,
        "value": "+000000016+1"
    },
    {
        "id": "DE00056366740S2031372170000000000010001080000",
        "timestamp":<PHONE_NUMBER>,
        "value": "+000000019+1"
    },
    {
        "id": "DE00056366740S2031372170000000000010001080000",
        "timestamp":<PHONE_NUMBER>,
        "value": "+000000019+1"
    }
]

```
#### Values Table (DynamoDB: [DOCS](https://aws.amazon.com/de/documentation/dynamodb/)/[SDK](http://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/DynamoDB.html))

The Values table stores submitted and metered meter values.

Schema and example data:

| id                                            | timestamp  | value        |
| --------------------------------------------- |:----------:| ------------:|
| DE00056366740S2031372170000000000010001080000 |<PHONE_NUMBER> | +000000010+1 |
| DE00056366740S2031372170000000000010001080000 |<PHONE_NUMBER> | +000000040+1 |
| DE00056366740S2031372170000000000010001080000 |<PHONE_NUMBER> | +000000010+1 |

#### Predictions Table (DynamoDB: [DOCS](https://aws.amazon.com/de/documentation/dynamodb/)/[SDK](http://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/DynamoDB.html))

The Values Predictions table stores predicted values that are calculated
based on an analytical model. Thus, stored values have never been
submitted or metered.

Schema and example data:

| id                                            | timestamp  | value        |
| --------------------------------------------- |:----------:| ------------:|
| DE00056366740S2031372170000000000010001080000 |<PHONE_NUMBER> | +000000010+1 |
| DE00056366740S2031372170000000000010001080000 |<PHONE_NUMBER> | +000000040+1 |
| DE00056366740S2031372170000000000010001080000 |<PHONE_NUMBER> | +000000010+1 |

#### Notifications Stream (Kinesis: [DOCS](https://aws.amazon.com/de/documentation/kinesis/)/[SDK](http://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Kinesis.html))
The Notifications stream publishes predicted meter values that represent
an absolute change in value that is greater than a configurable threshold.

##  Getting Started

##### Deploy Application
```
sls deploy
```

#### Load Initial Dataset
```
sls invoke -f persistValueFunction -p persistValue/event1.json
sls invoke -f persistValueFunction -p persistValue/event2.json
sls invoke -f persistValueFunction -p persistValue/event3.json
```

#### Emulate Meter Client
```
sls invoke -f ingestValueFunction -p ingestValue/event.json
sls invoke -f ingestValueFunction -p ingestValue/event2.json
sls invoke -f ingestValueFunction -p ingestValue/event3.json
```

#### Emulate Grid Operator Client
```
sls invoke -f readValuesFunction -p readValues/event.json
```

#### Emulate Grid Controller Client
```
sls invoke -f readPredictionsFunction -p readPredictions/event.json
```

#### Emulate Notification Service Client
```
sls invoke -f readNotificationsFunction -p readNotifications/event.json
```

#### Check Executions
```
sls logs -f ingestValueFunction
sls logs -f persistValueFunction
sls logs -f predictValueFunction
```

#### Remove Deployment
```
sls remove
```

repository: markusklems/costradamus

repo_name: markusklems/costradamus


text:
# Attempt

A tiny Crystal library for trying code blocks again and again.

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

## Installation

Add this to your application's `shard.yml`:

```yaml
dependencies:
  attempt:
    github: mosop/attempt
```

## Code Samples

### Trying 5 Times

```crystal
response = Attempt.times(5).start do
  begin
    response = HTTP::Client.get("http://unstable.net")
    break response if response.success?
  rescue
  end
end

if response
  puts response.body
else
  raise "UNSTABLE!"
end
```

### Wait 60 Sec. Before a Retry

```crystal
response = Attempt.times(5).wait(60).start do
  begin
    response = HTTP::Client.get("http://unstable.net")
    break response if response.success?
  rescue
  end
end
```

### Every Hour Forever

```crystal
Attempt.wait(60 * 60).start do
  begin
    response = HTTP::Client.get("http://api.cat.pics/links.json")
    File.write("/path/to/kitty.json", response.body) if response.success?
  rescue
  end
end
```

### Wait 10 Sec. Before the First Attempt

```crystal
`rails s`
response = Attempt.prewait(10).start do
  begin
    response = HTTP::Client.get("http://localhost:3000")
    break response if response.success?
  rescue
  end
end
```

## Usage

```crystal
require "attempt"
```

<!--
and see [API Document](http://mosop.me/attempt/Attempt.html).
-->

repository: mosop/attempt

repo_name: mosop/attempt


text:
---
date: '2008-02-06 23:36:46'
layout: post
slug: on-software-development-the-myth-of-no-maintenance-etc
status: publish
comments: true
title: 'On software development: the myth of no maintenance etc.'
wordpress_id: '205'
---

[Jeremy Miller](http://codebetter.com/blogs/jeremy.miller/) put a very intersting post up about the [First causes in software development](http://codebetter.com/blogs/jeremy.miller/archive/2008/02/06/173994.aspx)
While I don't always like the how of delivering his messages, I think Jeremy is generally spot on. In fact he seems to voice my thoughts much more eloquently than I ever could. Anyway his post or series of posts is dealing with some of the choices he made concerning tools and development philosophy and it also tries to explain that while these tools seem to work today, there won't be anything stopping him if something better comes along.

Now in that article he links to an article by the pragmatic programmers on the principle of DRY and orthogonality. For me the biggest problem of software development is not the techniques or the patterns but it's the actual language people use. Till this day I still don't know what orthogonality means although I understand what that word means in a development context. There are countless examples where people overcomplicate things by using difficult words, this is just one more. Anyway I digress :)

The article series he's referring to is pretty interesting. If you have some time to kill I suggest you read them. It are 10 articles:
[Part I - Don't live with broken windows](http://www.artima.com/intv/fixit.html)

[Part II - Orthogonality and the DRY Principle](http://www.artima.com/intv/dry.html)

[Part III - Good enough software](http://www.artima.com/intv/goodenough.html)

[Part IV - Abstraction and Detail](http://www.artima.com/intv/metadata.html)

[Part V - Building adaptable systems](http://www.artima.com/intv/adapt.html)

[Part VI - Programming close to the domain](http://www.artima.com/intv/domain.html)

[Part VII - Programming is gardening, not engineering](http://www.artima.com/intv/garden.html)

[Part VIII - Tracer Bullets and Prototypes](http://www.artima.com/intv/tracer.html)

[Part IX - Programming defensively](http://www.artima.com/intv/defense.html)

[Part X - Plain text and xml](http://www.artima.com/intv/plain.html)

The reason that I put these links up is not only because they are a great read but also because one of the things they say in one of the articles is that after you wrote 10 lines of code or so you're effectively in maintenance mode the green field is gone. And that couldn't be more true after I had some internal discussion about it I definitely agree with that statement and as such one of the primary goals of your development should not be on getting it out the door as quickly as possible but building it in such a way that you or somebody else can get in there and make changes without throwing away half the code base.

I hope you enjoy them as much as I did

extension: markdown


text:
---
layout: post
title: "OsBBX11"
description: ""
category: genes
tags: [transcription factor, stress, salt, tolerance, salt tolerance, salt stress, breeding]
---

* **Information**
    + Symbol: OsBBX11
    + MSU: [LOC_Os04g41560](http://rice.uga.edu/cgi-bin/ORF_infopage.cgi?orf=LOC_Os04g41560)
    + RAPdb: [Os04g0493000](https://rapdb.dna.affrc.go.jp/locus/?name=Os04g0493000)

* **Publication**
    + [OsBBX11 on qSTS4 links to salt tolerance at the seeding stage in Oryza sativa L. ssp. Japonica.](http://www.ncbi.nlm.nih.gov/pubmed?term=OsBBX11 on qSTS4 links to salt tolerance at the seeding stage in Oryza sativa L. ssp. Japonica.%5BTitle%5D), 2023, Front Plant Sci.

* **Genbank accession number**

* **Key message**
    + In conclusion, this study identified OsBBX11 as a salt-tolerance gene, and one SNPs in the OsBBX11 promoter region can be used to identify its interacting transcription factors
    + Transgenic plants using knockout-based technology and demonstrated that Na(+) and K(+) in the roots of the functional-loss-type OsBBX11 were translocated largely to the leaves under 120 mmol/L NaCl compared with the wild-type, causing osbbx11 leaves to die after 12 days of salt stress due to an imbalance in osmotic pressure
    + OsBBX11 on qSTS4 links to salt tolerance at the seeding stage in Oryza sativa L. ssp. Japonica.
    + This provides a theoretical basis for finding the molecular mechanism of OsBBX11 upstream and downstream regulation of salt tolerance and molecular design breeding in the future

* **Connection**

[//]: # * **Key figures**


text:
# Symmetric NMF for graph clustering

**Symmetric nonnegative matrix factorization (SymNMF)** is an unsupervised algorithm for graph clustering, and has found numerous use cases with itself or its extensions [(Google Scholar)](https://scholar.google.com/scholar?oi=bibs&hl=en&cites=5171938689932689716), many of which are in bioinformatics and genomic study.

This Matlab package is developed for the following paper:
```
Da Kuang, Chris Ding, Haesun Park,
Symmetric Nonnegative Matrix Factorization for Graph Clustering,
The 12th SIAM International Conference on Data Mining (SDM '12), pp. 106--117, 2012.
```
and a journal version:
```
Da Kuang, Sangwoon Yun, Haesun Park,
SymNMF: Nonnegative low-rank approximation of a similarity matrix for graph clustering,
Journal of Global Optimization, 62(3):545-574, 2015.
```
Please cite this paper if you find the code useful.

## Problem Statement

SymNMF is defined as:
```
    min_H f(H) = ||A - HH'||_F^2 subject to H >= 0
```
where the input A is an N-by-N symmetric matrix containing pairwise similarity values, and the output H is an N-by-K nonnegative matrix indicating clustering assignment. SymNMF uses the same input similarity matrix A as in spectral clustering, but imposes different constraint on H.

All these Matlab functions are documented. To get started, run the script `test.m` Please find the helper texts at the beginning of each M-file for more options.

## Basic usage

To run SymNMF on a similarity matrix:
```
H = symnmf_newton(A, k)
```
or:
```
H = symnmf_anls(A, k)
```
To run SymNMF on a data matrix for graph clustering:
```
idx = symnmf_cluster(X, k)
```
Please refer to the documentation for more options. A summary of the functions in this package is listed below:

User functions (API):
* `symnmf_newton.m`: Newton-like algorithm for SymNMF, accepting a similarity matrix as input
* `symnmf_anls.m`: ANLS algorithm for SymNMF, accepting a similarity matrix as input
* `symnmf_cluster.m`: A wrapper for graph clustering, accepting a data matrix as input

Auxiliary files:
* `scale_dist3.m`: Computes the affinity matrix of a dense graph with Gaussian similarity
* `scale_dist3_knn.m`: Computes the affinity matrix of a sparse graph with Gaussian similarity
* `inner_product_knn.m`: Computes the affinity matrix of a sparse graph with inner product similarity
* `dist2.m`: Computes a matrix of squared Euclidean distance values
* `nnlsm_blockpivot.m`: The block pivoting algorithm for nonnegative least squares (courtesy of Jingu Kim)
* `graph.data`: A simple graph clustering example
* `test.m`: A test script running on the graph.data example

## Which algorithm to choose

If the similarity matrix is dense (i.e. N is not extremely large and an N-by-N dense matrix can be stored into memory), then we recommend `symnmf_newton`.

If the similarity matrix is sparse (especially when an N-by-N dense matrix cannot be stored into memory), then we recommend `symnmf_anls`. (the default option in `symnmf_cluster`)

`symnmf_newton` will generate more accurate solutions, whereas `symnmf_anls` is generally faster and applicable to larger problems. Please find more options for further acceleration in the helper text of `symnmf_anls`.

An *affinity matrix* contains the raw edge weights in a graph, whereas a *similarity matrix* is formed based on the affinity matrix and is directly fed into `symnmf_newton`.

For example, `scale_dist3`, `scale_dist3_knn`, `inner_product_knn` routines all compute the affinity matrix; the similarity matrix in normalized cut is a normalized version of the affinity matrix.

repository: cmap/cmapM

repo_name: cmap/cmapM


text:
# Chapter 11
## Build Your Own Glass

### Requirements

To run this project you need to have Android Studio installed, including the minimum required SDK/s.

### How to use this project

1. Clone the repository `git clone git@github.com:pro-android-wearables/chapter-11.git`
2. Import the project to your Android Studio IDE

### License

    Copyright 2015 David Cuartielles & Andreas Göransson

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at

      http://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.


text:
# _Parcel Estimator_

#### _A Ruby app that estimates shipping cost based on size, time and distance, 09.11.2017_

#### By _**Margaret Berry and Dan Danilyuk**_

## Project Goals
* _Get more comfortable using the Sinatra framework._

## Specifications
| Spec              | Input | Output |
|-------------------|-------|--------|
| Returns volume of a package.     | 3, 3, 3    | 27      |

## Setup/Installation Requirements
_Run the following commands in Terminal:_

1. `$ git clone` [this repository](https://github.com/codemargaret/parcel_estimator_ruby.git)
2. `$ cd parcel_estimator_ruby`
3. `$ ruby app.rb`
4. _Navigate to localhost:4567_

## Known Bugs
_The cost part of the cost to ship function does not currently work. The app only returns volume and input parameters._

## Support and contact details

_If you have questions, comments, or concerns, please contact [Margaret](codeberry1@gmail.com).  Feel free to make a contribution to the code._

## Technologies Used
* _Ruby_
* _Sinatra_

### License
*This software is licensed under the MIT license.*

Copyright (c) 2017 **_Margaret Berry and Dan Danilyuk_**


text:
### PyNN Model

This version of the network can run in PyNN using simulator NEST

To simulate the activity of 2000 cells (1600 excitatory in red, 400 inhibitory in blue with 0.75 of the inhibitory cells (darker blue) perturbed), and then plot result:

```
python runNetwork.py nest .75 2000
python analysis_perturbation_pynn.py .75 2000
```

![0.75](test_0.75.png)

To simulate activity (2000 cells total, with 0.1 of the inhibitory cells perturbed), and then plot result:

```
python runNetwork.py nest .1 2000
python analysis_perturbation_pynn.py .1 2000
```

![0.1](test_0.1.png)

The script [runall.sh](runall.sh) will run 40 simulations and plot the average of these:

![40](rates.png)

gha_language: Matlab


text:
# Udacity Robotics Term 1 Deep Learning Project
## Specification
This specification for this project is a fully convolutional network (FCN). This network will be trained to segment an input image into three classes - identified by distinct colors - target human, other human, and other.

## FCN Discussion
Convolutional Neural Networks (CNNs) have had great success building image classifiers. That is, given an input image and a label defining the class for that image, the CNN is trained to predict the label for a new image. The layers of the CNN get progressively deeper, increasing number of filters, and at each layer the CNN learns progressively larger abstract concepts within the image. At the lowest level, for example, the CNN may be learning to recognize features such as lines while at the highest level the CNN learns things like faces. These layers are referred to as encoders.

The CNN is successful for image classification but the task here is for a real-time segmentation of the image. One way to consider this task is that we will do a simultaneous classification of each pixel in the image. A conventional approach of a CNN is to add some number of fully connected (dense) layers after the encoders and it is from those fully connected layers that we end at some number of class labels. Using a fully connected layer for each pixel would produce a network with so many parameters as to be untrainable. This is where the FCN comes to the rescue.

The desired output is an image consisting of three colors where each pixel is colored based upon the class of that pixel. The desire is to learn to build such an image from the abstract features of the scene that were learned in the encoding layers. This operation is the inverse of the encoding layers where the depth of the image progressively increased while the height and width progressively decreased. These layers are, appropriately, the decoders or deconvolutional layers. At the top of the decoder layers is a convolutional layer with 3 filters - one for each of the output clases using a kernel size of 1 and a stride of 1 as each pixel is written individually.

One issue with producing a dense output image is the potential for loss of information that is vital to production of the output image. This issue is common when the sole input to a given decoder layer is the output of the preceding layer. In the as-built FCN, we try to mitigate the impact of this issue by adding skip connections. Each decoding layer takes as input the output of the previous decoding layer as well as the output of one of the encoding layers.

Together we have an encoder-decoder architecture that effectively serves to translate an image into an alternate representation of that image that reflects knowledge learned from training. An encoder-decoder architecture may tend to be very deep with a large number of learned parameters. This can be problematic for training and could be disastrous for inference in a real-time environment such as the quadcopter.

Connecting the encoding layers with the decoding layers is a 1x1 convolutional layer. That layer provides the simliar features to a fully connected layer but spatial information is preserved. In the case of the as-built FCN, we retain the 4D tensor with depth 512. This contrasts to a fully connected layer which would result in a 2D tensor. The 1x1 convolution allows for the translation from one shape to another allowing us to take a pretrained encoder and use that in our network with ease.

### High Level Architecture
The high-level architecture of the built FCN looks like

| Layer | Filters | Kernel | Strides | Output Shape |
| -------- |:----------:|:------|:---------|:------------------:|
| Input | N/A  | N/A | N/A | 160x160x3  |
| Encoder 1 | 64 | 3x3 | 2 | 80x80x64 |
| Encoder 2 | 256 | 3x3 | 2 | 40x40x256 |
| Encoder 3 | 512 | 3x3 | 2 | 20x20x512 |
| 1x1 Convolution | 1x1 | 512 | 1 | 20x20x512 |
| Decoder 1 | 512 | 3x3 | 1 | 40x40x512 |
| Decoder 2 | 256 | 3x3 | 1 | 80x80x256 |
| Decoder 3 | 64 | 3x3 | 1 | 160x160x64 |
| Conv2D Output | 3 | 1x1 | 1 | 160x160x3 |

The depth of 3 for the input layer corresponds to the RGB color scheme - 1 value for each of the color components. The depth of 3 for the output layer corresponds to the number of classes we recognize in this neural network - target human, other human, everything else.

The number of encoder and decoder layers as well as the number of filters chosen within each layer was partially determined by the memory limitations of the machine used for training. It was not possible in my environment to exceed 512 filters. Nor was it possible to exceed three encoder / decoder layers given the use of two layers within each encoding / decoding layer as noted below. In general, I tried to maximize the number of filters available given the memory constraints.

[image_0]: ./fcnarch.png
![Figure 1: Fully Convolutional Network Architecture][image_0]

### Encoder Architecture
The encoder layer itself consists of two separable 2D convolutional batch normalization layers. The second layer conv2d layer uses a stride of 1 so as not to impact the shape. Experimentation with architectures revealed that this additional stride 1 layer was valuable in producing a better IoU. The convolutional layer uses a kernel size of 3 which is a standard recommendation employed in VGG16 among others.

| Layer | Stride |
| ------- |:--------:|
| Conv2D | 2 |
| Batch Normalization | N/A |
| Conv2D | 1 |
| Batch Normalization | N/A |

### Decoder Architecture
The decoder layer combines the inputs from the previous layer with the outputs of an earlier layer and runs two separable 2D convolutional batch normalization layers on the concatenated result. In general, a decoder layer takes as input the output of the previous layer having shape (x,x,w) and the output of a decoder layer of shape (2x,2x,y). In order to combine these two layers, the (x,x,w) layer is upsampled to (2x,2x,w) resulting in the concatenated layer (2x,2x,w+y). It is on that concatenated result that we run the convolution producing an output of (2x,2x,z) where z is the number of filters in the convolutional layer.

| Layer | Stride |
| ------- |:--------:|
| Upsample | |
| Concatenate ||
| Conv2D | 1 |
| Batch Normalization | |
| Conv2D | 1 |
| Batch Normalization | |

## Training Data Collection
I constructed a variety of scenes within the simulation with the target hero, non-target humans, varying backgrounds, and varying elevation of the quad. I generally tried to collect at least 500 images from each camera for a given scene, sometimes as many as several thousand from each camera. From this raw data set, I downsampled to force mostly images with the target hero. For example, given a data set I would target that 80% of the resulting images had the hero. The remaining 20% of images would be randomly selected from the other images. After preprocessing, I used the sklearn train_test_split function to randomly allocate 80% of these images to training and 20% to validation. The end result after preprocessing was that I added ~4800 images to the training data set and ~1300 images to the validation data set. The additional source code files to assist with the data preparation process are preserve_target_ratio.py and split_train.py.

## Hyperparameter Selection
The overall method of hyperparameter selection was brute force and the end result was:

| Parameter | Value |
| ------------- |:--------:|
| Epochs | 15 |
| Batch Size | 40 |
| Learning Rate | 0.0002 |
| Training Steps per Epoch | 225 |
| Validation Steps per Epoch | 61 |

The batch size was chosen based upon memory limitations of the AWS instance. The number of training steps per epoch and validation steps per epoch were derived from the total number of samples and the batch size.

	training_steps = ceil(training_samples / batch_size)
	validation_steps = ceil(validation_samples / batch_size)

The learning rate was chosen as a result of experimentation. Values of 0.001 and 0.0005 seemed to result in convergence difficulties while 0.0001 simply converged too slowly resulting in too long training stages. 0.0002 with the number of epochs set to 15 avoided overfitting while keeping the total training time on the AWS instance less than 2.5h.

Figure 2 shows the training and validation loss curve.

[image_1]: ./losscurve.png
![Figure 2: Training and Validation Loss Versus Epoch][image_1]

The table below shows the specific training and validation losses for each training epoch. As you can see, the training and validation losses fall sharply for the first several epochs while stabilizing after epoch 10.

| Epoch | Training Loss | Validation Loss |
| ------- |:----------------:|:-------------------:|
| 1 | 0.839 | 0.557 |
| 2 | 0.335 | 0.175 |
| 3 | 0.144 | 0.093 |
| 4 | 0.080 | 0.053 |
| 5 | 0.054 | 0.047 |
| 6 | 0.041 | 0.039 |
| 7 | 0.035 | 0.033 |
| 8 | 0.029 | 0.028 |
| 9 | 0.025 | 0.024 |
| 10 | 0.023 | 0.025 |
| 11 | 0.021 | 0.024 |
| 12 | 0.019 | 0.023 |
| 13 | 0.018 | 0.024 |
| 14 | 0.017 | 0.024 |
| 15 | 0.016 | 0.021 |

## Results
IoU and evaluation results are shown in the table below

| Test Name | True Positives | False Positives | False Negatives | IoU Background | IoU Other People | IoU Hero |
| ------------- |:-----------------:|:--------------:|:---------------:|:--------------:|:--------------:|:-----------------:|
| Following | 539 | 0 | 0 | 0.996 | 0.360 | 0.887 |
| Non-Visible | 0 | 18 | 0 | 0.989 | 0.781 | 0.0 |
| Visible | 131 | 2 | 170 | 0.997 | 0.441 | 0.245 |

The final score calculated from these intermediate results was** 0.441**.

We can see the effectiveness of the prediction model in the figure below:
[image_2]: ./evaluation1.png
![Figure 3: Example of Predicted Segmentation][image_2]

## Model
The model is located in data/weights/model_weights.h5 and data/weights/config_model_weights.h5.

## Experimentation
The quadcopter successfully found the hero however the inference engine appears to have run too slowly on my host (no gpu). The result was stalls in the quad and the textual output of the inference processing reporting the target found followed by target lost.

## Limitations
The developed model is only valid for differentiating three object types - target human, other human, and everything else. It seems that it should be possible to use a pre-trained inception/resnet/vgg16 model on the CIFAR1000 dataset and use that as part of the segmentation process.

## Future Work
There are multiple techniques available to improve the results of this network. As noted in the limitations, the current network only segments three classes. It would be useful for the network to segment many more classes. For example, the ability to identify obstacles likely in the way of the flight path versus the road. One approach widely used is transfer learning where we could use a pretrained model such as VGG16 to provide many of the layers required. A second technique that would be good to explore is to execute the inference within C++ rather than python to hopefully bring the image processing. A third item to consider is whether this model is over-parameterized. If the model can be simplified in any fashion, inference will be faster and therefore more suitable to a real-time environment.

repository: kscharpf/RoboND-DeepLearning-Project

repo_name: kscharpf/RoboND-DeepLearning-Project


text:
[![Build Status](https://travis-ci.org/WinRb/autodiscover.svg?branch=master)](https://travis-ci.org/WinRb/autodiscover)

Autodiscover
============

Ruby client for Microsoft's Autodiscover Service.

The Autodiscover Service is a component of the Microsoft Exchange architecture. Autoservice clients can access the URLs and settings needed to communicate with Exchange servers, such as the URL of the endpoint to use with the Exchange Web Services (EWS) API.

This library implements Microsoft's "Autodiscover HTTP Service Protocol Specification" to discover the endpoint for an Autodiscover server that supports a specified e-mail address and Microsoft's "Autodiscover Publishing and Lookup Protocol Specification" to get URLs and settings that are required to access Web services available from Exchange servers.

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

This library requires the following Gems:

* HTTPClient
* Nokogiri
* Nori

The HTTPClient Gem in turn requires the rubyntlm Gem for Negotiate/NTLM authentication.

How to Use
----------

```ruby
require 'autodiscover'

client = Autodiscover::Client.new(email<EMAIL_ADDRESS>password: "tps_eq_awesome")
data = client.autodiscover

# Get the EWS endpoint
data.ews_url

# Get an Exchange Version ingestible by EWS
data.exchange_version

# Access the raw Autodiscover data in its entirety
data.response
```

Options
-------

Besides `:email` and `:password`, `Autodiscover::Client` can take a few other options as can the #autodiscover method.

Examples:

```ruby
# Use a different username than your e-mail.
client = Autodiscover::Client.new(email<EMAIL_ADDRESS>password: "tps_eq_awesome", username: 'INITECH\blumbergh')

# Override the domain
client = Autodiscover::Client.new(email<EMAIL_ADDRESS>password: "tps_eq_awesome", domain: "tpsreports.local")

# Set a custom connection timeout
client = Autodiscover::Client.new(email<EMAIL_ADDRESS>password: "tps_eq_awesome", connect_timeout: 5)

# Ignore SSL Errors
client.autodiscover(ignore_ssl_errors: true)
```

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

### Configuring a Rails App to use the latest GitHub master version

	  gem 'autodiscover', :git => 'git://github.com/WinRb/autodiscover.git'

### To install the latest development version from the GitHub master

	  git clone http://github.com/WinRb/autodiscover.git
	  cd autodiscover
	  gem build autodiscover.gemspec
	  sudo gem install autodiscover-<version>.gem

Bugs and Issues
---------------

Limitations:

* Doesn't support querying the DNS for SRV Records

Please submit additional bugs and issues here [http://github.com/WinRb/autodiscover/issues](http://github.com/WinRb/autodiscover/issues)

repository: thorsteneckel/autodiscover

gha_language: Ruby

repo_name: thorsteneckel/autodiscover


text:
# Orbs Starter Kit [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](https://github.com/orbs-network/orbs-starter-kit/pulls)
> Your starting point to build application on Orbs Network.

## Quick start
* Click on [`Use this template`](https://github.com/orbs-network/orbs-starter-kit/generate)
* Clone the resulted repo
* `cd <your-repo-name>`
* `npm install`
* `gamma-cli start-local`
* `gamma-cli deploy ./contracts/counter.go -name counter -signer user1`
* `npm run start`

## Prerequisites
* [Docker for desktop](https://www.docker.com/products/docker-desktop)
* [NodeJS](https://nodejs.org/en/)
* [Gamma-cli](https://github.com/orbs-network/gamma-cli)
* [Go language](https://golang.org/doc/install) (Optional)

## Decentralized Application Architecture
![dapp architecture](https://static.wixstatic.com/media/13b3a9_ff49d3ebf639421eb853c75945e0461a~mv2_d_2450_1342_s_2.png)

## Wired Parts
* Smart Contract example (Counter)
* `orbs-contract-sdk`
* Client side application based on react
* `orbs-client-sdk`

## Available Scripts

In the project directory, you can run:

### `npm start`

Runs the app in the development mode.

Open [http://localhost:4000](http://localhost:4000) to view it in the browser.

The page will reload if you make edits.

You will also see any lint errors in the console.

### `npm test`

Launches the test runner in the interactive watch mode.

See the section about [running tests](https://facebook.github.io/create-react-app/docs/running-tests) for more information.

### `npm run build`

Builds the app for production to the `build` folder.

It correctly bundles React in production mode and optimizes the build for the best performance.

The build is minified and the filenames include the hashes.

Your app is ready to be deployed!

See the section about [deployment](https://facebook.github.io/create-react-app/docs/deployment) for more information.

### `npm run lint`

Runs prettier to do automatic linting of JavaScript files.

## Learn More

* Gamma server and gamma-cli, read [gitbook](https://orbs.gitbook.io/contract-sdk).
* [JavaScript Client SDK](https://github.com/orbs-network/orbs-client-sdk-javascript).
* [Create React App documentation](https://facebook.github.io/create-react-app/docs/getting-started).
* [React documentation](https://reactjs.org/).

repository: geekybot/mystarterkit

repo_name: geekybot/mystarterkit


text:
# angular-joystick [![Build Status](https://travis-ci.org/arthurianx/angular-joystick.png?branch=master)](https://travis-ci.org/arthurianx/angular-joystick)

> Angular Joystick component for hybrid games.

## Demo

[Live Demo](http://arthurianx.github.io/angular-joystick/demo)

## Getting Started

Install with Bower or download the files directly from the dist folder in the repo.

```bash
bower install angular-joystick --save
```

Add `dist/angular-joystick.js` and `dist/angular-joystick.css` to your index.html.

Add `artJoystick` as a module dependency for your module.

```js
angular.module('your_app', ['artJoystick']);
```

## Options

You can use it like this:

```html
<div art-joystick ></div>
```

There's also a full set of options:

* `art-joystick` - The main directive declaration. Example usage `<art-joystick levels="tiers" pagination="true" trigger="callbackID(id, type)" source="dataEndpoint"></art-joystick>`

## Release History
 * v0.1.1 - Launch gh-pages.
 * v0.1.0 - Initial release.

## TODO

repository: ArthurianX/angular-joystick

repo_name: ArthurianX/angular-joystick


text:
# Neural Net Classification

## Running Stuff

-  `deploy_cloudml.py` -- launch a training run on cloudml. Use `--help` to see options

   If not running in the SkyTruth/GFW environment, you will need to edit `deploy_cloudml.yaml`
   to set the gcs paths correctly.

   For example, to run vessel classification in the dev environment with the name `test`:

        `./deploy_cloudml.py --model_name prod.vessel_classification --env dev --job_name test`

   **IMPORTANT**: Even though there is a maximum number of training steps specified, the CloudML
   process does not shut down reliably.  You need to periodically check on the process and kill it
   manually if it has completed and is hanging. In addition, there are occasionally other problems
   where either the master or chief will hang or die so that new checkpoints aren't written, or
   new validation data isn't written out. Again, killing and restarting the training is the solution.
   (This will pick up at the last checkpoint saved.)

- *running training locally* -- this is primarily for testing as it will be quite slow unless you
  have a heavy duty machine:

        python -m classification.run_training \
            prod.fishing_range_classification \
            --feature_dimensions 12 \
            --root_feature_path FEATURE_PATH \
            --training_output_path OUTPUT_PATH \
            --fishing_range_training_upweight 1 \
            --metadata_file training_classes.csv \
            --fishing_ranges_file combined_fishing_ranges.csv \
            --metrics minimal

- `compute_metrics.py` -- evaluate restults and dump vessel lists. Use `--help` to see options

- *running inference* -- Unless you have local access to a heavy duty machine, you should
  probably run this on ComputeEngine as described below.

   - Copy a model checkpoint locally:

      gsutil cp GCS_PATH_TO_CHECKPOINT  ./model.ckpt

   - Run inference job:

    * *Vessel Classification*. This command only infers result for only the test data
      (for evaluation purposes), and infers a seperarate classification every 6 months:

       python -m classification.run_inference prod.vessel_classification \
              --root_feature_path GCS_PATH_TO_FEATURES \
              --inference_parallelism 32 \
              --feature_dimensions 12 \
              --dataset_split Test \
              --inference_results_path=./RESULT_NAME.json.gz \
              --model_checkpoint_path ./model.ckpt \
              --metadata_file training_classes.csv \
              --fishing_ranges_file combined_fishing_ranges.csv \
              --interval_months 6

   - *Fishing localisation*: This infers all fishing at all time points (no `--dataset_split` specification)

         python -m classification.run_inference prod.fishing_range_classification \
                --root_feature_path GCS_PATH_TO_FEATURES \
                --inference_parallelism 32 \
                --feature_dimensions 12 \
                --inference_results_path=./RESULT_NAME.json.gz \
                --model_checkpoint_path ./model.ckpt \
                --metadata_file training_classes.csv \
                --fishing_ranges_file combined_fishing_ranges.csv

## Local Environment Setup

* Python 2.7+
* Tensorflow 12.1 from (https://www.tensorflow.org/get_started/os_setup)
* `pip install google-api-python-client pyyaml pytz newlinejson python-dateutil yattag`

## ComputeEngine Setup for Inference

* Install the SDK: https://cloud.google.com/sdk/docs/.
* Sign in: `gcloud auth application-default login`.
* Create an instance:
      - Need at least 8 cores; here is the command to create a 16 core machine named 'nnet-inference'
        in the 'us-east1-d' zone:

        gcloud compute instances create nnet-inference --zone=us-east1-d --machine-type=n1-standard-16

  - SSH into the machine:

        gcloud compute ssh nnet-inference --zone=us-east1-d

  - Install and activate `tmux`:

        sudo apt-get -y update
        sudo apt-get install -y tmux
        tmux

  - Install other dependencies:

        sudo apt-get -y install python python-pip python-dev build-essential git virtualenv
        sudo easy_install pip
        sudo pip install --upgrade pip
        sudo pip install https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-0.12.1-cp27-none-linux_x86_64.whl
        sudo pip install google-api-python-client pyyaml pytz newlinejson python-dateutil yattag
        git clone https://github.com/GlobalFishingWatch/vessel-classification-pipeline.git

## Adding new models

* For development: create a directory in `classification/classification/models/dev` with the model name
  (usually the developer name).  A `__init__.py` is required for the model to be picked up and the model
  package directory must be added to `setup.py`.

* For production: add the model to `classification/classification/models/prod`

## Formatting

[YAPF](https://github.com/google/yapf) is a code formatter for Python. All our python code should
be autoformatted with YAPF before committing. To install it, run:

* `sudo pip install yapf`

Run `yapf -r -i .` in the top level directory to fix the format of the full project.


text:
# Options

## force
Type: `Boolean`
Default: false

This overrides `grunt.file.delete` from blocking deletion of folders outside current working dir (CWD). Use with caution.

repository: baidu/BIPlatform

repo_name: baidu/BIPlatform


text:
# ubirchApiDocs
ubirch REST API Swagger Docs

If you add a new documentation, add an entry to the file

    ubirchApiDocs/swaggerDocs/docu_paths.json

In the following structure:

    {
       "add_swagger_path": false,
       "services": [{
        "name": "<service name>",
        "version": "<version>",
        "uri": "<path to the yaml or json starting under swaggerDocs>"
         }]
     },

Example:

    {
       "add_swagger_path": false,
       "services": [{
           "name": "Ubirch Niomon Service",
           "version": "1.0",
           "uri": "https://niomon.dev.ubirch.com/swagger/swagger.json"
         }]
     },

The add_swagger_path defines, if the Swagger documentation has it's .yaml or .json file
in this project and the path is only a relative one or if the path is a standalone provision of a swagger documentation.

repository: ubirch/ubirchApiDocs

repo_name: ubirch/ubirchApiDocs


text:
---
layout: page
title: anvi-export-gene-coverage-and-detection [program]
categories: [anvio]
comments: false
image:
  featurerelative: ../../../images/header.png
  display: true
---

Export gene coverage and detection data for all genes associated with contigs described in a profile database.

See **[program help menu](../../../../vignette#anvi-export-gene-coverage-and-detection)** or go back to the **[main page](../../)** of anvi'o programs and artifacts.

{% include _toc.html %}

{% capture network_path %}{{ "network.json" }}{% endcapture %}
{% capture network_height %}{{ 300 }}{% endcapture %}
{% include _project-anvio-graph.html %}

## Can provide

[coverages-txt](../../artifacts/coverages-txt)  [detection-txt](../../artifacts/detection-txt)

## Can consume

[profile-db](../../artifacts/profile-db)  [contigs-db](../../artifacts/contigs-db)

## Usage

This program gives you the **coverage and detection data** for all of the genes found in your [contigs-db](/software/anvio/help/7/artifacts/contigs-db), using the short reads data in your [profile-db](/software/anvio/help/7/artifacts/profile-db).

anvi-export-gene-coverage-and-detection -c [contigs-db](/software/anvio/help/7/artifacts/contigs-db) \
                                        -p [profile-db](/software/anvio/help/7/artifacts/profile-db) \
                                        -O MY_DATA

This will give you a [coverages-txt](/software/anvio/help/7/artifacts/coverages-txt) and a [detection-txt](/software/anvio/help/7/artifacts/detection-txt) whose file names will begin with `MY_DATA`

{:.notice}
Edit [this file](https://github.com/merenlab/anvio/tree/master/anvio/docs/programs/anvi-export-gene-coverage-and-detection.md) to update this information.

## Additional Resources

{:.notice}
Are you aware of resources that may help users better understand the utility of this program? Please feel free to edit [this file](https://github.com/merenlab/anvio/tree/master/bin/anvi-export-gene-coverage-and-detection) on GitHub. If you are not sure how to do that, find the `__resources__` tag in [this file](https://github.com/merenlab/anvio/blob/master/bin/anvi-interactive) to see an example.

repository: genomewalker/web

repo_name: genomewalker/web


text:
# Code Snippets

Several code snippets are provided to make working with Ookii.CommandLine even easier:

- **clargclass:** Snippet for an argument class, including a static `Create` method that parses arguments.
- **clarg:** Snippet for a command line argument.
- **clargpos:** Snippet for a positional command line argument.
- **clargmulti:** Snippet for a multi-value command line argument.
- **clargdict:** Snippet for a dictionary command line argument.

All snippets are provided for C# and Visual Basic.

A [Visual Studio extension](https://www.ookii.org/Link/CommandLineSnippets) is
provided that installs the snippets. Alternatively, manually copy the snippet files to the
"Visual Studio \<version>\Code Snippets\Visual C#\My Code Snippets" or "Visual Studio \<version>\Code Snippets\Visual Basic\My Code Snippets"
folder located in your Documents folder. Or, use the snippet manager inside Visual Studio to import the snippet files.

path: /docs/Code Snippets.md

filename: Code Snippets.md


text:
---
title: Rule MinStatusForNoDropExemptions
searchTitle: Lua Rule MinStatusForNoDropExemptions
weight: 1
hidden: true
menuTitle: Rule MinStatusForNoDropExemptions
---
## MinStatusForNoDropExemptions

This represents a MinStatusForNoDropExemptions Rule
```lua
Rule.MinStatusForNoDropExemptions
```

repository: xackery/eqquestapi

repo_name: xackery/eqquestapi


text:
# nerddis.co

## Contribute

- Install [hugo](https://gohugo.io/getting-started/installing/)
- Clone the repo
- Run `npm i` to install dependencies
- Install [imagemagick](https://imagemagick.org/script/download.php)
- Start the local hugo server: `hugo server -D --renderToDisk -d public`
- Start Workbox: `npm run watch`
- Make your changes
- Push back to the repo

When your commit / PR is merged into the master, it will trigger a build on netlify automatically and update the website.

### Shows

- The original image for a show goes into `static/shows/original`
- Create the optimized jpg versions of the image
  ```
    ./image-convert.sh
  ```

## Uses

- [Workbox](https://developers.google.com/web/tools/workbox/guides/generate-service-worker/cli) for Service Worker
- [pwa-update-available](https://github.com/thepassle/pwa-helpers#pwa-update-available) to update the app when a new version is released
- [Badd Mono](https://paulconley.works/badd-mono/) font

https://dev.to/thepassle/lessons-learned-building-a-covid-19-pwa-57fi

## Subpage with own index.html

For some demos we have to put the code into public/\*\*/live, therefor we can use this:

```
npm run build && rm -fR ~/dev/hugo/nerddis.co/public/nd-xmas-001/live && cp -R dist ~/dev/hugo/nerddis.co/public/nd-xmas-001/live
```

## Optimize images to have smaller textures

```
convert -resize 50% bark_NORMAL.png bark_NORMAL_50%.jpg
```

## Optimizations

- Inline CSS
- Converted Badd Mono from otf (76 kb) into woff2 (7 kb)
- All images are jpg with quality 1
- Lazyload images
- Service Worker
- Async JavaScript
- Thanks to Pascal Schilp for https://dev.to/thepassle/lessons-learned-building-a-covid-19-pwa-57fi

gha_language: HTML


text:
# `scoop-tools`

Scoop tools.

## `scoop-rehash`

Updates hash of source file in package.

### Dependencies

- Python 3

## `scoop-reshim`

Updates shims in local Scoop installation.

### Dependencies

```
pip3 install requests
```

## `scoop-validate`

Validates packages against schema.

### Dependencies

```
pip3 install jsonschema
pip3 install requests
```

repository: excitoon/scoop-tools

repo_name: excitoon/scoop-tools


text:
# nbviewer-provider

Replaces all of the default providers in nbviewer with a simple URL rewrite for input of the form
`https://mindtrove.info/<name>` that renders a vanilla HTML page naming the page you entered. (You
have to use your imagination about what it might do instead.)

With docker installed, run:

```
make nbviewer
open http://localhost:8080
```

See the Dockerfile for how the provider is specified on the nbviewer command line.

repository: parente/nbviewer-provider

repo_name: parente/nbviewer-provider