text:
# Doshii - ESLint Shareable Config

[![npm][npm-image]][npm-url]

[npm-image]: https://img.shields.io/npm/v/eslint-config-doshii.svg
[npm-url]: https://npmjs.org/package/eslint-config-doshii

## An ESLint [Shareable Config](http://eslint.org/docs/developer-guide/shareable-configs) for [JavaScript Standard Style](http://standardjs.com)

This module is an extension and customization of [eslint-config-airbnb](https://github.com/feross/eslint-config-airbnb-base) by AirBnB.

We want to provide a consistent coding standard across Doshii projects, this library extends the standard styling to conform with Doshii's opinion of best practice.

The initial differences are small, such as requiring semi-colons and spacing, but will be increased over time as we tighten the style.

## Install

```bash
yarn add eslint-config-doshii
```

## Usage

Shareable configs are designed to work with the `extends` feature of `.eslintrc` files.
You can learn more about
[Shareable Configs](http://eslint.org/docs/developer-guide/shareable-configs) on the
official ESLint website.

To use the JavaScript Standard Style shareable config, first run this:

```bash
yarn add -D eslint-config-doshii
```

Then, add this to your .eslintrc file:

```json
{
  "extends": ["doshii"]
}
```

_Note: We omitted the `eslint-config-` prefix since it is automatically assumed by ESLint._

You can override settings from the shareable config by adding them directly into your
`.eslintrc` file.

## License

MIT. Copyright (c) [Doshii Connect Pty Ltd](https://doshii.io).

repository: doshii-io/eslint-config-doshii

repo_name: doshii-io/eslint-config-doshii


text:
# AT&T AddressBook (AAB) SDK for Android

AT&T Address Book API enables the client applications and other service consumers with a programmable interface to manage subscriber’s contacts in AT&T Address Book (AAB). AT&T Address Book provides features to create, modify, retrieve, organize and search subscriber’s contacts using the easy to use web services based interfaces.

The Address Book  SDK is an android library for natively consuming the RESTful resources for [AT&T’s Address Book API].

The SDK abstracts away all the networking tasks using the AsyncTasks in a wrapper file - AabManager.java  for each of the APIs

#Quick Start

#### Requirements:

* Git

* AndroidSDK

# Overview

There are two main components to the library

1.A manager --HTTP client-- to handle all the Addres Book requests

2.A set of request wrappers for the HTTP requests to access the API's resources.

## Request wrappers

The SDK provides the wrappers for the actual REST resources that are accessed by the application.The main request parameters are exposed.

	CreateContact
	GetContacts
	GetContact
	GetContactGroups
	UpdateContact
	DeleteContact
	CreateGroup
	GetGroups
	DeleteGroup
	UpdateGroup
	AddContactsToGroup
	RemoveContactsFromGroup
	GetGroupContacts
	GetMyInfo
	UpdateMyInfo

##Request Management

The networking layer is abstracted away by providing the manager—AabManager-- to handle the request made by the application. The AabManager, calls the Service which creates the actual HTTP requests in the background tasks using Android’s AsyncTask. The network calls are not allowed in the main UI thread from the Android API level - 11 onwards , hence the calls are handled in the AsyncTasks.  The developer is allowed  to define success and error callbacks using listeners)

	aabManager =
	new AabManager(... new getContactsListener());

	aabManager.GetContacts(…,…,…);

	private class getContactsListener implements AttSdkListener {

	@Override
	public void onSuccess(Object response) {

	// Your code for success

	}

	@Override
	public void onError(AttSdkError error) {

	// Your code for error

	}

##Using the SampleApp

##### AABSampleApp project

Enter the OAuth credentials -

 * APP_KEY
 * APP_SECRET
 * APP_SCOPE
 * REDIRECT_URI

Run the AabSampleApp project which demonstrates the basic functionalities of all the Address Book APIs

##### TestAAB project

Enter the OAuth credentials -

 * APP_KEY
 * APP_SECRET
 * APP_SCOPE
 * REDIRECT_URI

Run the TestAab project which can be used to test the functionality of the individual Address Book APIs by entering the test case numbers.[1:GetContacts ; 2:GetContact etc]

Note : User can also add their own test cases

## Using the Address Book SDK in your App

##### Using the Binaries

Add the jars[ aabsdk.jar, codekit.jar ], downloaded from the release folder to the build path of your project

#####Using the AabSDK Source

* Download the AabSDK project. Import the project into eclipse .
* Build the project
* Link the AabSDK project to your App

#####Using the CodeKit Source

* Download the ATT Maven CodeKit Project from [ATT CodeKit](https://github.com/attdevsupport/codekit-java)
* Import m2eclipse plugin from [m2eclipse plugin](http://theopentutorials.com/tutorials/eclipse/installing-m2eclipse-maven-plugin-for-eclipse/)
* Import the Maven CodeKit project into Eclipse/ADT
* Add CodeKit to the ProjectReferences in the Build Path of AabSDK project.
* Add the AabSDK project as a reference in the build path of your project

Note : User can create CodeKit jar by following the steps given in [Maven Jar in Eclipse](http://www.beingjavaguys.com/2013/08/create-java-project-with-maven-eclipse.html)

##Usage

Initialize the app client

 	final String domainName = "https://api.att.com";

	// Enter the value from 'App Key' field
	final String clientId = " appId";

	// Enter the value from 'Secret' field
	final String clientSecret = "appSecret"

Add the UserConsent Activity in the ManifestFile

	<activity>

	android:name=
	"com.att.api.consentactivity.UserConsentActivity"

 	android:label="@string/title_activity_user_consent” >
    </activity>

 Start the UserconsentActivity for result by passing the domainName, appId and appSecret as extras to get the oAuthCode on the onActivityResult callback

 	Intent i = new Intent
		(this,com.att.api.consentactivity.UserConsentActivity.class);
	i.putExtra("fqdn", Config.fqdn);
	i.putExtra("clientId", Config.clientID);
	i.putExtra("clientSecret", Config.secretKey);
	i.putExtra("redirectUri", Config.redirectUri);
	i.putExtra("appScope", Config.appScope);

	startActivityForResult(i, OAUTH_CODE);

Obtain the token by passing the oAuthCode in onActivityResult

	aabManager = new AabBManager(Config.fqdn, Config.clientID,Config.secretKey,new getTokenListener());

	aabManager.getOAuthToken(oAuthCode);

OnSuccess call back of the token listener, you can call other APIs
Example :

	public class getTokenListener implements AttSdkListener {
	@Override
	public void onSuccess(Object response) {
	OAuthToken authToken = (OAuthToken) response;
	if (null != authToken) {

	getAddressBookContacts();
      }
	}

	@Override
	public void onError(AttSdkError error) {
      //Your code for error
      }
	}

Note : AccessToken can be cached so that the developer need not have to authorize everytime the app is launched.

repository: WillieChang/att-sdk-android

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: WillieChang/att-sdk-android


text:
---
title: "[Coderbyte] Reverse Polish Notation (Python)"
tags:
  - Data Structures and Algorithms
  - Coderbyte
  - Stack
categories:
  - Data Structures and Algorithms
---

## Problem Statement
**Reverse Polish Notation**: It is a mathematical notation in which operators follow their operands. Watch this [video](https://www.youtube.com/watch?v=qN8LPIcY6K4) for more detailed explanation.

For example, given `3 4 + 2 * 1 +`, the operation would be: (3+4) *2 +1 = 15.
Whenever we see a number, we push to stack and if an operator, pop and perform the calculation and push it back to stack.

## Example
#### Example 1
```
Input: "3 4 + 2 * 1 +"
Output: 15
```

#### Example 2
```
Input: "3 5 + 7 2 – *"
Output: 40
```

## Explanation
1. Create a stack
2. When its a number, append to stack.
3. If it is an operation, pop and evaluate the statement, then pop back in

## Code Implementation

```python
def polish_eval(strArr):
    split_arr = strArr.split()
    stack = []

    for i in split_arr:
        if re.match ([\+\-\*\/], i):
            val2 = stack.pop()
            val1 = stack.pop()
						var = str(val1)+i+str(val2)
            stack.append(eval(var))
        else:
            stack.append(int(i))
    return stack[0]
```

license: MIT

path: /_posts/Data Structures and Algorithms/2021-04-04-ReversePolishNotation.md

gha_language: JavaScript

gha_license_id: MIT


text:
# story_teller

Development: <img src='https://api.travis-ci.org/wesleyit/story_teller.svg?branch=development'>

An application which uses a Recurrent Neural Network (a LSTM model) to import and learn a text from a book and generate text with the same style.


text:
# Tasks - 5th day
## Task 1:

The file (the file name is given as the first argument) contains the points in the plane. Each point is given with a name and two coordinates. The point name contains a maximum of 5 letters. The file contains a maximum of 100 points.

Write a program that

a) reads the file and saves the data in a table,

b) print the points in alphabetical order according to the name of the point,

c) print out points arranged according to the distance of the point from the coordinate starting point

Example of input files: [points1](https://ucilnica.fri.uni-lj.si/pluginfile.php/110115/mod_assign/intro/t1),[points2](https://ucilnica.fri.uni-lj.si/pluginfile.php/110115/mod_assign/intro/t2)

## Task 2:

Write a program that generates N random numbers between 1 and 100. The program should count how many of these numbers fell on the interval between 1 and 10, how many on the interval between 11 and 20,…, and how many on the interval between 91 and 100 Finally, have the program draw a diagram to illustrate the distribution of numbers by intervals.

Example: if N is 13 and if the program generates the numbers 34, 12, 45, 39, 90, 21, 56, 85, 31, 76, 17, 54, 98, the diagram should be as follows:
```
                       o

         o             o             o                           o

         o      o      o      o      o             o      o      o

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

 1-10  11-20  21-30  31-40  41-50  51-60  61-70  71-80  81-90  91-100
```

(Explanation: no number was generated on the interval between 1 and 10, so no circle is plotted there; three numbers were generated on the interval between 31 and 40, so three circles are drawn there; the same applies to the other intervals).

Additional instruction: the plotted diagram must not be higher than M (the highest columns can contain a maximum of M circles). Therefore, recalculate all values in the columns relative to M.

The N and M parameters are given as the first and second arguments since the program call.

repository: mevljas/Programming-Language-C

repo_name: mevljas/Programming-Language-C


text:
# Watcher
Watcher is an application for hashtag watching

## Installation

If you want try `watcher`, you can install via `go get`:

```sh
go get -u github.com/sociafill/watcher
```

repository: sociafill/watcher

gha_language: Go

repo_name: sociafill/watcher


text:
# Audio-Technica ATH-M50x
See [usage instructions](https://github.com/jaakkopasanen/AutoEq#usage) for more options and info.

### Parametric EQs
In case of using parametric equalizer, apply preamp of **-6.8dB** and build filters manually
with these parameters. The first 5 filters can be used independently.
When using independent subset of filters, apply preamp of **-6.8dB**.

| Type    | Fc       |    Q | Gain    |
|:--------|:---------|:-----|:--------|
| Peaking | 24 Hz    | 0.86 | 6.2 dB  |
| Peaking | 324 Hz   | 2.37 | 3.3 dB  |
| Peaking | 2933 Hz  | 2.02 | -2.2 dB |
| Peaking | 14378 Hz | 1.38 | -8.9 dB |
| Peaking | 19653 Hz | 0.42 | -8.1 dB |
| Peaking | 4410 Hz  | 4.58 | -4.9 dB |
| Peaking | 5664 Hz  | 1.35 | 3.6 dB  |
| Peaking | 7733 Hz  | 2.91 | -6.2 dB |
| Peaking | 9897 Hz  | 1.74 | 2.9 dB  |
| Peaking | 12482 Hz | 5.09 | -3.5 dB |

### Fixed Band EQs
In case of using fixed band (also called graphic) equalizer, apply preamp of **-5.8dB**
(if available) and set gains manually with these parameters.

| Type    | Fc       |    Q | Gain     |
|:--------|:---------|:-----|:---------|
| Peaking | 31 Hz    | 1.41 | 5.0 dB   |
| Peaking | 62 Hz    | 1.41 | 1.7 dB   |
| Peaking | 125 Hz   | 1.41 | -2.1 dB  |
| Peaking | 250 Hz   | 1.41 | 2.0 dB   |
| Peaking | 500 Hz   | 1.41 | 0.9 dB   |
| Peaking | 1000 Hz  | 1.41 | 0.8 dB   |
| Peaking | 2000 Hz  | 1.41 | -0.7 dB  |
| Peaking | 4000 Hz  | 1.41 | -1.4 dB  |
| Peaking | 8000 Hz  | 1.41 | -1.0 dB  |
| Peaking | 16000 Hz | 1.41 | -15.8 dB |

### Graphs
![](https://raw.githubusercontent.com/jaakkopasanen/AutoEq/master/results/oratory1990/harman_over-ear_2018/Audio-Technica%20ATH-M50x/Audio-Technica%20ATH-M50x.png)

repository: CosmicCarter/AutoEq

repo_name: CosmicCarter/AutoEq


text:
# tzc - time zone convert

[![PyPI](https://img.shields.io/pypi/v/tzc.svg)](https://pypi.org/project/tzc/)
[![Changelog](https://img.shields.io/github/v/release/rstms/tzc?include_prereleases&label=changelog)](https://github.com/rstms/tzc/releases)
[![Tests](https://github.com/rstms/tzc/workflows/Test/badge.svg)](https://github.com/rstms/tzc/actions?query=workflow%3ATest)
[![License](https://img.shields.io/github/license/rstms/tzc)](https://github.com/rstms/tzc/blob/master/LICENSE)

copies input to output, converting timezone in any lines beginning with an ISO-8601 timestamp

## Installation

Install this tool using `pip`:

    $ pip install tzc

## Usage
```
Usage: tzc [OPTIONS] [INPUT_FILE] [OUTPUT_FILE]

  copy input to output, converting timezone in any lines starting with a
  timestamp

Options:
  --version               Show the version and exit.
  -i, --input-zone TEXT   timezone in file
  -o, --output-zone TEXT  output timezone
  -f, --format TEXT       output format (strptime)
  -s, --short             format output as YYYY-MM-DD HH:MM:SS
  --help                  Show this message and exit.
```

## Development

To contribute to this tool, first checkout the code. Then create a new virtual environment:

    cd tzc
    python -mvenv venv
    source venv/bin/activate

Or if you are using `pipenv`:

    pipenv shell

Now install the dependencies and tests:

    pip install -e '.[test]'

To run the tests:

    pytest

repository: rstms/tzc

repo_name: rstms/tzc


text:
# Docker how to

Running this software on your local machine on Docker

## Installing Docker and Docker Compose

### Install Docker
  - OS specific guides can be found: [here](https://docs.docker.com/get-docker/)
- You also need Docker Compose but it's installed with Docker

#### Install Docker on Ubuntu 20.04 with script:

-  `bash devscripts/ubuntu/install_docker.sh`

## Running on your local machine
- have `.env` in `extractiontool/` root
( check `devscripts/.env-file-example` )

Note: If you have MariaDB/MySQL running on your local machine, you have to stop it, because docker compose tries to initialize one container with MariaDB and that container uses same port as MySQL/MariaDB service. Linux and macOS run-scripts try to stop possible MariaDB/MySQL service.

### Linux
- `bash devscripts/run_docker.sh`

### Windows
- `devscripts\windows\run_windows_docker.bat`

### macOS
- `bash devscripts/darwin/run_macOS_docker.sh`

Script will setup everything ready to start developing. Two local super-users are created using the value in the variables
`$DJANGO_SUPERUSER_USERNAME`
`$DJANGO_SUPERUSER_PASSWORD`
`$DJANGO_SUPERUSER_EMAIL`
, the second one with just number `2` added to the end for all.

NOTE: Windows and macOS GUI:sh have a bug which makes running/stopping Docker from the graphical user interface to cause an error. Solution is to just start and stop from the commandline until Docker-developers fix the bug. https://github.com/docker/for-win/issues/9539

repository: IELuomus/extractiontool

branch_name: refs/heads/main

repo_name: IELuomus/extractiontool


text:
# Create a read-only instancec {#reference_ljz_xdf_12b .reference}

## Description {#section_l21_v32_12b .section}

This API is used to create a read-only instance for an RDS instance. The instance must meet the following conditions:

-   The master instance is running and is not in switchover status.
-   The read-only instance and master instance must be in the same region.
-   The database version of the read-only instance must be the same as or later than that of the master instance. The master instance must be in a version of at least MySQL 5.6.
-   The read-only instance must be in a version of at least MySQL 5.6.
-   A single RDS instance can have up to five read-only instances.

## Request parameters {#section_qzx_w32_12b .section}

|Name|Type|Required or not|Description|
|----|----|---------------|-----------|
|Action|String|Yes|Required parameter. Value: CreateReadOnlyDBInstance.|
|RegionId|String|Yes|Data center. The length cannot exceed 50 characters.  DescribeRegionsfunction can be used to view available data centers.|
|ZoneId|String|Yes|Zone ID. TheDescribeRegions function can be used to view available zones.|
|DBInstanceId|String|Yes|ID of a master instance|
|EngineVersion|String|Yes|Database version. -   5.6
-   5.7

|
|DBInstanceClass|String|Yes|Instance type. For more information, see [Instance type list](../../../../intl.en-US/Product Introduction/Instance types/Instance type list.md#).|
|DBInstanceStorage|Integer|Yes|User-defined storage space. Value range: \[5, 1000\], 5 GB increments. Unit: GB.|
|DBInstanceDescription|String|No| -   Instance description or remarks, no more than 256 bytes.
-   It cannot begin with http:// or https://. It must start with a Chinese character or an English letter.  It may contain Chinese and English characters/letters, “\_”, “-“, and numbers.The length may be 2-256 characters.

 |
|PayType|String|Yes|Postpaid|
|ClientToken|String|Yes|Used to guarantee idempotence|
|InstanceNetworkType|String|No|If no value is specified, a classic instance is created by default.-   VPC: VPC
-   Classic: classic network

|
|VPCId|String|No|VPC ID|
|VSwitchId|String|No|VSwitch ID|
|PrivateIpAddress|String|No|IP address of an VPC under VSwitchId. If no value is specified, the system automatically assigns a VPC IP address based on VPCId and VSwitchId.|

## Return parameters {#section_rpk_z32_12b .section}

|Name|Type|Description|
|----|----|-----------|
|<Public return parameters\>|-|For more information, see [Public parameters](intl.en-US/API Reference/Use APIs/Public parameters.md#).|
|DBInstanceId|String|DB instance ID|
|OrderId|String|Order ID|
|ConnectionString|String|Database connection address|
|Port|String|Port connecting to the database|

## Request example {#section_l4g_pj2_12b .section}

```
https://rds.aliyuncs.com/?Action=CreateReadOnlyDBInstance
&RegionId=cn-hangzhou
&ZoneId=cn-hangzhou-b
&DBInstanceId=rdsaiiabnaiiabn
&EngineVersion=5.6
&DBInstanceClass=rds.mys2.small
&DBInstanceStorage=10
&PayType=Postpaid
&ClientToken=ETnLKlblzczshOTUbOCziJZNwHlYBQ
&<[Public Request Parameters]>
```

## Return example {#section_xtg_rj2_12b .section}

**XML format**

```
<CreateDBInstanceResponse>
     <OrderId>100789370230206</OrderId>
     <ConnectionString>rdsaiiabnaiiabn.mysql.rds.aliyuncs.com </ConnectionString>
     <DBInstanceId>rdsaiiabnaiiabn</DBInstanceId>
     <port>3306</port>
     <RequestId>1E43AAE0-BEE8-43DA-860D-EAF2AA0724DC</RequestId>
</CreateDBInstanceResponse>
```

**JSON format**

```

    "OrderId": "100789370230206",
    "ConnectionString": "rdsaiiabnaiiabn.mysql.rds.aliyuncs.com",
    "DBInstanceId": "rdsaiiabnaiiabn",
    "Port": "3306",
    "RequestId": "1E43AAE0-BEE8-43DA-860D-EAF2AA0724DC"

```

url: https://raw.githubusercontent.com/BoobooWei/mysql/ab57fd707a304fef514c395afe35966a34c9b8b9/intl.en-US/API Reference/API Reference/Instance management/Create a read-only instancec.md

repository: BoobooWei/mysql

filename: Create a read-only instancec.md

repo_name: BoobooWei/mysql


text:
# Photos

**An example React + React-Router photo album app using the Apollo GraphQL Client**.

The home page is a list of links to photo albums. The links take the user to an album page with a list of photos. The photos are clickable to open in a new photo detail page.

**Note**: Depends on the companion [graphql server](www.github.com/jroth/01/graphql-photos-server) to also be running. By default the `server` will run and be recognized on `localhost:4000`.

# Run Locally

1. First, clone the companion [graphql server](www.github.com/jroth/01/graphql-photos-server) and follow the steps in that repo's README to run it locally.

2. Once the graphql server is up and running, clone this repo and run:

```
npm install && npm start
```

# Heroku Deployment

The react app is deployed for free on Heroku. The server is deployed separately, also on Heroku.

Because it's free tier, Heroku will put both the client and server dynos to sleep when not in use. (That way they can save on AWS costs and provide a convenient PaaS to hobbyists)

If no one visits the app in some time, Heroku must first wake the client app.

Once active, the client app tries to connect to the server, which Heroku must also wake.

## *TL;DR*

_The first page load will be slow if no one has visited the free tier Heroku app(s) in some time!_

Free tier Heroku apps are sleepy. You get what you pay for :)

## Links to Deployed Client + GraphQL Server

[Photos App on Heroku](https://graphql-photos-app.herokuapp.com)

[Companion Graphql Server +  Query Playground](https://graphql-photos.herokuapp.com)

## Build Config
Build configuration is extremely minimal thanks to `create-react-app`. It abstracts away bundling and minification so one can quickly prototype and focus on development.

The Heroku react buildpack references the [`static.json`](./static.json), which allows index.js to hanldle the app's declarative routing.

# Declarative Routing

Delarative routing ensures a user can access content directly via url without navigating through a contextual heirarchy. In this case, the user can enter a url to go directly to an album or an individual photo within an album.

# Implementation w/ React-Router

The basic routing setup uses react-router's `Switch`. Swtich attempts to match a url to a route and render the appropriate component. If there is no match, it renders a `NotFound` 404 page.

Here's an example from /routes/AlbumSwitch.js

```jsx
import React, {Component} from 'react'
import { Switch, Route } from "react-router-dom";
import NotFound from '../containers/NotFound';
import Album from '../containers/Album';
import Home from '../containers/Home';
import Photo from '../containers/Photo';

class AlbumSwitch extends Component {
  render() {
    let { location } = this.props;
    return (
      <div>
        <Switch location={location}>
          <Route exact path="/" component={Home} />
          <Route exact path="/album/:id" component={Album} />
          <Route exact path="/album/:id/photo/:id" component={Photo} />
          <Route component={NotFound}/>
        </Switch>
      </div>
    );
  }
}

export default AlbumSwitch;
```
Each route maps to an individual page (React component) of the application defined under `/containers`.

The base route `/` takes the user to the `Home` page.

An unrecognized route, such as `/foo`, will render the `NotFound` component.

# Parameterized and Nested Routes

React-Router supports route parameters for urls to dynamic content.

Take for example the following route that allows a user to access albums directly by url

```
<Route exact path="/album/:id" component={Album} />
```

The route `/album/:id` accepts a single parameter: an `id` .

As one might guess, `/:id` in the url corresponds to a unique id of an album returned by the server.

## Using url parameters within a component
That `id` parameter from the url passed to the `props` of the matching route's `Album` component via `match.params`.

React-router makes parameters automatically accessible within the `Album` component's props as
```js
match.params.id
```

The `Album` component uses the parameter to fetch data for the entity with that `id`, and do whatever with the response.

## Nesting routes with parameters

React-router lets you combine route parameters with nested routes.

Take for example the route to an individual photo within an album:
```
<Route exact path="/album/:id/photo/:id" component={Photo} />
```

The route `/album/:id/photo/:id` accepts two `:id` parameters. The first corresponds to a unique album id, the second is the unique id of photo within that album.

The nested url reflects the fact that photos are child entities of albums.

Just like before, the `Photo` component uses the id parameters to fetch data.

Moving on to fetching that data with GraphQL + the Apollo Client .

# What's GraphQL?

GraphQL exposes a single endpoint through which a client can execute queries and define the structure of the data it receives.

It's an alternative to REST.

One can use it directly over a database, or indirectly as a layer over legacy REST apis.

# Why Use GraphQL?
The beauty of graphql is it's simplicity.

**There's just one endpoint** - not a series of imperatively defined endpoints.

**It's self documenting**. It exposes it's typed schema directly to the client, so there's no ambiguity about the response to a query.

**You get exactly and only what you ask for**. The query result provides the minimal amount of data needed, delivered in the structure the client actually uses.

Legacy rest APIS exist at every major company, and usually repond with extraneous data in a convoluted, ever-changing structure.  GraphQL allows you to make response payloads tiny and predicatable.

 Same with state management boilerplate.

You effectively offload that work to your GraphQL server, which is a more sensible place for data-pruning tedium.

Tiny payloads = no parsing = less client side code.

# Fetching with Apollo GraphQL Client

The Apollo client allows for decalarative data fetching from a GraphQL endpoint in React.

## Forming a query with `graphql-tag`
Here's an example of the query executed from the `Home` page. It gets an array of albums from a graphql endpoint.

The query is written using `graphql-tag`, which allows one to form queries using ES6 template literals.

```js
import gql from 'graphql-tag';

export const ALBUMS_ALL = gql`
  query{
    albums{
      id
      name
      date
    }
  }
`;
```

The above dictates a query on `albums`. It defines the exact JSON object structure of all objects returned in the resulting array.

Each album object will be returned with only 3 properties:
```gql
{
  id
  name
  date
}
```
## Using the query with the `Apollo Client`

The Apollo Client's `Query` component takes in a query and exposes the result to it's children.

The result is _declarative AF_.

Here's the entire `Home` page in 35 lines.

```js
import React, { Component, Fragment } from 'react';
import AlbumList from '../../components/AlbumList';
import { Query } from 'react-apollo';
import gql from 'graphql-tag';

export const ALBUMS_ALL = gql`
  query{
    albums{
      id
      name
      date
    }
  }
`;

class Home extends Component {
  render() {
    return (
      <Query query={ALBUMS_ALL}>
        {({ loading, error, data }) => {
          if (loading) return <div>Fetching</div>
          if (error) return <div>{error.message}</div>
          if (!data.albums) return <div>No albums</div>
          return (
            <Fragment>
              <AlbumList {...data} />
            </Fragment>
          )
        }}
      </Query>
    )
  }
};

export default Home;
```

Based on the state of the query, the UI renders itself accordingly.

All properties of the response `data` are passed to the `<AlbumList>`   :
```
  <Fragment>
      <AlbumList {...data} />
  </Fragment>
```

In this case, the `data` object just contains one property, `albums`, so use of the spread operator here is admittedly lazy.

 But if we changed the query to retrieve additional properties other than `albums`, it would automatically pass them to `<AlbumList>` with no code change needed in the component.

# GraphQL Results + Declarative Routing

How does `<AlbumList/>` use the query result with dynamic routing?

Using the `Link` component from `React-Router`, we can wrap each list item in a link to one of the app's parameterized routes.

That way, the user can click on a link to an album and be taken to it's page. The url will be updated in the browser with history preserved.

Here's the `AlbumList` component. It just maps over the album array and renders a link for each album:
```js
import React from 'react';
import { Link } from 'react-router-dom';
import Heading from '../Heading';

const AlbumList = ({albums}) => (
  <div>
    <Heading title="Albums"/>
    <ul>
      {albums.map(album =>
      <li key={album.id}>
        <Link to={`/album/${album.id}`}>
          {album.name} - <small>{album.date}</small>
        </Link>
      </li>
      )}
    </ul>
  </div>
);

export default AlbumList;
```

What a beautifully dumb component! It's completely stateless. It's just based on the `albums` prop, which contains the minimal amount of data needed in a flat structure.

All it does is render itself accordingly.

No parsing logic needed from either the parent `Home`, or child `AlbumList

# Cached Queries

The Apollo Client is configured to use in-memory caching, which helps reduce the amount of state management needed.

Repeated visits to the same pages directly via browser url or hyperlink will execute the same query, but the results are returned from memory rather than re-fetched over the network.

```js
const client = new ApolloClient({
  link: httpLink,
  cache: new InMemoryCache()
})
```


text:
# Limit Repeated Requests

To prevent brute force attacks or overloads on your application, you need to implement a rate limiter to limit the number of requests a user is able to send to your application.

In FoalTS you can implement a rate limiter like the [express-rate-limit](https://github.com/nfriedly/express-rate-limit) package by creating a customized `express` object and passing it as a parameter to the FoalTS `createApp` function.

*src/index.ts*
```typescript
// std
import * as http from 'http';

// 3p
import * as express from 'express';
import * as rateLimit from 'express-rate-limit';
import { Config, createApp } from '@foal/core'

// App
import { AppController } from './app/app.controller';

async function main() {
    const expressApp = express();
    expressApp.use(rateLimit({
      windowMs: 15 * 60 * 1000, // 15 minutes
      max: 100 // limit each IP to 100 requests per windowMs
    }));

    const app = createApp(AppController, expressApp); // For v1
    // For v0.8
    // const app = createApp(AppController, { /* ... */ }, expressApp);

    const httpServer = http.createServer(app);
    const port = Config.get('port', 3001);
    httpServer.listen(port, () => {
        console.log(`Listening on port ${port}...`);
    });
}

main();
```


text:
# ParBLiSS bruno
[![Apache 2.0 License](https://img.shields.io/badge/license-Apache%20v2.0-blue.svg)](LICENSE)

`Bruno` is a library in the **Par**allel **B**ioinformatics **Li**brary for **S**hort **S**equences project (ParBLiSS).

Bruno provides parallel de Bruijn graph construction, erroneous k-mer filtering, and chain compaction (initial contig generation) capabilities in distributed memory environments.

Please take a look at our [Wiki](https://github.com/ParBLiSS/bruno/wiki).

  BUILD AND USAGE INSTRUCTIONS ARE TO FOLLOW.

repository: ParBLiSS/bruno

repo_name: ParBLiSS/bruno


text:
# switch-config-render

switch-config-render is a python module that can be used to create
an SVG depiction of the internal configuration of an FPGA-based network
switch product.

The module renders:
* Front panel interfaces in use, together with their optional alias and
description
* FPGA application interfaces with their optional alias and description
* Applications configured on the FPGA devices and the ports that they
are connected to
* Cross-connect connections between the front panel and application
interfaces which can be colour-coded depending on the connection type(s)
as defined in the interface definitions

Example output:

![](example_output.png)

Install by running `pip install switch-config-render`.
directory.

## Generating an SVG

The SVG can be generated by calling the `generate_system_svg` function:

```python
generate_system_svg('svg_file.svg', interfaces, connections, fpga_apps, app_shapes, onchip_connections)
```

Where:
* `svg_file.svg` is the name of the destination .svg file
* `interfaces` is a dict specifying all the front panel and FPGA application
interfaces
* `connections` is a dict of `key: value` pairs, where the `key` defines the
destination and the `value` the source of a connection
* `fpga_apps` is a dict that specifies the applications that are
configured on the given FPGA
* `app_shapes` defines the vertices of the shapes to be used for the
applications defined in `fpga_apps`
* `onchip_connections` specifies internal connectivity within the FPGA and
between FPGAs, between `ap` interfaces and FPGA applications

Refer to the example code in `switch_config_render.__main__.py` for more
information.

## Example Application

An example application is provided and can be run by calling:

```bash
python -m switch_config_render
```

from the project root. The example runs `switch_config_render.__main__.py`
which runs two examples: one that calls the high-level
`generate_system_svg` function and one low-level example that manually
creates objects for fine-grained placement control. These examples
produce the `high_level_example.svg` and `low_level_example.svg` files
respectively.

## License

switch-config-render is:

Copyright \[2021\] \[Optiver\]

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.

repository: optiver/switch-config-render

gha_language: Python

repo_name: optiver/switch-config-render


text:
# Debugging

In your project, if you find that there is a bug that appears ONLY when you use BabelMinify, it's most likely that there is a bug in BabelMinify and you should definitely report it. Here are some guidelines that might help you drill down the issue. If it doesn't help you, you can of course create a minimal repro project with the bug and report it.

## Compile time Errors

If you get a syntax error at compile time, then it could be a few things:

1. The code is actually invalid syntax.
1. You didn't turn on the relevant Babel plugin for that syntax (if experimental).
1. The parser itself doesn't handle the syntax being used (a [babylon](https://github.com/babel/babel/tree/master/packages/babylon) bug).

If the syntax error occurs at runtime,  it likely means the code generator ([babel-generator](https://github.com/babel/babel/tree/master/packages/babel-generator)) has a bug and has output invalid code.

## Runtime errors

When you run your minified code in the browser,

1. If there is an error in the console, as a first step, look around the code block where the error happens, and the code block of a few steps up in the stack.
1. Try to predict what caused the error and try relating it to some of the plugin names in the [packages/](https://github.com/babel/minify/tree/master/packages) directory. The major ones (that do a lot of transformations) are - mangle, deadcode-elimination and simplify.
1. Every plugin that Babel-Minify uses has an option in preset to toggle it on/off - [preset-options](https://github.com/babel/minify/tree/master/packages/babel-preset-minify#options)
1. Disable any transformation(s) that you suspect are causing problems. Turning OFF mangling (`mangle: false`) is a good practice if you don't think it's related to a mangling bug, since unmangled variable names will make debugging easier.
1. Sometimes it might NOT be a bug with one plugin but a combination of plugins. Again, `deadcode-elimination` and `simplify` maybe good candidates to start with here as they perform many transformations.
1. Sometimes it might because of the [unsafe transformations](https://github.com/babel/minify/tree/master/packages/babel-preset-minify#option-groups). Some of them are grouped into a single option named `unsafe`. This option can help you identify it sooner if the bug is in one these plugins.
1. Produce a minimal repro of the same issue - the function block containing the bug should be enough to help reproduce the bug.
1. [Report it 🙂](https://github.com/babel/minify/issues/new)
1. You're awesome. Thanks!

repository: babel/minify

repo_name: babel/minify


text:
---
title: "Blackhoodie Seattle 2023"
excerpt: "Malware, Incident Response, Side Channels"
tags: [workshop, conferences, BlackHoodie, Seattle]
date: 2023-05-02 00:00:00 -0500
---
Malware, Incident Response, Side Channels

On June 22nd & 23rd Leviathan Security Group will host BlackHoodie Seattle, our biggest BlackHoodie event coming back since the start of the pandemic. We'll be hosting 4 classes over two days, discussion groups and a lot of networking opportunities.  Trainings will be held by Thaís Moreira Hamasaki, Bhavna Soman, Supriya M Gowda, and Marion Marschalek, and we'll cover malware analysis topics, side-channel attacks, and incident response including cloud incidents. Come meet us in Seattle in June, Leviathan offices are spacious and comfy and the trainings will be so much fun <3

## **TL;DR:**

**What:** class on low-level security topics, introductory and intermediate

**When:** June 22 & 23 2023 - 9am-5pm

**Where:** Leviathan Offices 2925 1st Ave S, Seattle, WA 98134

**Who:** Women

**Registration:** [fill form here](https://docs.google.com/forms/d/e/1FAIpQLSdbPcNMbRj742uKqccRtCDfAt5-gpo92_K1x6z4HrYJrUUN3Q/viewform?usp=sf_link)

**Fees:** The trainings are free; food, travel and hotel is responsibility of attendees

**COVID:** We want everyone to feel comfortable; masks and testing prior to the event are encouraged yet not required. Masks and tests will be provided.

---

## **Agenda**

### **Day 1 June 22nd**

### **Track 1: A Lady’s Illustrated Primer to ELF Malware Analysis**

**Trainer:** Bhavna Soman (@bsoman3), Security Research/Machine Learning, AWS Security

**Topic:**  We will build up to reversing some new ELF malware. On the way we may discuss the structure of ELF binaries, C pointers, threads/processes, syscalls etc. We will also learn some tools (as necessary) like radare2, Ghidra, and others and use them in our process. If time permits, we will play with “cloud” malware.

**Good to have:** Some knowledge of coding in C, basics of CPU architecture, VM (set up instructions will be provided)

### **Track 2: Incident Response with a Splash of Cloud**

**Trainer:** Supriya Gowda (@supg0x80), Security Engineer ll (DFIR), Amazon

**Topic:** This class will be an introduction to incident investigations in theory and practice, including a primer on cloud security and cloud forensic investigations.

### **Day 2 June 23rd**

### **Track 1: Binary Unpacking in a Nutshell**

**Trainer:** Marion Marschalek (@pinkflawd), Senior Security Engineer, AWS Security

**Topic:** Runtime packers are considered a big hindrance in malware analysis, however in reality there are a few neat tricks that help defeat almost any packer. In a very hands-on class students will learn the concept of self-modifying code and basics of malware anti-analysis tricks.

**Good to have:** Basics of binary reverse engineering, Windows virtual machine or cloud instance; non-malware exercises can be done on host as well

### **Track 2: Speculative CPU Shenanigans**

**Trainer:** Thaís Moreira Hamasaki (@barbieauglend) , Offensive Security Researcher, Intel STORM

**Topic:** In this workshop we will deep-dive into security from the CPU perspective. We will learn about Spectre, Meltdown, and other side-channel attacks exploiting speculative/transient execution. We will learn how to use timing (side-channel) attacks to infer information otherwise not reachable to us.
It is going to be very hands-on, no slides, no fancy diagrams, not much of a GUI - it's going to be you, a text editor, a shell, and me (speculatively) having lots of fun!

**Good to have:** Fundamentals of modern computer architecture, coding in C and x86 assembly

---

## **What is BlackHoodie?**

BlackHoodie is a free, women only reverse engineering workshop and community. More information can be found here:[ https://www.blackhoodie.re/about/](https://blackhoodie.re/mission/)

### **Why women-only?**

One qualifies to attend an in-person bootcamp either if born and raised female, or if one identifies as a woman. This concept of women-only has no intention of putting up walls or feeling exclusive. Blackhoodie is about creating space in an industry that’s very competitive. It is a comfortable place, where attendees feel encouraged to grow skills without pressure. We do what we do, not to create women-only bubbles, as contradicting as it might sound, but to enable a minority to enter the security space, learn skills that are otherwise expensive to learn, find their interests and grow a professional network.

And, it works. BlackHoodie alumnae have gone far beyond being successful in the classroom since the workshop series started. They ventured out to start community projects and collaborations, got themselves new jobs in the security industry, went to speak at major security conferences, joined review boards and became influencers in our community. Many went on to mentor others after they had found their spot, came back to BlackHoodie to give trainings on their own or are now conference trainers and teach classes to the community.

Finally, why does the security industry need more women at all? The industry is growing and facing a talent shortage. More importantly, jobs are typically well paid, come with certain privileges, and are challenging and often fulfilling. And we do firmly believe our society as a whole can only benefit from having more women with money, independence and confidence. Likewise, the tech sector has grown in size and influence, and with great power comes great responsibility – responsibility best shared among a diverse body of decision makers.

gha_language: HTML


text:
# a more up-to date and easy to use version available on GitLab!
# https://gitlab.com/daaaaande/circs

# automate_DCC
automating DCC circular RNA detection

## two major levels of automation:
1. dcc_starter.pl runs the whole DCC pipeline for one sample (two reads, samplename); matrix has to be created manually after it finished.
2. auto_automaker.pl runs DCC for how many lines are in the input file for it, summarizes for each group and all samples into a matrix.

3. let find_circ/godfather.pl handle it all, see find_circ/godfather.pl

## dcc_commands.txt
- shows the DCC commands that have benn automated with this tool here. however, you can change those if you prefer other filtering parameters
- can be ignored otherwise

# what you need (need to be in the parent directory, so wherever you stared the git clone command):

- STAR Aligner installed
- DCC installed
- mapping files for annotation (see auto_find_circ for links and instructions + you will need the STAR hg19 reference genome and in .gtf format)
- two reads for each sample, a samplename and a groupname for auto_automaker.pl

## how to run:
- copy the samplesheet into the parent dir
- go into the dir where these scripts are
- perl auto_automaker.pl samplesheet (auto_automaker looks for a samplesheet in the parent directory, where all the infiles need to be aswell)
- all dirs and files in these dirs will be created in the parent directory of the scripts, the script- containing dir will have no additional files after execution.
- the two input .fastq files will be deleted after the run was finished. so keep a copy somewhere else (auto_find_circ does not delete them, so maybe there)
## start auto_automaker.pl with inputfile1 inputfile2 samplename groupname table, separated by \t
```bash
~ head infiles_for_auto_automaker.txt
lineonefile1 linetwofile1 samplename1 group1
lineonefile2  linetwofile2  samplename2 group1
```
the group will lead to auto_automaker making a directory named after the group where all the resulting .csv files will be copied into, catted into one big .csv file and then run matrixmaker.pl with this as an input and then start matrixtwo.pl with this as an input

>> expect about ~ 20 minutes runtime per sample with 10 CPUs

## outfiles:
- for each sample, it creates a directory where all outputfiles  from dcc and the three(!) STAR alignemnts will be
- additionally if you utilize groups it copies the .tsv files from dcc_outreader.pl into there and creates a matrixmaker.pl matrix
- and all processed.csv files will also get copied into the Day_Month dir created in the parent dir and two matrices will be created that contaion information fromm al samples in the samplesheet
# this set of scripts is not mature


text:
# line_buffer
A ruby implementation of yielding lines when streaming data to a buffer

# Credit
Original code by https://github.com/jowl and https://github.com/grddev


text:
# Cluster Analysis

Gaussian Mixture Models
----------

## Packages
- [Gaussian Mixture of Copulas](https://cran.r-project.org/web/packages/GMCM/vignettes/GMCM-JStatSoft.pdf)

## References

- [Parametric Characterization of Multimodal Distributions with Non-Gaussian Modes](https://scihub.wikicn.top/10.1109/ICDMW.2011.135)
- [A unified view of density-based methods for semi-supervised clustering and classification](https://link.springer.com/article/10.1007/s10618-019-00651-1)

repository: AstroKnights/Cluster-Analysis

repo_name: AstroKnights/Cluster-Analysis


text:
# Python-to-Deb

This repo contains steps and sample to convert a python package to deb package which can be install on any debian-supported OS
___

## Steps

### 1. First install stdeb

```
apt install python-stdeb
pip3 install stem stdeb
```

### 2. The folder structure should be same as

```
ThisRepo/
    README.md
    setup.py
    PyToDeb/
        __init__.py
        PyToDeb.py
```

### 3. Now copy the `setup.py` from [here](setup.py)

Change the necessary fields in setup.py

### 4. Now copy the `PyToDeb.py` from [here](PyToDeb/PyToDeb.py)

### 5. Now run the command

```
python setup.py --command-packages=stdeb.command bdist_deb
```

### 6. A .deb file would be created in deb_dist folder

Run the .deb file to install the software


text:
# Overview
This project is a simple Docker image that contains the [Oracle JDK](http://www.oracle.com/technetwork/java/index.html).

# Prerequisites
* a working [Docker](http://docker.io) engine
* a working [Docker Compose](http://docker.io) installation

# Building
Type `docker-compose build` to build the image.

# Installation
Docker will automatically install the newly built image into the cache.

# Tips and Tricks

## Launching The Image

`docker-compose up` will launch the image in a simple test mode to ensure things are wired up correctly.

## Simple Usage
The `/opt/launch-jvm.sh` script is available to launch the JVM and is convenient means of doing so. An
example of how to use the script might look like this `ENTRYPOINT ["/opt/launch-jvm.sh", "-jar", "/opt/server.jar"]`.

The environment variables in the container control some of the settings in the script:

* JVM_HEAP_MIN -- the minimum heap size. Defaults to 128m.
* JVM_HEAP_MAX -- the maximum heap size. Defaults to 512m.
* JVM_METASPACE -- the maximum Metaspace size. Defaults to 512m.
* JVM_CMS_OCCUPANCY -- the percentage at which the concurrent mark and sweep garbage collector should be triggered. Defaults to 70.
* JVM_GC_LOG_PATH -- where to store the garbage collection logs. Defaults to /var/logs.
* JVM_GC_LOG_FILE_COUNT -- the maximum number of GC log files to keep before rotating. Defaults to 10.
* JVM_GC_LOG_FILE_SIZE -- the maximum size of a single GC log file. Defaults to 100M.
* JVM_DNS_TTL -- how long, in seconds, DNS entries should be cached. Defaults to 30.
* JVM_JMX_HOST -- the interface to bind JMX to.  Defaults to <IP_ADDRESS>.
* JVM_JMX_PORT -- the port to bind JMX to.  Defaults to  9898.
* JVM_JMX_RMI_PORT -- the port to bind RMI to.  Defaults to  9999.

The settings in the script were borrowed from
[Java VM Options You Should Always Use in Production](http://blog.sokolenko.me/2014/11/javavm-options-production.html).

Since the settings are environment variables, you may customize them at launch time.

**WARNING:** this is simplistic mechanism that, because of the PID 1 problem, will prevent some applications, such as
Spring Boot based ones, from seeing exit signals and cleaning up properly after themselves.

## Sophisticated Usage
This image is based on [phusion/baseimage](https://hub.docker.com/r/phusion/baseimage/) and can take advantage of its
watchdog capabilities.  I've found that **not** using this mechanism causes problems when building Spring Boot based
microservices.    If,
however, you decide to launch your JVM via shell script you will run into problems.  In the case of a Spring Boot
microservice, I've found that the JVM never sees the shutdown signal and the program never gets a chance to clean
up.  This left stale registrations in our service registry.  Not good.  A more complex, but safer, way of launching
your application is to create a launch script that follows certain conventions.  Here is an example borrowed from
 [docker-spring-cloud-configuration-server](https://github.com/kurron/docker-spring-cloud-configuration-server).

### Shutdown the container
`docker stop configuration-server` should cleanly shutdown this example server and the logs should indicate a clean shutdown.

```
configuration-server | {"timestamp":"2016-04-03T18:01:49.275+00:00","message":"Started Application in 10.288 seconds (JVM running for 12.895)","component":"org.kurron.example.Application","level":"INFO"}
configuration-server | *** Shutting down runit daemon (PID 10)...
configuration-server | *** Killing all processes...
configuration-server | {"timestamp":"2016-04-03T18:02:04.601+00:00","message":"Closing org.springframework.boot.context.embedded.AnnotationConfigEmbeddedWebApplicationContext@33f4c061: startup date [Sun Apr 03 18:01:42 UTC 2016]; parent: org.springframework.context.annotation.AnnotationConfigApplicationContext@2680968e","component":"org.springframework.boot.context.embedded.AnnotationConfigEmbeddedWebApplicationContext","level":"INFO"}
configuration-server | {"timestamp":"2016-04-03T18:02:04.605+00:00","message":"Stopping beans in phase 0","component":"org.springframework.context.support.DefaultLifecycleProcessor","level":"INFO"}
configuration-server | {"timestamp":"2016-04-03T18:02:04.740+00:00","message":"Removing {logging-channel-adapter:_org.springframework.integration.errorLogger} as a subscriber to the 'errorChannel' channel","component":"org.springframework.integration.endpoint.EventDrivenConsumer","level":"INFO"}
configuration-server | {"timestamp":"2016-04-03T18:02:04.741+00:00","message":"Channel 'jvm-guy-configuration-server:2020.errorChannel' has 0 subscriber(s).","component":"org.springframework.integration.channel.PublishSubscribeChannel","level":"INFO"}
configuration-server | {"timestamp":"2016-04-03T18:02:04.744+00:00","message":"stopped _org.springframework.integration.errorLogger","component":"org.springframework.integration.endpoint.EventDrivenConsumer","level":"INFO"}
configuration-server | {"timestamp":"2016-04-03T18:02:04.778+00:00","message":"Unregistering JMX-exposed beans on shutdown","component":"org.springframework.boot.actuate.endpoint.jmx.EndpointMBeanExporter","level":"INFO"}
configuration-server | {"timestamp":"2016-04-03T18:02:04.784+00:00","message":"Unregistering JMX-exposed beans","component":"org.springframework.boot.actuate.endpoint.jmx.EndpointMBeanExporter","level":"INFO"}
configuration-server | {"timestamp":"2016-04-03T18:02:04.790+00:00","message":"Shutting down ExecutorService 'taskScheduler'","component":"org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler","level":"INFO"}
configuration-server | {"timestamp":"2016-04-03T18:02:04.801+00:00","message":"Unregistering JMX-exposed beans on shutdown","component":"org.springframework.jmx.export.annotation.AnnotationMBeanExporter","level":"INFO"}
configuration-server | {"timestamp":"2016-04-03T18:02:04.803+00:00","message":"Unregistering JMX-exposed beans","component":"org.springframework.jmx.export.annotation.AnnotationMBeanExporter","level":"INFO"}
configuration-server exited with code 0
```

# Troubleshooting

## Docker Compose Version
You must be running the current version of Docker Compose or it won't recognize the newer format of the build file.

# License and Credits
This project is licensed under the [Apache License Version 2.0, January 2004](http://www.apache.org/licenses/).

gha_language: Shell


text:
##########
JHU Data Science Hackathon, Genomics Section, Cell Type Hacking Group
##########

##########
GOAL

>Build a model to classify tissue and tumor types from GEO data from NCBI
##########

##########
IN PRACTICE

>Exploring how to download, handle and curate GEO data, specifically NCI-60 cancer cell lines and reference normal cell lines, and how to use machine learning to train a data set and test the model on single cell genomics data and see how tissue and tumor types classify.
##########

##########
BACKGROUND

PMID: 25434802

Any given tumor is a mixture of normal cells and tumor cells. Single cell genomic technology can capture molecular data from a single tumor cell, bypassing molecular characterization of heterogenous tumor mixtures. However, this technology is very new and not very high throughput, so it would be valuable to know if traditional cell line data can correctly classify data from single cells, which strengthens how accurate the cell lines characterize tissue and tumor samples.

##########

##########
DATA

NCI-60 Cancer cell line panel http://www.ncbi.nlm.nih.gov/gds/4296

Reference-Large scale analysis of the human transcriptome http://www.ncbi.nlm.nih.gov/gds/596

deg.txt - got all protein coding genes (424) that are differentially expressed on the protein level in NCI-60
- http://<IP_ADDRESS>:7070/NCI60/query/globalExpression

Single Cell Melanoma and Leukemia data
GSE66117_CLL_FPKM_values.txt RNA-seq data of chronic lymphocytic leukemia http://www.ncbi.nlm.nih.gov/geo/query/acc.cgi?acc=GSE66117
GSE62526_Normalized_expression_values.txt RNA-seq data of 29 melanoma cell lines http://www.ncbi.nlm.nih.gov/geo/query/acc.cgi?acc=GSE62526

##########

##########
PROGRAMMING

Downloaded and handled GEO data in R

Model Training and Testing in iPython using the scikit-learn package

##########

##########
FINAL THOUGHTS

Summary:

Gene expression data from cancer cell lines can differentiate samples from different cancer types. We investigated the classification accuracy of cancer and normal cell line data, using a testing set of homogenous tumor data from single-cell tumor gene expression data. In producing a model using the cancer and normal cell line data as a training set, we ran into challenges that are common with these types of analyses, such as batch effects integrating multiplatform data and overfitting of the model.

https://github.com/NCBI-Hackathons/DASH_cell_type

##########

gha_language: R


text:
---
title: BlinkyBracelet - Troubleshooting LED "leakage"
desc: Where is that current coming from?
---

### The Issue

Previously on BlinkyBracelet: I left the project with a strange issue where lighting up certain LEDs also lit up other LEDs but to a lesser degree. Since I used scotch
tape to glue on the LEDs to the copper tape and the connections were punctured into the copper tape and paper, I could not be sure whether the issue was the design or the
method of prototyping.

Since then, I was able to purchase a small soldering iron with some accessories. After a couple of attempts I got the hang of soldering on LEDs to copper tape.

### Breaking it down

First thing's first - break down the whole circuit into components. I make a charlieplexed circuit with 6 LEDs in 2 rows of 3 LEDs. Pins 6, 5 and 3 are PWM pins on the Arduino Uno.

Here is what that looks like on paper with copper tape and the LEDs soldered on. The source code to drive the LEDs is [here](https://github.com/nishakm/blinkybracelet/blob/master/sketch_blinkybracelet_3x2/sketch_blinkybracelet_3x2.ino)

So now I have a smaller set of LEDs that I can debug.

### Where is the current going?

Breaking it down made me realize immediately that this had nothing to do with current leakage or breaking down the LED but a timing issue with keeping multiple LEDs on in
a charlieplexed circuit.

One more time - because all of the LEDs are tied together and none of them have a common ground, the only way to turn on a specific set of LEDs was to turn each of the
LEDs in the set on and off in rapid succession. No human (or camera) can see the flickering so it works out. This is called "persistance of vision".
So essentially the "leakage" on the LEDs came from a small overlap between the states of the pins (OK, there is some actual current leakage going on but I'll get to that later). Here is a diagram (again, hand-drawn, because it's quick) that
demonstrates this.

At some point the pin 3 was high and stayed high while pin 6 went to high impedence. If it had gone low then LED 6 would have gone completely on. The High Impedence is not exactly "open" and the state changes are not instantaneous so I would guess this is the reason for my mischevious LEDs turning on when they were not supposed to.

The fix was to reset them to high impedence after they completed a round of blinking.

```c
void reset2()
{
  pinMode(3, INPUT);
  pinMode(5, INPUT);
  pinMode(6, INPUT);
}
```
And then:

```c
  // set pinmode
  reset2();
  pinMode(leds[ledNo].pinHigh, OUTPUT);
  pinMode(leds[ledNo].pinLow, OUTPUT);
  pinMode(leds[ledNo].pinHiImp, INPUT);
  // turn it on
  digitalWrite(leds[ledNo].pinLow, LOW);
  digitalWrite(leds[ledNo].pinHigh, HIGH);
  delay(1);
```

And presto! No more sneaky LEDs! I earned my cookie today.


text:
[![Build Status](https://travis-ci.com/WyattBlue/auto-editor.svg?branch=master)](https://travis-ci.com/WyattBlue/auto-editor)
   <sup>version 20w24b
# Auto-Editor
Auto-Editor is a command line application program for automatically editing **video or audio**.
It works by analyzing the video's audio to detect when a section needs to be cut or kept in, then it runs a subprocess called ffmpeg to create the new video.

## New in 20w24b!
 * Introduced a brand new method of editing videos that is **4x faster**. Right now, it can't handle changes in sounded or silence speeds so it will default to the original method.
 * Fixed rare audio bug that stopped new audio being generated.
 * The main script has been split into more manageable parts to aid future collaborators. You can find them in the 'scripts' folder.

 For old users, remember to install cv2 for python.
 ``` $ pip3 install opencv-python```

## Usage
### Minimal Example

Create an edited version of example.mp4 with the default parameters.
```terminal
 $ python auto-editor.py example.mp4
```

### Change the Feel
You can change the **pace** of a video by changing by including frames that are silent but are next to loud parts. A frame margin of 8 will add up to 8 frames before and 8 frames after the loud part.

```terminal
 $ python auto-editor.py example.mp4 --frame_margin 8
```

There are many more features in auto-editor, including **adding in background music** that automatically gets quieter, and **zooming in** the video when it gets especially loud.

[See the docs](/resources/docs.md) for more commands and usages.

## Installing Auto-Editor
[Installing for Windows](/resources/install_win.md)

[Installing for Mac](/resources/install_mac.md)

[Installing for Linux](/resources/install_lin.md)

## Help or Issues
If you have a bug or a code suggestion, you can [create a new issue](https://github.com/WyattBlue/auto-editor/issues/new) on this github page. If you'll like to discuss this project, suggest new features, or chat with other users, do that in [the discord server](https://discord.com/invite/kMHAWJJ).


text:
---
id: 8JECQzntY2P5ha3U
title: Publish
desc: ''
updated:<PHONE_NUMBER>094
created:<PHONE_NUMBER>451
---

## Summary

The Github Publish Pod lets you update the status and labels of issues in your github repository that have previously been imported into Dendron.

## Example Workflow

When importing issues through [Github Import](https://wiki.dendron.so/notes/2H9FBzagX9wf4b0V0ADGG.html), a note is created for each issue. The note frontmatter is populated with the title, url, status, existing tags, and an issueID. You can update the status of the issue (OPEN/CLOSED) and modify the tags within Dendron; after publishing with the publish pod, the changes in status and tags will be reflected in Github.

Upon publishing the note below, for this issue #86, the status will be updated to `CLOSED` and the tags will be updated to `wontfix` and `documentation`

```md
...

title: 86-Extra quotes in links tutorial
url: 'https://github.com/dendronhq/dendron-site/issues/86'
status: CLOSED
issueID: gkdskrereidnYu
tags:
  - wontfix
  - documentation
---
Line 12 of the links page ( https://github.com/dendronhq/dendron-site/edit/master/vault/dendron.tutorial.links.md ) has two consecutive back-quotes before the [[  that do not appear to be necessary. I am not sufficiently confident of this to submit a PR, however.
```
## Configuration

### owner
* description: owner of the repository
* type: string
* required: true

### repository
- description: github repository of the issue
- type: string
- required: true

### token
- description: github personal access token
- type: string
- required: true

### Example Configuration:
```yml
owner: dendronhq
repository: dendron-site
token: ***
```

### Authentication (Populating the token field in the configuration)

To communicate with the Github server, you'll need an OAuth token with the right scopes.
Follow the steps in [Creating a personal access token](https://docs.github.com/en/github/authenticating-to-github/keeping-your-account-and-data-secure/creating-a-personal-access-token) to create a token.

repository: namjul/dendron-site

repo_name: namjul/dendron-site


text:
---
title: Troubleshoot Runtime Instances
no_version: true
content-type: how-to
---

## Out of sync runtime instance

Occasionally, a {{site.base_gateway}} runtime instance might get out of sync
with the {{site.konnect_short_name}} control plane. If this happens, you will
see the status `Out of sync` on the Runtime Instances page, meaning the control
plane can't communicate with the instance.

Troubleshoot the issue using the following methods:

* Ensure the runtime instance is running. If it's not running, start it; if it
is running, restart it.

    Check the sync status in the Runtime Manager.

* Check the logs of the runtime that's appearing as `Out of sync`. The default
directory for {{site.base_gateway}} logs is [`/usr/local/kong/logs`](/gateway/latest/reference/configuration/#log_level).

    If you find any of the following errors:

    * Runtime instance failed to connect to the control plane.
    * Runtime instance failed to ping the control plane.
    * Runtime instance failed to receive a ping response from the control plane.

    You may have an issue on the host network where the instance resides.
    Diagnose and resolve the issue, then restart the instance and check
    the sync status in the Runtime Manager.

* If the logs show a license issue, contact [Kong Support](https://support.konghq.com/).

If you are unable to resolve sync issues using the above methods, contact
[Kong Support](https://support.konghq.com/).

## Missing functionality

If a {{site.konnect_short_name}} feature isn’t working on your runtime instance,
the version may be out of date.

Verify that your instance versions are up to date:

1. Open {% konnect_icon runtimes %} **Runtime Manager**, then open your runtime group.

1. Click **+ Add runtime instance** and check the {{site.base_gateway}} version
in the code block. This is the version that the {{site.konnect_short_name}}
control plane is running.

1. Return to the runtime instances page.

1. Check the runtime instance versions in the table. If you see
an instance running an older version of {{site.base_gateway}}, your runtime
instance may need [upgrading](/konnect/runtime-manager/runtime-instances/upgrade).

If your version is up to date but the feature still isn't working, contact
[Kong Support](https://support.konghq.com/).


text:
# artemdemo.com blog

Basic commands:

- `npm start` - Gatsby will start a hot-reloading development environment accessible at localhost:8000
- `npm run build` - Gatsby will perform an optimized production build for your site generating static HTML and per-route JavaScript code bundles.
- `npm run serve` - Gatsby starts a local HTML server for testing your built site.

## How to publish

```
$ npm run deploy
```

repository: artemdemo/artemdemo-com

repo_name: artemdemo/artemdemo-com


text:
Collections are defined by calls to the StorageRegistry.registerCollection(s) function:

```typescript
storageManager.registry.registerCollections({
    user: {
        version: new Date(2018, 11, 11),
        fields: {
            identifier: { type: 'string' },
            isActive: { type: 'boolean' },
        },
        indices: [
            { field: 'identifier' },
        ]
    },
    todoList: {
        version: new Date(2018, 7, 11),
        fields: {
            title: { type: 'string' },
        },
        relationships: [
            {childOf: 'user'} # creates one-to-many relationship
        ],
        indices: []
    },
})
```

The versions are grouped by date, which could be a release date for example. This allows Storex to give you a history of all your collection versions for data model migration purposes. To access the list of versions, you can use the StorageRegistry.collectionsByVersion map of which the key is the timestamp, and the value is an object mapping collectionName -> collectionDefinition.

Field types
===========

Currently built-in field types are `string`, `text`, `json`, `datetime`, `timestamp`, `boolean`, `float`, `int`, `blob` and `binary`.

**String and text fields:** If you place an index `text` field, it will be marked to be indexed for full-text search.

**JSON fields:** You can pass in JSON-serializable values here, which will be stored by the back-end in the fast, and possibly queryable way. Serialization and deserialization happens automatically on store/retrieval if needed.

**Datetime and timestamp fields:** Depending on preferences, this allows you to either store/retrieve Date objects, or milisecond timestamps.

**Blob and binary fields:** TODO

### Custom fields

You can register your own custom field types, which allows you to do some pre-storage/post-retrieval processing, optionally allowing you to signal to the back-end which of the above primitive field types to store its value as. An example can be found [here](../ts/fields/random-key.ts).

Relationships
=============

You can define three kinds of relationships between collections. `singleChildOf`, `childOf` and `connects`. Each of allows you to multiple connected objects in one call. In the future they will allow also you to fetch related objects when retrieving data, and to filter objects based on their relationships.

### singleChildOf

Creates a one-to-one relationship:
```typescript
storageManager.registry.registerCollections({
    email: {
        version: new Date(2018, 11, 11),
        fields: {
            address: { type: 'string' },
            isActive: { type: 'boolean' },
        },
        indices: []
    },
    activationCode: {
        version: new Date(2018, 7, 11),
        fields: {
            key: { type: 'string' },
        },
        relationships: [
            {
                childOf: 'email',
                // alias: 'emailToBeActivated', // Defaults to the name of the parent collection
                // reverseAlias: 'code' // Defaults to the name of this collection, used to create child objects directly when creating the parent objects
            }
        ],
        indices: []
    },
})
await storageManger.finishInitialization()

const email = await storageManager.collection('email').createObject({address<EMAIL_ADDRESS>isActive: false, activationCode: {key: 'thekey'}})
console.log(email.activationCode)

// The parent objects pk is stored on the child object on the configured alias field
const key = await storageManager.collection('activationCode').findOneObject({email: email.id'})
```

### childOf

Creates a one-to-many relationship:
```typescript
storageManager.registry.registerCollections({
    user: {
        version: new Date(2018, 11, 11),
        fields: {
            displayName: { type: 'string' },
        },
        indices: [],
    },
    email: {
        version: new Date(2018, 11, 11),
        fields: {
            address: { type: 'string' },
            isPrimary: { type: 'boolean' },
            isActive: { type: 'boolean' },
        },
        relationships: [
            {
                childOf: 'user',
                // alias: 'owner', // Defaults to the name of the parent collection
                // reverseAlias: 'usedEmails' // Defaults to the plural name of this collection, used to create child objects directly when creating the parent objects
            }
        ],
        indices: [],
    },
})
await storageManger.finishInitialization()

const user = await storageManager.collection('user').createObject({displayName: 'Joe', emails: [
    {address<EMAIL_ADDRESS>isPrimary: true, isActive: true},
    {address<EMAIL_ADDRESS>isPrimary: false, isActive: true},
]})

// The parent objects pk is stored on child objects on the configured alias field
const emails = await storageManager.collection('activationCode').findObjects({user: user.id'})
```

### connects

Creates a many-to-many relationship by explictly defining a connection between them:
```typescript
storageManager.registry.registerCollections({
    user: {
        version: new Date(2018, 11, 11),
        fields: {
            displayName: { type: 'string' },
        },
        indices: [],
    },
    newsletter: {
        version: new Date(2018, 11, 11),
        fields: {
            title: { type: 'string' },
        },
        relationships: [
            {
                childOf: 'user',
                alias: 'owner',
            },
        ],
        indices: [],
    },
    subscription: {
        version: new Date(2018, 11, 11),
        fields: {
            isActive: { type: 'boolean' }
        },
        relationships: [
            {
                connects: ['user', 'newsletter'],
                aliases: ['subscriber', 'newsletter'],
                reverseAliases: ['newsletterSubscriptions', 'subscriptions'],
            },
        ],
        indices: [],
    }
})
await storageManger.finishInitialization()

// For now, you'll have to create and retrieve parents, children and connections between them manually until we figure out a nice way to make this easier.
const user = await storageManager.collection('user').createObject({displayName: 'Joe'})
const newsletter = await storageManager.collection('newsletter').createObject({title: 'The blahoo'})
const subscription = await storageManager.collection('newsletter').createObject({subscriber: user.id, newsletter: newsletter.id})
```

Indices
=======

TBD

repository: WorldBrain/storex

gha_language: TypeScript

repo_name: WorldBrain/storex


text:
# NetJSON Templates

NetJSON is a data interchange format based on JavaScript Object Notation (JSON) designed to describe the basic building blocks of layer2 and layer3 networks. OpenWISP uses NetJSON to create configurations. If you have devices with very similar configuration dictionaries you can store the shared blocks in one or more reusable templates which will be used as a base to build the final configuration.

*TL;DR*: OpenWISP configurations can be simplified with the help of reusable templates written in NetJSON.

## Learn About Templates

Here are a couple of links in case you are unfamiliar with the concept of templates.

1. [Introduction to OpenWISP - Video](https://www.youtube.com/watch?v=MY097Y2cPQ0)
2. [Basic Concepts: Templates](http://netjsonconfig.openwisp.org/en/stable/general/basics.html#template)

## Contributing

Please read CONTRIBUTING.md for details on our process for submitting pull requests to us.

## License

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

repository: openwisp/netjson-templates

gha_language: CSS

repo_name: openwisp/netjson-templates


text:
# Done!

In the description of the problem we haven't mentioned the `select` loop.

The `select` loop helps us to organize a user menu. It has almost the same syntax as a `for` loop:

```bash
select answer in elem1 elem2 ... elemN
do
  # statements
done
```

The `select` prints all `elem1..elemN` on the screen with their sequence numbers, after that it prompts the user. Usually it looks like `$?` (`PS3` variable). The answer will save in `answer`. If `answer` is the number between `1..N`, then `statements` will execute and `select` will go to the next iteration — that's because we should use `break` statement.

A working example might look like this:

```bash
#!/bin/bash

PS3="Choose the package manager: "
select ITEM in bower npm gem pip
do
  echo -n "Enter the package name: " && read PACKAGE
  case $ITEM in
    bower) bower install $PACKAGE ;;
    npm)   npm   install $PACKAGE ;;
    gem)   gem   install $PACKAGE ;;
    pip)   pip   install $PACKAGE ;;
  esac
  break # avoid infinite loop
done
```

This example, asks the user what package manager to use. Then, it will ask what package we want to install and finally proceed to install it.

If we run this, we will get:

```
$ ./my_script
1) bower
2) npm
3) gem
4) pip
Choose the package manager: 2
Enter the package name: bash-handbook
<installing bash-handbook>
```

In the next exercise you will take a look at what functions are in bash.

repository: WeilerWebServices/Bash

repo_name: WeilerWebServices/Bash


text:
---
layout: post
title: 'Day 24: File ACL under GNU-Linux'
published: true
---
## Acess Control Lists
![getfacl_featured](https://github.com/codarrenvelvindron/codarrenvelvindron.github.io/raw/master/images/getfacl_featured.png)

There is a transparent way of managing files and directories under GNU/Linux.

And it's called ACL.

## A little history
There are few projects that you never meant to be managing.

But there you are doing it.

I had inherited from one of those.

Due to the people actually working on it leaving the company.

## The problem ?
You have set permissions to files and directories.

You have added the new user to the valid users of that particular directory.

The owner's/group and users permissions are already set and you know it's the right thing (chmod/chown)

But... When the user connects to the share, he gets an access denied.

Chances are you're blocked by an ACL.

## Resolving it
If you are giving a user access to a whole directory, that should be done recursively.

Else, the user will be able to enter the directory.

But he won't be able to do anything else, like reading and changing files.

## Steps
1. Get the current ACL
```
getfacl Downloads
```
![downloads facl](https://github.com/codarrenvelvindron/codarrenvelvindron.github.io/raw/master/images/facl_downloads_before.png)

2. Set the new ACL, positioned to the new user
```
setfacl -d -Rm u:bogususer:rwx Downloads/
```

d = d for default --> apply this acl change to the default acl. Useful if you have a default ACL already in place.

R = recursive --> When you're applying a change to a directory, you'd want to apply it to the files inside. This does it.

m = modify --> modifies current acl

u = user --> Specify username, in my case i created a new bogususer

rwx = read/write/execute --> options are r,w,x. You could select rw for read/write, and so on.

3. Check if the new ACL is successfully created
```
getfacl Downloads/
```
![getfacl](https://github.com/codarrenvelvindron/codarrenvelvindron.github.io/raw/master/images/getfacl_end.png)

4. Success !

## \Codarren/


text:
## 137. [Single Number II](https://leetcode.com/problems/single-number-ii/)

> Medium

Given a **non-empty** array of integers, every element appears *three* times except for one, which appears exactly once. Find that single one.

**Note:**

Your algorithm should have a linear runtime complexity. Could you implement it without using extra memory?

**Example 1:**

```
Input: [2,2,3,2]
Output: 3
```

**Example 2:**

```
Input: [0,1,0,1,0,1,99]
Output: 99
```

**Solutions:**

Firstly, we can use map to solve this problem.

Here is my solution class:

```c++
class Solution {
public:
	int singleNumber(vector<int>& nums) {
		map<int/*num*/, int/*times*/> mp;
		for (auto num : nums)
			mp[num]++;
		for (auto it : mp)
			if (it.second == 1)
				return it.first;
		return -1;
	}
};
```

Then, similar to Problem No.136, there's also a bit operation method.

Define `once` and `twice` representing numbers exist once and twice. We all know that `a ^ a = 0` which means `a` shows twice. Therefore, when first `a` shows, `once = ~0 & (0 ^ a) = a` and `twice = ~a & (0 ^ a) = 0`; when the second `a` shows, `once = ~0 & (a ^ a) = 0` and `twice = ~0 & (0 ^ a) = a`; then the third `a` shows, `once = ~a & (0 ^ a) = 0` and `twice = ~0 & (a ^ a) = 0`.

After operate all numbers in `nums`, `once = the only single number`.

```c++
class Solution {
public:
	int singleNumber(vector<int>& nums) {
		int once = 0, twice = 0;
		for (auto num : nums) {
			once = ~twice & (once ^ num);
			twice = ~once & (twice ^ num);
		}
		return once;
	}
};
```

repository: YuanweiZHANG/Leetcode

repo_name: YuanweiZHANG/Leetcode


text:
---
author: admin
comments: true
date: 2009-12-11 15:21:36+00:00
layout: post
slug: reblog-from-avc-com-a-vc
title: 'reBlog from avc.com: A VC '
wordpress_id: 21
---

I found this fascinating quote today:

>

>
> I believe that in startups, like venture investing, the cost of making a bad decision is not nearly as great as the benefit of making a good one. So I like action oriented leaders.avc.com, [A VC](http://www.avc.com/a_vc/2009/12/action-oriented.html), Dec 2009
>
>

It's cheating to start a blog post with a quote from Fred Wilson. He is that good. But sometimes you need to cheat and I'm doing it today.

I suggest that you read the [whole article](http://www.avc.com/a_vc/2009/12/action-oriented.html), which exactly captures what startups ought to be doing, and why the cost of not trying is way more than trying and failing.

extension: markdown


text:
---
layout: page
title: About
permalink: /about/
---

Hi there! Thanks for reading my blog.
I'm Andrew Byrne and I'm a Senior Content Developer at Microsoft. My software career spans many countries, many companies and many roles over many years. I love learning and this blog is dedicated to sharing my discoveries and some opinions with you. I hope you enjoy!

### More Information

All opinions on this site are my own.

### Current Work

Check out my edX course [**Writing Professional Code**](https://www.edx.org/course/writing-professional-code-microsoft-dev275x)

### Contact me

Twitter: [@AndrewJByrne](https://twitter.com/andrewjbyrne)

Github: [@AndrewJByrne](https://github.com/andrewjbyrne)


text:
# Fast Artistic File Transfer

This is the code for the paper

**[Perceptual Losses for Real-Time Style Transfer and Super-Resolution](http://cs.stanford.edu/people/jcjohns/eccv16/)**

[Justin Johnson](http://cs.stanford.edu/people/jcjohns/),
[Alexandre Alahi](http://web.stanford.edu/~alahi/),
[Li Fei-Fei](http://vision.stanford.edu/feifeili/)

Presented at [ECCV 2016](http://www.eccv2016.org/)

## Install

refreshing the repositories
```sh
sudo apt update
```

its wise to keep the system up to date! you can skip the following line if you not want to update all your software
```sh
sudo apt upgrade
```

installing python 3.6.5 and pip for it
```sh
sudo apt-get install python3-pip
```
installing python virtualenv
```sh
sudo pip install virtualenv
```

install virtualenv and application dependencies
```sh
virtualenv ~/fast_style_transfer/
source ~/fast_style_transfer/bin/activate
pip install -r requirements_python3.txt
```

## Usage

```sh
source ~/fast_style_transfer/bin/activate

```

Once the virtualenv is set up, go throught train.py and change the paths of the dataset and folders and run to train.


text:
## Description
An API for uploading data about battles fought to Teiserver.

}
```

**Failure response**
```
{
  "result": "failure",
  "reason": "auth error"
}
```

### POST /teiserver/api/battles -- Uploads a battle
```
curl -X POST $SERVER_ADDR/teiserver/api/battle/create -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" -d '{--data goes here--}'

## Example data
{
  "outcome": "completed",
  -- other stuff here, just needs to be marked as completed --
}
```

repository: rafidka/teiserver

repo_name: rafidka/teiserver


text:
# Test that copying a patch works as expected

```unison:hide
x = 1
```

```ucm
.> add
```

Change the definition of `x` so something goes in our patch:

```unison:hide
x = 2
```

```ucm
.> update foo.patch
```

Copy the patch and make sure it's still there.

```ucm
.> copy.patch foo.patch bar.patch
.> ls foo
.> view.patch foo.patch
.> ls bar
.> view.patch bar.patch
```

Now move the patch.

```ucm
.> move.patch foo.patch qux.patch
```

The moved patch should be gone.

```ucm:error
.> view.patch foo.patch
.> ls foo
```

repository: unisonweb/unison

branch_name: refs/heads/trunk

gha_language: Haskell

gha_license_id: NOASSERTION

repo_name: unisonweb/unison


text:
---
title: "Visual Lab - Facial Recognition AI"
subtitle: "A project done alongside INESC TEC with the purpose of developing facial recognition software in order
to recognize the face of a person with their identity card, using Siamese Twins Neural Networks."
link: https://github.com/andrefmrocha/VI_LAB_2018_Card_Detection
image_1: "../images/siamese-network.png"
image_2: "../images/siamese-network-2.png"
image_1_legend: "A visual example of siamese network"
image_2_legend: "A visual example of a autoencoder"
date: "2018-08-01"
---

Using Bayesian One-Shot Learning Algorithm, the comparison in order to check if the object is present in the image is done as well as a calculation if the image itself is only background clutter. In order to make this check with images, both images are passed as arguments, so that they are both normalized by the same network, being those results then concatenated, so that they are then compared.
However, beforehand, autoenconders are used to remove background noise from the images.


text:
![money](./public/money.jpg)
## Description
- This app provides you with future expected currency exchange rates, and current currency exchange rates, allowing you to choose a good time to exchange your money.

link to deployed [site](http://callous-summer.surge.sh)

## To install and run locally
- clone this repository. Then in your terminal type in npm install while in this repository. then type npm start while still in this directory.

## Contact info
<EMAIL_ADDRESS>www.linkedin.com/in/austenelswick

## License
MIT license

repository: AustenElswick/Exchange-Estimations

repo_name: AustenElswick/Exchange-Estimations