text:
# eFuse Example

## Overview

This example shows how to use the eFuse API. It demonstrates read and write operations with fields from the common and custom eFuse tables. For more information about eFuse, see the “eFuse Manager” chapter in the documentation and the “eFuse Controller” chapter in ESP32 TRM.

The eFuse is a single bit of non-volatile memory with the restriction that once an eFuse bit is programmed to 1, it can not be reverted to 0.
The eFuse fields can be useful to store: device types, serial numbers, some system variables, etc.

Note that the bits already written cannot be reset to the original state. For debugging purposes, the `CONFIG_EFUSE_VIRTUAL` option is provided. This option will block physical burning. All work happens with an array in RAM.
In this example, all write operations are wrapped in `#ifdef CONFIG_EFUSE_VIRTUAL ... # endif` to prevent accidental burn while testing the features.

## How to use example

This example first reads the eFuse field, then writes a value, then reads it again. The program can be seen in the logs.

The program uses two eFuse tables:

 * The common table (for IDF purposes).
 * The custom table (for custom purposes).

The custom table has five fields:

```
MODULE_VERSION,                   EFUSE_BLK3,    56,  8,    Module version
DEVICE_ROLE,                      EFUSE_BLK3,    64,  3,    Device role
SETTING_1,                        EFUSE_BLK3,    67,  6,    Setting 1
SETTING_2,                        EFUSE_BLK3,    73,  5,    Setting 2
CUSTOM_SECURE_VERSION,            EFUSE_BLK3,    78, 16,    Custom secure version
```

### Hardware Required

To run this example, you need to use the ESP32 developer board. If your ESP32 has the `None` coding scheme of eFuse, then write and read operations have no limitations. But if it has the `3/4` or `RS` coding scheme, the writing may lead to an error due to the fact that some coded value was written earlier. A simple way to find out what coding scheme your chip has, you can see in the log while esptool is working or the log of the program:

```
esptool.py v2.7-dev
Serial port /dev/ttyUSB0
Connecting........_____.....__
Detecting chip type... ESP32
Chip is ESP32-PICO-D4 (revision 1)
Features: WiFi, BT, Dual Core, Embedded Flash, Coding Scheme None
MAC: d8:a0:1d:40:ac:90
```

The esptool also has a command to get general information about the chip `esptool.py chip_id`:

```
esptool.py v2.8-dev
Found 1 serial ports
Serial port /dev/ttyUSB0
Connecting........_
Detecting chip type... ESP32
Chip is ESP32-PICO-D4 (revision 1)
Features: WiFi, BT, Dual Core, Embedded Flash, Coding Scheme None
Crystal is 40MHz
MAC: d8:a0:1d:40:ac:90
Uploading stub...
Running stub...
Stub running...
Warning: ESP32 has no Chip ID. Reading MAC instead.
MAC: d8:a0:1d:40:ac:90
Hard resetting via RTS pin...
```

### Configure the project

```
idf.py menuconfig
```

In this example, there is `sdkconfig.default`, which already includes all the necessary settings. No need to configure.

 * `CONFIG_EFUSE_CUSTOM_TABLE=y` - It allows using the custom table.
 * `CONFIG_EFUSE_VIRTUAL=y` - All read and writes operations are redirected to RAM instead of eFuse registers. Not really burning eFuses.

### Build and Flash

Build the project and flash it to the board, then run monitor tool to view serial output:

```
idf.py -p PORT flash monitor
```

(Replace PORT with the name of the serial port to use.)

(To exit the serial monitor, type ``Ctrl-]``.)

See the Getting Started Guide for full steps to configure and use ESP-IDF to build projects.

## Example Output

For ``None`` coding scheme:

```
I (0) cpu_start: Starting scheduler on APP CPU.
I (323) example: Coding Scheme NONE
I (323) example: Uses common and custom tables
I (333) example: read efuse fields
I (333) example: 1. read MAC address: d8:a0:1d:40:ac:90
I (343) example: 2. read secure_version: 0
I (343) example: 3. read custom fields
I (353) example: module_version = 0
I (353) example: device_role = None
I (363) example: setting_1 = 0
I (363) example: setting_2 = 0
I (363) example: custom_secure_version = 0
W (373) example: This example does not burn any efuse in reality only virtually
W (383) example: Write operations in efuse fields are performed virtually
I (383) example: write custom efuse fields
W (393) efuse: Virtual efuses enabled: Not really burning eFuses
W (403) efuse: Virtual efuses enabled: Not really burning eFuses
W (403) efuse: Virtual efuses enabled: Not really burning eFuses
W (413) efuse: Virtual efuses enabled: Not really burning eFuses
W (423) efuse: Virtual efuses enabled: Not really burning eFuses
I (423) example: module_version = 1
I (433) example: device_role = Slave
I (433) example: setting_1 = 3
I (433) example: setting_2 = 4
I (443) example: custom_secure_version = 5
I (443) example: Done
```

And for ``3/4`` coding scheme:

```
I (0) cpu_start: Starting scheduler on APP CPU.
I (327) example: Coding Scheme 3/4
I (327) example: Uses common and custom tables
I (337) example: read efuse fields
I (337) example: 1. read MAC address: 84:0d:8e:18:8e:44
I (347) example: 2. read secure_version: 0
I (347) example: 3. read custom fields
I (357) example: module_version = 0
I (357) example: device_role = None
I (367) example: setting_1 = 0
I (367) example: setting_2 = 0
I (367) example: custom_secure_version = 0
W (377) example: This example does not burn any efuse in reality only virtually
W (387) example: Write operations in efuse fields are performed virtually
I (387) example: In the case of 3/4 coding scheme, you cannot write efuse fields separately
I (397) example: You should use the batch mode of writing fields for this
I (407) efuse: Batch mode of writing fields is enabled
W (417) efuse: Virtual efuses enabled: Not really burning eFuses
I (417) efuse: Batch mode of writing fields is disabled
I (427) example: module_version = 1
I (427) example: device_role = Slave
I (437) example: setting_1 = 3
I (437) example: setting_2 = 4
I (437) example: custom_secure_version = 5
I (447) example: Done
```

### How to create the new custom table

In the main folder of the example there is a custom eFuse table - `esp_efuse_custom_table.csv`. You can add there some fields and run `idf.py efuse_custom_table`, it will generate all the necessary source files. If all is ok then you will see:

```
...
Parsing efuse CSV input file /home/kostia/esp/esp-idf/components/efuse/esp32/esp_efuse_table.csv ...
Verifying efuse table...
Parsing efuse CSV input file /home/kostia/esp/esp-idf/examples/system/efuse/main/esp_efuse_custom_table.csv ...
Verifying efuse table...
Creating efuse *.h file /home/kostia/esp/esp-idf/examples/system/efuse/main/include/esp_efuse_custom_table.h ...
Creating efuse *.c file /home/kostia/esp/esp-idf/examples/system/efuse/main/esp_efuse_custom_table.c ...
Max number of bits in BLK 192
```

If the following fields were not changed in the CSV file: field_name, efuse_block, bit_start or bit_count, then a new generation will not occur, and you will see this message `Source files do not require updating correspond to csv file`.

This command will create into main folder two files: `esp_efuse_custom_table.c` and `include/esp_efuse_custom_table.h`.

Do not forget to add these files for the Cmake build system:

```
idf_component_register(SRCS "efuse_main.c" "esp_efuse_custom_table.c"
                       INCLUDE_DIRS "." "include")
```

If you are not sure which eFuse bits are free you can run `idf.py show_efuse_table`. It prints a sorted list of the common and custom tables.

repository: EmbeddedSystemClass/esp-idf

repo_name: EmbeddedSystemClass/esp-idf


text:
# event-handlers

tldr; Use [partial application and closures](https://hackernoon.com/ingredients-of-effective-functional-javascript-closures-partial-application-and-currying-66afe055102a) to avoid re-rendering when using event handlers with parameters in React components.

Below is a typical case where we map over an array of notes and add an editNote event handler for each note.

```tsx
<div>
    <div>
        Contacts
    </div>
    {stuff.map(x => (
        <div key={x.id}>
            <button onClick={e => editNote(x)}>Edit</button> {x.content}
        </div>
    ))}
</div>
```

The problem with this pattern is the event handler is created each time the component is re-rendered,
which means the button content has changed so the button is re-rendered.

An alternative pattern is shown below using partial application and closures.

```tsx
import * as React from 'react';

interface Note {
    id: number;
    content: string;
}
const notes: Note[] = [
    { id: 1, content: 'Note one' },
    { id: 2, content: 'Note two' },
    { id: 3, content: 'Note three' }
];

const editNote = (x: Note) => (e: any) => {
    e.preventDefault();
    console.log(`Edit note ${x.id}`);
};

interface Props {}

export const NoteManager = (props: Props) => {
    return (
        <div>
            <div>
                Contacts
            </div>
            {notes.map(x => (
                <div key={x.id}>
                    <button type="button" onClick={editNote(x)}>
                        Edit
                    </button>
                    {x.content}
                </div>
            ))}
        </div>
    );
};
```

Thanks to

- [Miron Machnicki](https://medium.com/@machnicki/handle-events-in-react-with-arrow-functions-ede88184bbb)
- [Charles Stover](https://medium.com/@Charles_Stover/cache-your-react-event-listeners-to-improve-performance-14f635a62e15)

license: MIT

repository: pjsvis/react-patterns

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: pjsvis/react-patterns


text:
# *Restaurant Tutorial*

**Restaurant Tutorial** is a full-stack web app using the popular MERN stack. In this web app a user can create reviews for restaurants in a yelp-like setting. Then users can save their reviews by logging in and also come back to delete those reviews in the future. The pros of this app includes its entire serverless backend possible due to MongoDB Realm

Created by: **Promise Onwuegbuchu**

Time spent: **12** hours spent in total

## Video Walkthrough

Here's a walkthrough of implemented user stories:

[Walkthrough](https://imgur.com/oSQ8b9H).

GIF created with [LiceCap](http://www.cockos.com/licecap/).

## Notes

Couple Improvements I would like to make to this bot in the future would be to enhance the assets of the webpage, make it more pleasing to view. Also it'd be better to add a better login system and store a certain number of users to view. Also adding real restaurants geo-located close to a users current location

## License

    Copyright 2021 Promise Onwuegbuchu

    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: promisecsmajor/restaurant-tutorial

branch_name: refs/heads/main

repo_name: promisecsmajor/restaurant-tutorial


text:
---
lip: 1
title: Oracle interface and reward algorithm specification
status: Implemented
author: Kirill Varlamov
discussions-to: none
created: 2020-11-10
updated: 2020-11-10
---

# Oracle interface and reward algorithm specification for v0.2.x

## Problems with v0.1.x

* The funds "in process" (from deposit submission until it gets processed and added to the beacon state's validators list) got treated like a decrease, the behavior was equal to slashing and lead to significant drops in stETH supply. See [lido-dao#110](https://github.com/lidofinance/lido-dao/issues/110)

## How they can be solved

* In-flight funds (submitted but not included in the beacon state) should be taken into account by the Lido contract.

## Proposal

### Bisiness logic of rewards calculation

```python
class LidoContract:
    """Lido.sol"""

    def __repr__(self):
        return(f"<Lido BcnValidators:{self.lastBeaconValidators} " +
               f"totalValidators:{self.totalValidators} " +
               f"bufferedBalance:{self.bufferedBalance} " +
               f"getInProcessBalance:{self.getInProcessBalance()} " +
               f"getTotalPooledEth:{self.getTotalPooledEth()}>")

    lastBeaconValidators = 0 # online validators reported by oracle (=all validators with retrievable balances)
    lastBeaconBalance = 0

    '''Total amount of validators incremented on each deposit.
    Note: was totalDepositCalls before v0.2.x
    Note: this value never decreases
    '''
    totalValidators = 0

    """The amount of Ethers received but not yet staked to DepositContract
    equals to web3.eth.getBalance(LidoContract), nominated in wei"""
    bufferedBalance = 0.0

    def reportBeacon(self, beaconValidators, beaconBalance): #onlyOracleContract
        """Called by the Oracle Contract (that in turn is called by the Oracle Daemons)

        arguments:
        beaconValidators -- the number of validators seen on beacon in the beaconChain validators index.
                            The validators can have the following states (for lighthouse API):
                            Active,
                            ExitedSlashed,
                            Withdrawable,
                            StandbyForActive,
                            WaitingInQueue,
                            WaitingForFinality,
                            etc..
                            https://github.com/sigp/lighthouse/blob/f8da151b0bec12a707a742260dfe635a6a1890f4/common/eth2/src/types.rs#L247
                      at the state (DEPOSITED or ACTIVE).Validators in activation queue are not accounted
        beaconBalance -- the total sum of all validators' balances on the beacon in wei (1e-18 ETH)

        """
        reportedBeaconBalance = beaconBalance # in wei
        reportedBeaconValidators = beaconValidators

        #just appeared validators. We assume the base balance is 32 for them
        appearedBeaconValidators = reportedBeaconValidators - self.lastBeaconValidators

        rewardBase = (appearedBeaconValidators * 32) + self.lastBeaconBalance
        print("calculated rewardBase", rewardBase)

        # If there was profit on the interval
        if reportedBeaconBalance > rewardBase :
            print("There was profit since last report, pay reward")
            reward = reportedBeaconBalance - rewardBase
            print("Pay reward", reward)
        else:
            print("No profit since last reward. Nothing to pay")

        self.lastBeaconBalance = reportedBeaconBalance
        self.lastBeaconValidators = reportedBeaconValidators

    def getInProcessBalance(self): #public
        """Returns the total base balance (multiple of 32) of validators in transient state (from deposit submission until
        it gets processed and added to the beacon state's validators list).
        The value nominated in wei (1e-18 Ether)
        """
        return (self.totalValidators - self.lastBeaconValidators) * 32.0

    def getTotalPooledEth(self): #public    was totalControlledEther in v0.1.x
        """Returns the sum of all the balances in the system.
        Nominated in wei (1e-18 Ether)
        """
        return self.bufferedBalance + self.getInProcessBalance() + self.lastBeaconBalance

    def submit(self, eth_amount):
        self.bufferedBalance += eth_amount
        # this is done separately. Combned for simplicity
        deposits_iter = int(self.bufferedBalance / 32)
        for iter in range(deposits_iter):
            self.bufferedBalance -= 32
            self.totalValidators += 1

class OracleContract:
    """LidoOracle.sol"""

    def __init__(self, lido):
        self.lido = lido

    def reportBeacon(self, epoch, beaconValidators, beaconBalance):
        """Receives reports from oracles. New interface for v0.2
        before v0.2.x was: pushData(uint256 _reportInterval, uint256 _eth2balance)

        arguments:
        epoch -- the reportable epoch
        beaconValidators -- the number of validators seen on beacon. This includes all the visible validators
                      (all the states )
        beaconBalance -- the total sum of all validators' balances on the beacon in wei (1e-18)

        The Oracle does not do any checks or validation, just checks if the mode achieved on reported value.
        self._tryFinalize()

        If yes, it pushes the value to the Lido
        """
        self.lido_contract.reportBeacon(beaconValidators, beaconBalance)
```

#### Behavior illustration

```
In:
oracle_contract = OracleContract(lido_contract)
lido_contract

Out:
<Lido BcnValidators:0 totalValidators:0 bufferedBalance:0.0 getInProcessBalance:0.0 getTotalPooledEth:0.0>

In:
"""User submits 100 ETH, and the funds get deposited to depositContract"""
lido_contract.submit(100)
lido_contract

Out:
<Lido BcnValidators:0 totalValidators:3 bufferedBalance:4.0 getInProcessBalance:96.0 getTotalPooledEth:100.0>

In:
"""the first validator appeared online.
This is not considered as a reward, no payouts"""
lido_contract.reportBeacon(1, 32)
lido_contract

Out:
calculated rewardBase 32
No profit since last reward. Nothing to pay
<Lido BcnValidators:1 totalValidators:3 bufferedBalance:4.0 getInProcessBalance:64.0 getTotalPooledEth:100.0>

In:
"""Got the first profit. Reward detected and paid"""
lido_contract.reportBeacon(1, 33)
lido_contract

Out:
calculated rewardBase 32
There was profit since last report, pay reward
Pay reward 1
<Lido BcnValidators:1 totalValidators:3 bufferedBalance:4.0 getInProcessBalance:64.0 getTotalPooledEth:101.0>

In:
"""Slashed down"""
lido_contract.reportBeacon(1, 32.5)
lido_contract

Out:
calculated rewardBase 33
No profit since last reward. Nothing to pay
<Lido BcnValidators:1 totalValidators:3 bufferedBalance:4.0 getInProcessBalance:64.0 getTotalPooledEth:100.5>

In:
"""Partial recovery from the loss considered as a reward."""
lido_contract.reportBeacon(1, 33)
lido_contract

Out:
calculated rewardBase 32.5
There was profit since last report, pay reward
Pay reward 0.5
<Lido BcnValidators:1 totalValidators:3 bufferedBalance:4.0 getInProcessBalance:64.0 getTotalPooledEth:101.0>

In:
"""the second validator appeared online.
This is not considered as a reward, no payouts"""
lido_contract.reportBeacon(2, 65)
lido_contract

Out:
calculated rewardBase 65
No profit since last reward. Nothing to pay
<Lido BcnValidators:2 totalValidators:3 bufferedBalance:4.0 getInProcessBalance:32.0 getTotalPooledEth:101.0>

In:
"""Third validator just appeared, but some others were slashed - No reward"""
lido_contract.reportBeacon(3, 96)
lido_contract

Out:
calculated rewardBase 97
No profit since last reward. Nothing to pay
<Lido BcnValidators:3 totalValidators:3 bufferedBalance:4.0 getInProcessBalance:0.0 getTotalPooledEth:100.0>

In:
"""Loss was partially compensated. Pay reward"""
lido_contract.reportBeacon(3, 97)
lido_contract

Out:
calculated rewardBase 96
There was profit since last report, pay reward
Pay reward 1
<Lido BcnValidators:3 totalValidators:3 bufferedBalance:4.0 getInProcessBalance:0.0 getTotalPooledEth:101.0>
```

## Implementation notices

### Oracle

The existing business logic of [Lido Oracle code](https://github.com/lidofinance/lido-dao/blob/master/contracts/0.4.24/oracle/LidoOracle.sol) basically remains the same as v0.1.x. The key changes are:

* Remove report interval, corresponding getters and setters - now we bind to epochs
* New interface and Report layout
* Implement current reportable epoch checks and if the epoch has been reported - postponed to v0.2.1 (after initial launch on testnet)
* Other synchronisation rules - postponed to v0.2.1 (after initial launch on testnet)
* `mode` function (https://github.com/lidofinance/lido-dao/blob/d8139560efb892bbb479bdc8ffc662929a78ea2c/contracts/0.4.24/oracle/Algorithm.sol#L13) should be adapted/tested with the `struct Report` as a payload.

```
pragma solidity 0.4.24;

contract LidoOracle {

    // the variables are tightly packed to 256bit word
    struct Report {
        uint64 epoch;
        uint64 beaconValidators;
        uint128 beaconBalance;
    }

    Report public report;

    // use conventional ABI encoder, no "experimental features" here
    function reportBeacon(uint64 _epoch, uint64 _beaconValidators, uint128 _beaconBalance) public {
        report = Report({epoch: _epoch, beaconValidators: _beaconValidators, beaconBalance: _beaconBalance});
        // SSTORE occupies 1 slot

        // Checks go here
        // Quorum business logic goes here
        // Downstream reporting to Lido goes here
    }
}
```

### Lido

* Implement reward calculations from the cells above. (Reward base calculated in runtime, validators that are in a transient state get accounted)
* Adapt variables naming and interfaces with this spec and oracle contract (rename `pushData` to `reportBeacon`)

repository: rigidus/lido-improvement-proposals

branch_name: refs/heads/develop

repo_name: rigidus/lido-improvement-proposals


text:
# User Specified Compaction

## Summary

In Pegasus, sometimes we should add user specified compaction policy to reduce disk usage. This RFC proposes a user specified compaction design.

## Design

Add two classes named with `compaction_operation` and `compaction_rule`.

`compaction_filter_rule` represents the compaction rule to filter the keys which are stored in rocksdb.
There are three types of compaction operation:
- Hashkey rule, which supports prefix match, postfix match and anywhere match.
- Sortkey rule. Just like hashkey rule, it also supports prefix match, postfix match and anywhere match.
- TTL rule. It supports time range match with format [begin_ttl, end_ttl]

`compaction_operation` represents the compaction operation. A compaction operation will be executed when all the corresponding compaction rules are matched.
There are two types of compaction filter rule:
- Delete. It represents that we should delete this key when all the rules are matched.
- Update TTL. It represents that we should update TTL when all the rules are matched.

Finally, we should save the information about user specified compaction in app env. In order to make these information can still be retrieved after the machine is restarted.

## Class Diagram

Here is the class diagram for user specified compaction.

```
          +---------------+                              +-----------------+
          | compaction op +------------------------------+ compaction rule |
          +------^--------+                              +--------^--------+
                 |                                                |
        _________|_________                 ______________________|______________________
       |                   |               |                      |                      |
       |                   |               |                      |                      |
       |                   |               |                      |                      |
+------------+      +------------+  +--------------+      +--------------+       +--------------+
| update ttl |      |   delete   |  | hashkey rule |      | sortkey rule |       |    ttl rule  |
+------------+      +------------+  +--------------+      +--------------+       +--------------+
```

repository: xxmazha/pegasus

repo_name: xxmazha/pegasus


text:
# NFT Deployer

Handles the deployment of NFT contracts as well as minting of NFTs on said contracts.

Right now only deploys and mints ERC721 contracts/tokens.

[Demo](https://vagabond.mypinata.cloud/ipfs/QmW8ft5vEG7DcEkzZz2zEcgUYTHzNyPBJY4r3tXA4zTN8D/#/)
## Environment Variables

If you have an Infura API key, add it to the `.env.sample` file and then rename the file to `.env`

## Install Dependencies

### `npm install` or `yarn`

## Start app

### `npm start` or `yarn start`

## Supported Networks

- Ethereum Mainnet
- Rinkeby
- Goerli
- Kovan
- Ropsten

repository: nipz/nft-deployer

repo_name: nipz/nft-deployer


text:
# Ilse B's work for Text IO

## Homework
[collections]() (python code)

[dictionary](Ilse_B/mediadesign/dictionary/dictionary.pv)

[list](Ilse_B/mediadesign/dictionary/list.pv)

[room](Ilse_B/mediadesign/dictionary/room.pv)

[spotify02](Ilse_B/mediadesign/dictionary/spotify02.pv)

## Concept

## Prototype: working demo

## Design the flow of the program

## How to use the script

## PDF format

repository: ArtezGDA/text-IO

repo_name: ArtezGDA/text-IO


text:
# WebSharper

* [Installation](Install.md)
* Developing Applications
    * [Getting Started](GettingStarted.md)
    * [Creating JavaScript Applications and Libraries](Libraries.md)
        * [Binding to Existing JavaScript Code](Bindings.md)
        * [Using the Interface Generator](InterfaceGenerator.md)
        * [Porting .NET Code to JavaScript with Proxies](Proxies.md)
        * [Generating TypeScript Definitions](TypeScriptOutput.md)
    * HTML Applications
        * [HTML Combinators](HtmlCombinators.md)
        * [Using Formlets](Formlets.md)
        * [Using Sitelets](Sitelets.md)
    * Client-Server Applications
        * [Calling Remote Procedures](Remoting.md)
        * [Using Pagelets](Pagelets.md)
    * [Mobile Applications](Mobile.md)
* Deploying Code
    * [Deploying to IIS](IIS.md)
    * [Deploying with Web API (OWIN, Standalone, IIS)](WebApi.md)
    * Generating Standalone HTML Applications
    * [Bundling Code](Bundling.md)
* Reference
    * Standard Libraries
        * [Asynchronous Workflows](Async.md)
    * Attributes
    * Core Extensions
        * [jQuery](jQuery.md)
        * [DOM](DOM.md)
        * [ECMA-262](ECMA-262.md)
* Developing WebSharper
    * Building from Source
    * Roadmap
    * [Release Notes](ReleaseNotes.md)
* Licensing
* Contact

repository: dotnet-websharper/core

gha_language: F#

repo_name: dotnet-websharper/core


text:
# BWGP-RCT
Bayesian Whole Genome Prediction for Randomized Clinical Trials

y
(numeric, n) the data-vector (NAs allowed).

data.fixed
(data.frame, n x d) data frame containing non-genetic covariates - should not include the treatment variable (NAs not allowed). Can be NULL. The fixed model will be constructed based on the specified parameterization approach (will include tx interactions). Interactions between variables (other than tx) should be included in data.fixed as a seperate variable to be included in the model. Entry order should match with tx and K.

tx
(integer/numeric, n) vector of treatment indicators (only 0 and 1s allowed: 0: control, 1:tx) - (NAs not allowed). Entry order should match with data.fixed and K.

X.marker
(matrix, n x J) the genotype matrix (coded as 0,1,2: count of minor alleles for each SNP) (NAs not allowed). Marker names are suggested to be stored in dimnames(X.marker)[[2]]. Entry order should match with data.fixed, tx and K.

K
(matrix, n x n) the genetic relationship matrix (GRM) (NAs not allowed). Entry order should match with data.fixed, tx and data.fixed.

par.app
(string) The parameterization approach. Can take values "group" for the group-specific approach; "interaction" for the interaction approach (specify int.cond if so); or "common" for common effects only. Note: The input is case sensitive.

int.cond
(string) Interaction approach assumption ("independent" or "dependent"). Dependent approach assumes a hierarchical relationship between main and interaction effects (main effects are included in the model if corresponding interaction is included).

fixed.prior
(string) The prior model for fixed genetic effects (two approaches implemented: "NormalMixture" and "BL" (Bayesian LASSO).

cov.app
(string) The covariance modeling approach. Can take values c("stratified","adaptive","pooled","none"). Note: The input is case sensitive.

varyingE
(logical) if TRUE the error variance is allowed to vary between tx groups. Defaults to TRUE.

nIter,burnIn, thin
(integer) the number of iterations, burn-in and thinning.

saveAt
(string) this may include a path and a pre-fix that will be added to the name of the files that are saved as the program runs.

HPL
(list) A list containing hyperparameter values. Note that the list contents depend on parameter (par.app) and covariance (cov.app) approaches. Note: group 1=control, group2=tx.
       For par.app = "group" and cov.app = "adaptive":
       list(S0, df0, Sb=c(Sb1, Sb2), dfb=c(dfb1, dfb2), Sg=diag(Sg1,Sg2), dfg=4.2)

----------------------------------------------------------------------------------------------------
HPL list elements are described below:

S0, df0
(numeric) The scale parameter for the scaled inverse-chi squared prior assigned to the residual variance. The default value for the df parameter is 4.2.

Sb, dfb
(numeric) The scale parameter for the scaled inverse-chi squared prior assigned to the marker effect variances. The default value for the df parameter is 4.2.

Sg, dfg  (for naive/stratified approach)
(numeric) The scale parameter for the scaled inverse-chi squared prior assigned to the genetic variance component. The default value for the df parameter is 4.2.

Sg, dfg  (for adaptive approach)
(matrix, numeric) The scale parameter for the inverse-Wishart prior assigned to the genetic variance component. Recommended to be set to (dfg + k + 1)*Sigma_prior, where k=2 in this case (the # of tx groups) and Sigma_prior is an a priori value for the genetic covariance matrix. Can be set as a diagonal matrix.
The default value for the df parameter is 4.2.
----------------------------------------------------------------------------------------------------

prob.Large
(numeric, 0<prob.Large<1) Initial proportion markers with large effects when fixed.prior="NormalMixture", except when probLargeTYPE="fixed". When probLargeTYPE="fixed", its the given a priori fixed proportion of markers with large effects.

probLargeTYPE
(character) Can take values "fixed", "uniform" (default), "beta" (with parameters given in probLargePARS), or "loguniform" (development stage), representing the type of prior on the inclusion probabilities.

probLarge.betaPARS
(numeric, 2) Parameters of the prior on the inclusion probability when probLargeTYPE="beta". If NULL (default), probLargeLIMS is used to find the optimum parameters given prob.Large and probLargeLIMS (see documentation for details).

probLargeLIMS
(numeric, 2) Expected interval of the inclusion probability to be used to calculate probLarge.betaPARS when probLargeTYPE="beta". probLargeLIMS is used to find the optimum parameters given prob.Large and probLargeLIMS (see documentation for details). The default interval is c(1/dim(X.marker)[2], (dim(X.marker)[2]-1)/dim(X.marker)[2]).

lambda
(numeric, lambda>0) Initial value of the regularization parameter for the Bayesian LASSO prior when fixed.prior="BL".

lambdaTYPE
(character) Can take values "fixed" or "gamma" (default).

tolDg
(numeric) In generating the genetic random effects (g), only eigenvectors of K whose eigenvalues> tolD are kept.

verbose
(logical) if TRUE the iteration history is printed. Defaults to TRUE.

saveChain
(logical) if TRUE the MCMC samples are saved to file. Defaults to TRUE.

repository: baharerar/BWGP-RCT

repo_name: baharerar/BWGP-RCT


text:
# Lucida
Lucida is an ecosystem of micro-services that make RPC calls using [Apache
Thrift](http://thrift.apache.org/). Each service is built using common Thrift
interface making micro-service communication efficient and flexible. The command
center arbitrates communication between the services.

Current micro-services:
- Automatic Speech Recognition (asr)
- Question-Answering (qa)
- Image Matching (imm)
- DjiNN and Tonic (coming soon)

## Building Lucida
- Download and build the C++ and Java bindings for [Apache
  Thrift](http://thrift.apache.org/)
- Build the [command center](command-center)
- Build each micro-service following each provided README

## Queries
- Start the command center first following the instructions in the command
  center's README
- Start each of the services separately assuring they correctly register with
  the command center (check the output)
- A command center client is provided in [command center](command-center) to
  test the command center and the micro services' execution.

repository: knkrth/lucida

repo_name: knkrth/lucida


text:
Attendly API examples
=====================

To run these examples, browse to examples/index.php from your browser (within a
server thats serving PHP). You will need to update settings.php with your
details.

You should be able to interact with your account on Attendly.

repository: Attendly/attendly-php

repo_name: Attendly/attendly-php


text:
# Item Catalog

_A Udacity Fullstack Web Developer nanodegree project._

After complete how to run access the app at [http://localhost:5000/](http://localhost:5000/)

## Objectives of the project

This application provides a list of items within a variety of categories as well as provide a user registration and authentication system. Registered users will have the ability to post, edit and delete their own items.

- The project aim to develop a RESTful web application using the Python framework Flask along with implementation on third-party OAuth authentication.
- The project attempts to properly use HTTP methods available to work with CRUD (create, read, update and delete) operations.
- Project [rubrick](https://review.udacity.com/#!/rubrics/5/view).

### Objectives

- [X] Implement a database structure
- [X] Implement basic app to connect with the database
- [X] Implement Route to consult the DB (Read option)
- [X] Implement Route to add data on the DB (Create option)
- [X] Implement Route to edit data on the DB (Update option)
- [X] Implement Route to consult delete data on the DB (Delete option)
- [X] Create templates for the Routes
- [X] Add Style for the Routes
- [X] create Secure Login with Google
- [X] Make Create, Update and Delete routes Secure
- [X] Create Logout

## How to run

### PreRequisites
 - [Python ~2.7](https://www.python.org/)
 - [Vagrant](https://www.vagrantup.com/)
 - [VirtualBox](https://www.virtualbox.org/)

### Setup Project:

1. Download [Vagrant](https://www.vagrantup.com/downloads.html) and install.
2. Download [Virtual Box 5.1.x](https://www.virtualbox.org/wiki/Download_Old_Builds_5_1) and install.
3. Fork and Clone or Download [Udacity's Linux-based virtual machine](https://github.com/udacity/fullstack-nanodegree-vm) configuration
4. Find the catalog folder and replace it with the content of this current repository, by either downloading or cloning it from [Here](https://github.com/andrevst/fsnd-p4-item-catalog).

#### Launch Project
1. Launch the Vagrant VM using command: ```$ vagrant up```
2. Update your versions of Flask, _ and _ to match the one used. Use the following commands:

```shell
sudo pip install werkzeug==0.8.3
sudo pip install flask==0.9
sudo pip install Flask-Login==0.1.3
```

4. Install and populate the database:
```
python db_config.py
python preloadShips.py
```

5. Run the application ```python application.py``` and access to test at [http://localhost:5000/starships](http://localhost:5000/starships).

## Inspirational work from other students

[sagarchoudhary96](https://github.com/sagarchoudhary96/P5-Item-Catalog)

[ddavignon](https://github.com/ddavignon/item-catalog)

[DawoonC](https://github.com/DawoonC/nd-sharables/)

Udacity [ud330](https://github.com/udacity/ud330) was a great help on this.


text:
# Terraform authentication for Azure

Terraform needs to be authenticated in order to interact with Azure resources.

## Authentication methods

Microsoft Azure offers a few authentication methods that allow Terraform to deploy resources, and one of them is an SP account.

The reason an SP account is better than other methods is that we don’t need to log in to Azure before running Terraform.

With the other methods (Azure CLI, or Cloud Shell), we need to login to Azure using az login or Cloud Shell.

## Creating a Service Principal using the Azure CLI

Firstly, login to the Azure CLI using:

```bash
$ az login
```

Once logged in - it's possible to list the Subscriptions associated with the account via:

```bash
$ az account list
```

The output (similar to below) will display one or more Subscriptions - with the id field being the subscription_id field referenced above.

```json
[
  {
    "cloudName": "AzureCloud",
    "id": "00000000-0000-0000-0000-000000000000",
    "isDefault": true,
    "name": "PAYG Subscription",
    "state": "Enabled",
    "tenantId": "00000000-0000-0000-0000-000000000000",
    "user": {
      "name"<EMAIL_ADDRESS>      "type": "user"
    }
  }
]
```

Should you have more than one Subscription, you can specify the Subscription to use via the following command:

```bash
$ az account set --subscription="00000000-0000-0000-0000-000000000000"
```

We can now create the Service Principal which will have permissions to manage resources in the specified Subscription using the following command:

```bash
$ az ad sp create-for-rbac --name="service_terraform" --role="Owner" --scopes="/subscriptions/00000000-0000-0000-0000-000000000000"
```

> The `Owner` role is necessary in order terraform will be able to assign roles on resources it will create.

This command will output 5 values:

```json
{
  "appId": "00000000-0000-0000-0000-000000000000",
  "displayName": "service_terraform",
  "name": "http://azure-cli-2017-06-05-10-41-15",
  "password": "0000-0000-0000-0000-000000000000",
  "tenant": "00000000-0000-0000-0000-000000000000"
}
```

Finally, it's possible to test these values work as expected by first logging in:

```bash
$ az login --service-principal -u CLIENT_ID -p CLIENT_SECRET --tenant TENANT_ID
```

Once logged in as the Service Principal - we should be able to list the VM sizes by specifying an Azure region, for example here we use the West US region:

```bash
$ az vm list-sizes --location francecentral
```

Finally, since we're logged into the Azure CLI as a Service Principal we recommend logging out of the Azure CLI (but you can instead log in using your user account):

```bash
$ az logout
```

## Configuring the Service Principal in Terraform

As we've obtained the credentials for this Service Principal - it's possible to configure them in a few different ways but it is important to avoid storing them in source code.
We prefer storing the credentials as Environment Variables, for example:

```bash
$ export ARM_CLIENT_ID="00000000-0000-0000-0000-000000000000"
$ export ARM_CLIENT_SECRET="00000000-0000-0000-0000-000000000000"
$ export ARM_SUBSCRIPTION_ID="00000000-0000-0000-0000-000000000000"
$ export ARM_TENANT_ID="00000000-0000-0000-0000-000000000000"
```

These values map to the Terraform variables like so:

- appId is the client_id defined above.
- password is the client_secret defined above.
- tenant is the tenant_id defined above.

After that, to authenticate with the Terraform Service Principal:

```bash
$ az login --service-principal -u $ARM_CLIENT_ID -p $ARM_CLIENT_SECRET --tenant $ARM_TENANT_ID
```

> You can create your own `env.sh` script at the root of the project. Take example upon the model [env.sh.example](../env.sh.example).

## Add Azure AD permissions

Terraform needs to create Azure resources and AD applications or Service Principals, so it needs a high level of permissions.
You can give the `Owner` role on the subscription to the Terraform Service Principal `service_terraform`.
For managing Azure AD resources, the SP also needs some API access.

Find all details in [this very good post](https://simonemms.com/blog/2021/01/10/setting-terraform-service-principal-to-work-with-azure-active-directory/).

## Check Terraform works

You can create a `provider.tf` file:

```hcl
terraform {
  required_providers {
    azurerm = {
      source  = "azurerm"
      version = "= 2.45.1"
    }
    azuread = {
      source  = "azuread"
      version = "= 1.3.0"
    }
  }
}

provider "azurerm" {
  features {}
}
```

And try some Terraform commands:

```bash
$ terraform init
$ terraform plan
```

You will be sure of the correct functioning when you will create resources of different types with the providers `azurerm` and `azuread`.

repository: tiko-oss/hub-and-spoke-aks

repo_name: tiko-oss/hub-and-spoke-aks


text:
capistrano-docker-rails-sample
==============================

Rails sample app for demonstrating capistrano-docker integration

Summary
-------
This is an example Rails 4.0.0 project to show how https://github.com/juwalter/capistrano-docker works.
The fun stuff is in https://github.com/juwalter/capistrano-docker-rails-sample/blob/master/config/deploy.rb#L14 and
https://github.com/juwalter/capistrano-docker-rails-sample/tree/master/config/deploy/cap_docker_rails_example

The configuration and control.sh assumes http://nginx.org/ as your web server. The included
[Dockerfile](http://docs.docker.io/en/latest/use/builder/ "Dockerfile") configures an image with nginx and
rvm and ruby 2.0.

Zero downtime deploys leverage nginx' reverse-proxy feature with multiple upstream servers, see
https://github.com/juwalter/capistrano-docker-rails-sample/blob/master/config/deploy/cap_docker_rails_example/host_nginx/sites-enabled/cap-docker-rails-example.conf#L1

Prerequisites
-------------
Have http://www.docker.io/gettingstarted/#h_installation and nginx installed and working on your server

Quick start
-----------
```shell
git clone git@github.com:juwalter/capistrano-docker-rails-sample.git
cd capistrano-docker-rails-sample
rvm use 2.0@capistrano-docker-rails-sample --rvmrc --create
bundle
(optional) adjust files at config/deploy/cap_docker_rails_example
cap docker:prepare (read the info at the end carefully; you need to prepare the Dockerfile with deploy keys and such)
before the next steps, make sure you have a docker repository for this app on your server
cap deploy:setup
cap deploy:migrations
```

Contribute
----------
 * Fork
 * Create a topic branch - git checkout -b my_branch
 * Rebase your branch so that all your changes are reflected in one commit
 * Push to your branch - git push origin my_branch
 * Create a Pull Request from your branch, include as much documentation as you can
   in the commit message/pull request, following these guidelines on writing a good commit message
 * Thanks :)

repository: alvinlai/capistrano-docker-rails-sample

repo_name: alvinlai/capistrano-docker-rails-sample


text:
## Architecture:

![Architecture](ecsfargatechat.png)

Current CDK script uses a dockerize Redis running on Fargate, it is not durable or HA.

repository: literalice/chat-websocket-fargate

repo_name: literalice/chat-websocket-fargate


text:
# Deep Learning for Music (DL4M) ![Awesome](https://cdn.rawgit.com/sindresorhus/awesome/d7305f38d29fed78fa85652e3a63e154dd8e8829/media/badge.svg)

The role of this curated list is to gather scientific articles that use deep learning approaches applied to music.
The list is currently under construction but feel free to contribute to the missing fields and to add other resources.
The resources provided here come from my review of the state-of-the-art for my PhD Thesis for which an article is being written.

## Table of contents

- [DL4M summary](#dl4m-summary)
- [DL4M details](#dl4m-details)
- [Code without articles](#code-without-articles)
- [Statistics and visualisations](#statistics-and-visualisations)
- [How To Contribute](#how-to-contribute)
- [FAQ](#faq)
- [Abbreviations used](#abbreviations-used)
- [Sources](#sources)
- [Contributors](#contributors)
- [Other useful related lists](#other-useful-related-lists)

## DL4M summary

| Article | Code |
|---------------------|-------------------------|
| [Monoaural audio source separation using deep convolutional neural networks](mtg.upf.edu/system/files/publications/monoaural-audio-source_0.pdf) | [GitHub](https://github.com/MTG/DeepConvSep) |
| [Transfer learning for music classification and regression tasks](https://arxiv.org/pdf/1703.09179v3.pdf) | [GitHub](https://github.com/keunwoochoi/transfer_learning_music) |
| [Convolutional recurrent neural networks for music classification](http://ieeexplore.ieee.org/abstract/document/7952585/) | [GitHub](https://github.com/keunwoochoi/icassp_2017) |
| [An evaluation of convolutional neural networks for music classification using spectrograms](http://www.inf.ufpr.br/lesoliveira/download/ASOC2017.pdf) | No |
| [Basic Filters for Convolutional Neural Networks: Training or Design?](https://arxiv.org/abs/1709.02291) | No |
| [Music signal processing using vector product neural networks](https://arxiv.org/pdf/1706.09555.pdf) | No |
| [Transforming musical signals through a genre classifying convolutional neural network](https://arxiv.org/pdf/1706.09553.pdf) | No |
| [Deep convolutional neural networks for predominant instrument recognition in polyphonic music](http://dl.acm.org/citation.cfm?id=3068697) | No |
| [CNN architectures for large-scale audio classification](https://arxiv.org/pdf/1609.09430v2.pdf) | No |
| [Music emotion recognition via end-to-end multimodal neural networks](http://ceur-ws.org/Vol-1905/recsys2017_poster18.pdf) | No |
| [End-to-end musical key estimation using a convolutional neural network](https://arxiv.org/pdf/1706.02921.pdf) | |
| [Sample-level deep convolutional neural networks for music auto-tagging using raw waveforms](https://arxiv.org/pdf/1703.01789v2.pdf) | |
| [Multi-level and multi-scale feature aggregation using sample-level deep convolutional neural networks for music classification](https://arxiv.org/pdf/1706.06810.pdf) | [GitHub](https://github.com/jongpillee/musicTagging_MSD) |
| [A deep multimodal approach for cold-start music recommendation](https://arxiv.org/abs/1706.09739) | [GitHub](https://github.com/sergiooramas/tartarus) |
| [Melody extraction and detection through LSTM-RNN with harmonic sum loss](http://ieeexplore.ieee.org/abstract/document/7952660/) | |
| [Timbre analysis of music audio signals with convolutional neural networks](https://arxiv.org/pdf/1703.06697.pdf) | [GitHub](https://github.com/jordipons/EUSIPCO2017) |
| [Designing efficient architectures for modeling temporal features with convolutional neural networks](http://ieeexplore.ieee.org/document/7952601/) | [GitHub](https://github.com/jordipons/ICASSP2017) |
| [Music feature maps with convolutional neural networks for music genre classification](https://www.micc.unifi.it/cbmi2017/session/poster-and-demo-session/) | No |
| [Automatic drum transcription for polyphonic recordings using soft attention mechanisms and convolutional neural networks](http://www.ryanstables.co.uk/docs/ISMIR2017CamReady.pdf) | [GitHub](https://github.com/CarlSouthall/ADTLib) |
| [Convolutional methods for music analysis](http://vbn.aau.dk/files/260308151/PHD_Gissel_Velarde_E_pdf.pdf) | |
| [Extending temporal feature integration for semantic audio analysis](http://www.aes.org/e-lib/browse.cfm?elib=18682) | No |
| [Audio spectrogram representations for processing with convolutional neural networks](https://arxiv.org/pdf/1706.09559.pdf) | No |
| [Attention and localization based on a deep convolutional recurrent model for weakly supervised audio tagging](http://www.isca-speech.org/archive/Interspeech_2017/pdfs/0486.PDF) | [GitHub](https://github.com/yongxuUSTC/att_loc_cgrnn) |
| [A study on LSTM networks for polyphonic music sequence modelling](https://qmro.qmul.ac.uk/xmlui/handle/123456789/24946) | [Website](http://www.eecs.qmul.ac.uk/~ay304/code/ismir17) |
| [An efficient approach for segmentation, feature extraction and classification of audio signals ](http://file.scirp.org/pdf/CS_2016042615054817.pdf) | No |
| [Towards playlist generation algorithms using rnns trained on within-track transitions](https://arxiv.org/pdf/1606.02096.pdf) | No |
| [Automatic tagging using deep convolutional neural networks](https://arxiv.org/pdf/1606.00298.pdf) | No |
| [Automatic chord estimation on seventhsbass chord vocabulary using deep neural network](http://ieeexplore.ieee.org/abstract/document/7471677/) | |
| [Robust downbeat tracking using an ensemble of convolutional networks](http://ieeexplore.ieee.org/abstract/document/7728057/) | |
| [Bayesian meter tracking on learned signal representations](http://www.rhythmos.org/MMILab-Andre_files/ISMIR2016_CNNDBNbeats_camready.pdf) | |
| [Deep learning for music](https://arxiv.org/pdf/1606.04930.pdf) | |
| [Learning temporal features using a deep neural network and its application to music genre classification](https://www.researchgate.net/profile/Il_Young_Jeong/publication/305683876_Learning_temporal_features_using_a_deep_neural_network_and_its_application_to_music_genre_classification/links/5799a27c08aec89db7bb9f92.pdf) | |
| [On the potential of simple framewise approaches to piano transcription](https://arxiv.org/abs/1612.05153) | |
| [Feature learning for chord recognition: the deep chroma extractor](https://arxiv.org/pdf/1612.05065.pdf) | |
| [A deep bidirectional long short-term memory based multi-scale approach for music dynamic emotion prediction](http://ieeexplore.ieee.org/document/7471734/) | |
| [Event localization in music auto-tagging](http://mac.citi.sinica.edu.tw/~yang/pub/liu16mm.pdf) | [GitHub](https://github.com/ciaua/clip2frame) |
| [Deep convolutional networks on the pitch spiral for musical instrument recognition](https://github.com/lostanlen/ismir2016/blob/master/paper/lostanlen_ismir2016.pdf) | |
| [Robust audio event recognition with 1-max pooling convolutional neural networks](https://arxiv.org/pdf/1604.06338.pdf) | No |
| [Singing voice melody transcription using deep neural networks](https://wp.nyu.edu/ismir2016/wp-content/uploads/sites/2294/2016/07/163_Paper.pdf) | |
| [Singing voice separation using deep neural networks and F0 estimation](http://www.music-ir.org/mirex/abstracts/2016/RSGP1.pdf) | [Website](http://cvssp.org/projects/maruss/mirex2016/) |
| [Learning to pinpoint singing voice from weakly labeled examples](http://www.ofai.at/~jan.schlueter/pubs/2016_ismir.pdf) | |
| [Note onset detection in musical signals via neural-network-based multi-ODF fusion](https://www.degruyter.com/downloadpdf/j/amcs.2016.26.issue-1/amcs-2016-0014/amcs-2016-0014.pdf) | No |
| [Convolutional neural network for robust pitch determination](http://www.mirlab.org/conference_papers/International_Conference/ICASSP%202016/pdfs/0000579.pdf) | |
| [Deep convolutional neural networks and data augmentation for acoustic event detection](https://arxiv.org/pdf/1604.07160.pdf) | No |
| [Unsupervised feature learning based on deep models for environmental audio tagging](https://arxiv.org/pdf/1607.03681.pdf) | |
| [Auralisation of deep convolutional neural networks: listening to learned features](http://ismir2015.uma.es/LBD/LBD24.pdf) | |
| [Downbeat tracking with multiple features and deep neural networks](http://perso.telecom-paristech.fr/~grichard/Publications/2015-durand-icassp.pdf) | |
| [Music boundary detection using neural networks on spectrograms and self-similarity lag matrices](http://www.ofai.at/~jan.schlueter/pubs/2015_eusipco.pdf) | |
| [Classification of spatial audio location and content using convolutional neural networks](https://www.researchgate.net/profile/Toni_Hirvonen/publication/276061831_Classification_of_Spatial_Audio_Location_and_Content_Using_Convolutional_Neural_Networks/links/5550665908ae12808b37fe5a/Classification-of-Spatial-Audio-Location-and-Content-Using-Convolutional-Neural-Networks.pdf) | |
| [Deep learning, audio adversaries, and music content analysis](http://www2.imm.dtu.dk/pubdb/views/edoc_download.php/6905/pdf/imm6905.pdf) | |
| [Singing voice detection with deep recurrent neural networks](https://hal-imt.archives-ouvertes.fr/hal-01110035/document) | |
| [Automatic instrument recognition in polyphonic music using convolutional neural networks](https://arxiv.org/pdf/1511.05520.pdf) | |
| [A software framework for musical data augmentation](https://bmcfee.github.io/papers/ismir2015_augmentation.pdf) | |
| [A deep bag-of-features model for music auto-tagging](https://arxiv.org/pdf/1508.04999v1.pdf) | |
| [Music-noise segmentation in spectrotemporal domain using convolutional neural networks](http://ismir2015.uma.es/LBD/LBD27.pdf) | |
| [Musical instrument sound classification with deep convolutional neural network using feature fusion approach](https://arxiv.org/ftp/arxiv/papers/1512/1512.07370.pdf) | |
| [Environmental sound classification with convolutional neural networks](https://scholar.google.co.kr/scholar?hl=en&q=Environmental+sound+classification+with+convolutional+neural+networks&btnG=&as_sdt=1%2C5&as_sdtp=) | |
| [Exploring data augmentation for improved singing voice detection with neural networks](https://grrrr.org/pub/schlueter-2015-ismir.pdf) | No |
| [An end-to-end neural network for polyphonic music transcription](https://arxiv.org/pdf/1508.01774.pdf) | |
| [Deep karaoke: extracting vocals from musical mixtures using a convolutional deep neural network](https://link.springer.com/chapter/10.1007/978-3-319-22482-4_50) | |
| [Deep neural network based instrument extraction from music](https://www.researchgate.net/profile/Stefan_Uhlich/publication/282001406_Deep_neural_network_based_instrument_extraction_from_music/links/5600eeda08ae07629e52b397/Deep-neural-network-based-instrument-extraction-from-music.pdf) | |
| [A deep neural network for modeling music](https://www.researchgate.net/profile/Xiaoqing_Zheng3/publication/275347034_A_Deep_Neural_Network_for_Modeling_Music/links/5539d2060cf2239f4e7dad0d/A-Deep-Neural-Network-for-Modeling-Music.pdf) | |
| ["The munich LSTM-RNN approach to the mediaeval 2014 ""emotion in music"" task"](https://pdfs.semanticscholar.org/8a24/c5131d5a28165f719697028c34b00e6d3f60.pdf) | |
| [End-to-end learning for music audio](http://ieeexplore.ieee.org/abstract/document/6854950/) | No |
| [Deep learning for music genre classification](https://courses.engr.illinois.edu/ece544na/fa2014/Tao_Feng.pdf) | No |
| [Recognition of acoustic events using deep neural networks](https://www.cs.tut.fi/sgn/arg/music/tuomasv/dnn_eusipco2014.pdf) | |
| [Deep image features in music information retrieval](https://www.degruyter.com/downloadpdf/j/eletel.2014.60.issue-4/eletel-2014-0042/eletel-2014-0042.pdf) | |
| [From music audio to chord tablature: teaching deep convolutional networks to play guitar](http://www.mirlab.org/conference_papers/International_Conference/ICASSP%202014/papers/p7024-humphrey.pdf) | |
| [Improved musical onset detection with convolutional neural networks](http://www.mirlab.org/conference_papers/International_Conference/ICASSP%202014/papers/p7029-schluter.pdf) | No |
| [A hybrid recurrent neural network for music transcription](https://arxiv.org/pdf/1411.1623.pdf) | |
| [Boundary detection in music structure analysis using convolutional neural networks](https://dav.grrrr.org/public/pub/ullrich_schlueter_grill-2014-ismir.pdf) | |
| [Improving content-based and hybrid music recommendation using deep learning](http://www.smcnus.org/wp-content/uploads/2014/08/reco_MM14.pdf) | |
| [A deep representation for invariance and music classification](http://www.mirlab.org/conference_papers/International_Conference/ICASSP%202014/papers/p7034-zhang.pdf) | No |
| [Multiscale approaches to music audio feature learning](http://ismir2013.ismir.net/wp-content/uploads/2013/09/69_Paper.pdf) | |
| [Deep content-based music recommendation](http://papers.nips.cc/paper/5004-deep-content-based-music-recommendation.pdf) | |
| [Musical onset detection with convolutional neural networks](http://phenicx.upf.edu/system/files/publications/Schlueter_MML13.pdf) | |
| [Rethinking automatic chord recognition with convolutional neural networks](http://ieeexplore.ieee.org/document/6406762/) | |
| [Moving beyond feature design: deep architectures and automatic feature learning in music informatics](http://citeseerx.ist.psu.edu/viewdoc/download?doi=<IP_ADDRESS>4.2304&rep=rep1&type=pdf) | |
| [Local-feature-map integration using convolutional neural networks for music genre classification.](http://liris.cnrs.fr/Documents/Liris-5602.pdf) | |
| [Learning sparse feature representations for music annotation and retrieval](https://pdfs.semanticscholar.org/099d/85f25e9336f48ff64287a4b53ee5fb64ab51.pdf) | No |
| [Unsupervised learning of local features for music classification.](http://www.ismir2012.ismir.net/event/papers/139_ISMIR_2012.pdf) | |
| [Audio-based music classification with a pretrained convolutional network](http://www.ismir2011.ismir.net/papers/PS6-3.pdf) | |
| [Automatic musical pattern feature extraction using convolutional neural network](https://www.researchgate.net/profile/Antoni_Chan2/publication/44260643_Automatic_Musical_Pattern_Feature_Extraction_Using_Convolutional_Neural_Network/links/02e7e523dac6bb86b0000000.pdf) | |
| [Audio musical genre classification using convolutional neural networks and pitch and tempo transformations](http://lbms03.cityu.edu.hk/theses/c_ftt/mphil-cs-b39478026f.pdf) | |
| [Unsupervised feature learning for audio classification using convolutional deep belief networks](http://papers.nips.cc/paper/3674-unsupervised-feature-learning-for-audio-classification-using-convolutional-deep-belief-networks.pdf) | No |
| [A convolutional-kernel based approach for note onset detection in piano-solo audio signals](http://www.murase.nuie.nagoya-u.ac.jp/~ide/res/paper/E04-conference-pablo-1.pdf) | |
| [A supervised learning approach to musical style recognition](https://www.researchgate.net/profile/Giuseppe_Buzzanca/publication/228588086_A_supervised_learning_approach_to_musical_style_recognition/links/54b43ee90cf26833efd0109f.pdf) | |

## DL4M details

- [dl4m.bib](dl4m.bib) - the corresponding bibliography.
- [dl4m.tsv](dl4m.tsv) - more details about each article:
	- First author name
	- Publication year
	- Article name
	- PDF link
	- Source code link
	- Source code reproducible (Yes/No) If Yes, indicates to what extent
	- Neural network architecture
	- Number of layers
	- Task
	- Dataset
	- Computation time
	- Hardware
	- Data augmentation technique if used
	- Additional notes

## Code without articles

- [Audio Classifier in Keras using Convolutional Neural Network](https://github.com/drscotthawley/audio-classifier-keras-cnn)

## Statistics and visualisations

- 87 articles currently referenced.
- Number of articles per year:
![Number of articles per year](fig/articles_per_year.png)

## How To Contribute

1. Adding/Updating information
	1. Fork the repo.
	2. Add one line per article in [dl4m.tsv](dl4m.tsv) with every column correctly filled.
	3. Submit your pull request and that's it! (Note: the table in the ReadMe is automatically generated thanks to a python script.)
2. Visualisation
	- Please submit your idea for new visualisation of the data
	- I am looking for a way to display relations between articles automatically like a mindmap. Tell me if you know anything able to handle that.

## FAQ

> Why a tsv file instead of a regular csv file for storing the detailed information about the articles?

Because:
1. Some articles have a comma in their title and the .bib of each article contains commas.
2. [GitHub currently only displays csv and tsv files](https://help.github.com/articles/rendering-csv-and-tsv-data/).
The built-in GitHub csv/tsv parser is handy because you can easily search in the file in your browser without downloading anything.

> How are the articles sorted?

In [dl4m.tsv](dl4m.tsv), the articles are first sorted by decreasing year (to keep up with the latest news) and then alphabetically by author's family name.

> Why are preprint from arXiv included in the list?

I want to have exhaustive research and the latest news on DL4M. However, one should take care of the information provided in the articles currently in review. If possible you should wait for the final accepted and peer-reviewed version before citing an arXiv paper. I regularly update the arXiv links to the corresponding published papers when available.

## Abbreviations used

| Abbreviation | Full name |
|--------------|-----------|
| ADT | Automatic Drum Transcription |
| BRNN | Bidirectional Recurrent Neural Network |
| CNN | Convolutional Neural Network |
| DNN | Deep Neural Network |
| LSTM | Long Short Term Memory |
| MER | Music Emotion Recognition |
| RNN | Recurrent Neural Network |
| SVD | Singing Voice Detection |
| SVS | Singing Voice Separation |
| VAD | Voice Activity Detection |
| VPNN | Vector Product Neural Network |

## Sources

#### Conferences and journals

- [DLRS](http://dlrs-workshop.org/)
- [ICASSP](http://ieeexplore.ieee.org/xpl/conhome.jsp?punumber=1000002)
- [ICML](https://2017.icml.cc/)
- [INTERSPEECH](http://www.isca-speech.org/iscaweb/)
- [ISMIR](http://ismir.net/)
- [IWDLM](http://www.dorienherremans.com/dlm2017/index.html)
- [LVA/ICA](http://lva-ica-2017.com/index.php/aim)
- [MIREX](http://music-ir.org/mirex/wiki/MIREX_HOME)
- [RECSYS](https://recsys.acm.org/)
- [SMC](http://www.smc-conference.org/)

#### Aggregators

- [arXiv](https://arxiv.org/)
- [PaperScape](http://paperscape.org/)
- [Scholar](https://scholar.google.com/scholar?q=neural+network+audio+music)
- [SciRate](https://scirate.com/)

## Contributors

- [Vincent Lostanlen](https://github.com/lostanlen)
- [Keunwoo Choi](https://github.com/keunwoochoi)

## Other useful related lists

- [Awesome Python Scientific Audio](https://github.com/faroit/awesome-python-scientific-audio) - Python resources for Audio and Machine Learning
- [Cheatsheets AI](https://github.com/kailashahirwar/cheatsheets-ai) - Cheat Sheets for Keras, neural networks, scikit-learn,...
- [Awesome Deep Learning](https://github.com/ChristosChristofidis/awesome-deep-learning) - General deep learning resources
- [ISMIR resources](http://ismir.net/resources.php) - Community maintained list
- [Awesome Python](https://github.com/vinta/awesome-python#audio) - Audio section of Python resources
- [Awesome Web Audio](https://github.com/notthetup/awesome-webaudio) - WebAudio packages and resources
- [Awesome Music](https://github.com/ciconia/awesome-music) - Music softwares
- [Awesome Music Production](https://github.com/adius/awesome-music-production) - Music creation
- General [![Awesome](https://cdn.rawgit.com/sindresorhus/awesome/d7305f38d29fed78fa85652e3a63e154dd8e8829/media/badge.svg)](https://github.com/sindresorhus/awesome) lists
- [The Asimov Institute](http://www.asimovinstitute.org/analyzing-deep-learning-tools-music/) - 6 deep learning tools for music generation


text:
# Java Tools

> Contents

Privide some useful java tools, like basic java utils, helpers, managers.
Also, provide some maven plugins.

## Repository Structure
```
|_ bundles                          Some jave tools
    |_ java-bundle-helper       Java bundle tools
|_ maven-plugins                Some maven plugins
    |_ maven-plugin-core        Base maven core
    |_ javacompiler-maven-plugin        Check java compiler version of classes, jar

```

## License

Licensed under the Apache V2 License

repository: kemixkoo/java-tools

repo_name: kemixkoo/java-tools


text:
# Saitek Throttle USB Retrofit

This project contains code for AVR MCUs to allow using the throttle which ships
with the Saitek Pro Flight Yoke System as a standalone USB device.
The code targets the AVR ATmega16U2 microcontroller which is found on the
Arduino Leonardo prototyping board.

# How To Use

I did not succeed in getting the code to run as part of an Arduino sketch.
Likely, this is due to the bootloader on the Arduino Leonardo, which interferes
with the USB peripheral. Thus, the code must be flashed onto the target by direct
serial programming, using a serial programmer such as the ATMEL-ICE or by using
a separate Arduino board as a programmer.

## Compiling & Uploading

### Using Microchip Studio

Simply create a new project. Select the ATmega16U2 as the target device, then add all files in the `src/` subdirectory of this repository to the project. Compile, then upload using a programmer of your choice.

### Using AVR-GCC

A makefile is provided. To compile, simply type

    make

To upload the binary to the device using avrdude, use

    make program

You may have to specify your programmer type in the makefile using the `PROGRAMMER` variable.

## Pin Mapping

The throttle is connected to the yoke by a 6-pin miniDIN connector.
The pinout is as follows:

| miniDIN Pin # | Wire Color | Function             | Driven by | ATmega16U2 pin | Arduino Leonardo Pin |
| ------------- | ---------- | -------------------- | --------- | -------------- | -------------------- |
| 1             | blue       | Clock                | Yoke      | PD1            | D2                   |
| 2             | brown      | "ready" (active low) | Throttle  | PD0            | D3                   |
| 3             | red        | +5V                  | Yoke      | -              | -                    |
| 4             | orange     | GND                  | -         | -              | -                    |
| 5             | yellow     | Data                 | Throttle  | PD2            | D0                   |
| 6             | green      | +5V                  | Yoke      | -              | -                    |

Additionally, two status LEDs can be connected on pins PD3 / D1 (green) and PD4 / D4 (red).

repository: brathis/saitek-throttle-usb-retrofit

repo_name: brathis/saitek-throttle-usb-retrofit


text:
# Ping Pong
#### By Eric Ochieng'
## Description
This is a repository for a website that returns different prompts when a number divisible by either 3, 5 or 15 is input into a form.

## Setup/Installation Requirements
There are no unique setup instructions or installations required to view this site, all that is required is access to the public repository link, a web browser and an internet connection to view the page. ##Link to the live site is provided below. https://ricochieng.github.io/pingpong/

MIT License

Copyright (c) [2018] [Eric Otieno Ochieng']

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.

repository: ricochieng/pingpong

repo_name: ricochieng/pingpong


text:
# good_omens
First steps with Clojurescript and Om

# UPDATE
after Reading this [blog post](http://getprismatic.com/story/1413760839515) I decided to switch from Om to Reagent.

I will follow this [Reagent tutorial](http://www.mattgreer.org/articles/reagent-rocks/).


text:
---
layout: post
comments: true
title: "Spring Adventures With Your Pup"
date: 2018-03-13
---
![_config.yml]({{ site.baseurl }}/images/SPRINGBLOG.png)

As the spring weather is approaching, we thought it would be a great time to show you trails and parks that you can bring your pup to! These trails and parks are scattered across Ontario and we believe that they should be added to your bucket list. So get ready, grab your pup and plan a trip to one of these locations!

![_config.yml]({{ site.baseurl }}/images/berczy.jpg)

**BERCZY PARK**

Berczy Park is located on Wellington Street East in Toronto, ON.  A perfect spot for a water break (yes, dogs are allowed to cool off in the fountain) or to sit and relax with your furry friend and soak up some sunshine.

![_config.yml]({{ site.baseurl }}/images/bechtelpark.jpg)

**BECHTEL DOG PARK**

Bechtel Dog Park is located in Waterloo and offers an open space for dogs to play, as well as trails to go for walks with a beautiful scenic view. The off-leash fenced in area is five acres, so there’s no question about having enough room for your dog to play!

![_config.yml]({{ site.baseurl }}/images/highpark.jpg)

**HIGH PARK**

High Park is located on Bloor Street West, and it is a leash-free zone! You and your pup can explore the beautiful trails or sit and enjoy a picnic in the park. It is one of Toronto’s oldest and largest parks occupying 400 acres of land. This park is a must see for anyone living or visiting the Toronto area!

![_config.yml]({{ site.baseurl }}/images/brucepit.jpeg)

**BRUCE PIT**

Bruce Pit is located Cedarview Road in Ottawa ON, it’s a leash-free park and trail for dogs. The trails are just over 3 kilometers long and are surrounded by beautiful nature with an open space available for dogs to play. A great park for you and your pup to spend some quality time together while getting some exercise!

![_config.yml]({{ site.baseurl }}/images/algonquinpark.jpg)

**ALGONQUIN PROVINCIAL PARK**

Algonquin Provincial Park is located in south-central Ontario and covers 7,630 square kilometers of land! It is Canada’s oldest Provincial Park and has over 10 trails to choose from, each varying in skill level and length. Furry friends are welcome to roam free and explore the beautiful surroundings. You can also spend the night in one of the pet friendly cabins along the lake. We 10/10 recommend making a visit!

![_config.yml]({{ site.baseurl }}/images/pacificspiritpark.jpg)

**PACIFIC SPIRIT REGIONAL PARK**

Located in Vancouver, this park has several trails within 750 hectares of forest. For those who are brave to walk the whole park, it is 10 km and takes approximately 3 hours to complete. For those who are just out for a stroll, you can choose an alternate route to take.  Many of the trails are off-leash to let your pup explore the nature. Wreck beach is also located nearby if your dog wants to have a swim afterwards. The perfect ending to a warm day!

![_config.yml]({{ site.baseurl }}/images/oxbowspark.jpeg)

**OXBOWS OFF LEASH DOG PARK**

This dog park is located in Red Deer, Alberta and was made exclusively for dogs and their owners. The park offers trails, open training sites and even an area for small dogs. (Sometimes the big dogs can be intimidating!) Oxbows accommodates all dogs and is the perfect spot for exercise or leisure. We think this park is a must-see for all pup parents!

That wraps up our list of trails and parks we think you need to visit with your pup. Plan an adventure and spend some quality time with your furry friend this spring at one of these beautiful locations!

**P.S. For more ways you can spend quality time with your pup, download Furevery and check out dog friendly events near you!**


text:
---
layout: post
title: 1Z0-803 Import Statements
permalink: import-statements
comments: True
published: False
---

Suppose a class file named Hello.java is located in classpath folder com.raywritescode.util and contains the following code:

{% highlight java %}
package com.raywritescode.util;

public class Hello
{
   public void printHello()
   {
      System.out.println(
         "Hello from com.raywritescode.util.Hello" );
   }
}
{% endhighlight %}

Without using *import statements* you need to specify the Hello class's *fully qualified name* inside your application's code to use the class.

For example, in ImportTest.java below

{% highlight java linenos %}
public class ImportTest
{
   public static void main( String[] args )
   {
      com.raywritescode.util.Hello myHello =
         new com.raywritescode.util.Hello();
      myHello.printHello();
   }
}
{% endhighlight %}

lines 5 and 6 use the fully qualified name com.raywritescode.util.Hello in order to access class Hello.

That's a lot of typing of fully qualified names if you use classes from the various Java API packages and from your custom API packages.

## import Statement Shortcut

import statements spare you from having to type fully qualified names.

In class file ImportTest2.java

{% highlight java linenos %}
import com.raywritescode.util.Hello;

public class ImportTest2
{
   public static void main( String[] args )
   {
      Hello myHello =  new Hello();
      myHello.printHello();
   }
}
{% endhighlight %}

the import statement on line 1 allows you to use the Hello class on line 7 without the fully qualified name.

The import statement tells the JVM "At package com.raywrites.util there's a class named 'Hello'. Whenever you see 'Hello' used in this class, use 'Hello" from com.raywritescode.util."

## importing Multiple Classes

If the com.raywritescode.util package contains a dozen classes and you want to use all 12 classes in your application, instead of writing 12 separate import statements you can add the wildcard character * to your single import statement as show on line 1 below:

{% highlight java linenos %}
import com.raywritescode.util.*;

public class ImportTest2
{
   public static void main( String[] args )
   {
      Hello myHello =  new Hello();
      myHello.printHello();

      Goodbye myGoodbye = new Goodbye();
      myGoodbye.printGoodbye();
   }
}
{% endhighlight %}

## Mixing import Statements and Fully Qualified Names

It's legal in Java to use both import statements and fully qualified names in the same source code file.

ImportTest3.java
{% highlight java linenos %}
import com.raywritescode.util.Hello;

public class ImportTest3
{
   public static void main( String[] args )
   {
      Hello myHello =  new Hello();
      myHello.printHello();

      com.raywritescode.util.Hello yourHello =
         new com.raywritescode.util.Hello();
      yourHello.printHello();
   }
}
{% endhighlight %}

## How to Use Classes with Identical Names
Suppose you wrote a custom API class named ArrayList in com.raywritescode.util and include it as an import statement in the application you're currently writing.

ImportTest4.java
{% highlight java linenos %}
import com.raywritescode.util.ArrayList;

public class ImportTest4
{
   public static void main( String[] args )
   {
      ArrayList<String> myList = new ArrayList<String>();
   }
}
{% endhighlight %}

The Java API also has a class named ArrayList. It's located in java.util.

To use the Java API's ArrayList class in your ImportTest4 application, use the Java API's fully qualified name.

ImportTest4.java (modified)
{% highlight java linenos %}
import com.raywritescode.util.ArrayList;

public class ImportTest4
{
   public static void main( String[] args )
   {
      ArrayList<String> myList = new ArrayList<String>();

      java.util.ArrayList<String> myOtherList =
         new java.util.ArrayList<String>();
   }
}
{% endhighlight %}

## If You're a C Programmer

Java's import statement is **NOT** similar to C's #include statement.

C's #include statement (directive) tells the C compiler to copy the identified code from the respective C header files into the program.

Java's import statement saves you from having to type fully qualified names. Nothing more.


text:
# Magic wand example

This example shows how you can use TensorFlow Lite to run a 20 kilobyte neural
network model to recognize gestures with an accelerometer.

## Table of contents

-   [Getting started](#getting-started)
-   [Run the tests on a development machine](#run-the-tests-on-a-development-machine)
-   [Train your own model](#train-your-own-model)

To stop viewing the debug output with `screen`, hit `Ctrl+A`, immediately
followed by the `K` key, then hit the `Y` key.

## Run the tests on a development machine

```bash
make -f tensorflow/lite/micro/tools/make/Makefile test_magic_wand_test
```

This will take a few minutes, and downloads frameworks the code uses like
[flatbuffers](https://google.github.io/flatbuffers/). Once that process has
finished, you should see a series of files get compiled, followed by some
logging output from a test, which should conclude with `~~~ALL TESTS PASSED~~~`.

If you see this, it means that a small program has been built and run that loads
the trained TensorFlow model, runs some example inputs through it, and got the
expected outputs.

## Train your own model

To train your own model, or create a new model for a new set of gestures,
follow the instructions in [magic_wand/train/README.md](train/README.md).


text:
[![Build Status](https://img.shields.io/travis/balihoo/balihoo-blip-sdk-node.svg?branch=master&style=flat)](https://travis-ci.org/balihoo/balihoo-blip-sdk-node) [![npm](https://img.shields.io/npm/v/npm.svg?maxAge=2592000)](https://www.npmjs.com/package/balihoo-blip-sdk)
# Balihoo Node.JS BLIP SDK
This package makes it easy to write software which interacts with the Balihoo Local Information Platform.

## Installation
```bash
npm install balihoo-blip-sdk
```

## Build this README
```bash
coffee tools/generateDocs.coffee --version=<VERSION> > README.md
```

## Usage
```javascript
var BlipSdk = require('balihoo-blip-sdk');

var parameters = {
    apiKey: '...',
    secretKey: '...'
};

var blipSdk = new BlipSdk(parameters);
```

## Parameters
The following parameters are required:
- apiKey:  The Balihoo-provided API key
- secretKey:  The Balihoo-provided secret key

The following parameters are optional and generally only useful for testing purposes:
- endpoint (string):  The fully qualified URL of BLIP (e.g. http[s]://somehost[:port]/some/path)
- concurrency (number):  The number of concurrent connections to use.  Default is 10, max is 20.
- version (string):  The API version to use.  Default value is the latest version.

## API

### ping()
Returns an indication of service availability

Parameters: none

### getSources()
Returns a list of sources

Parameters:
- brandKey (string):  The brand key (required)

### createSource()
Create a source

Parameters:
- brandKey (string):  The brand key (required)
- body (object)
 - source (string): The unique source identifier.
 - type (string): The source type.
 - description (string): A description of the data source.

### getProjections()
Returns a list of projections

Parameters:
- brandKey (string):  The brand key (required)

### getBrandKeys()
Returns a list of brand keys to which the user has access

Parameters: none

### getBrand()
Returns the requested brand details

Parameters:
- brandKey (string):  The brand key (required)

### putBrand()
Create or update a brand

Parameters:
- brandKey (string):  The brand key (required)

### getLocationKeys()
Returns a list of location keys

Parameters:
- brandKey (string):  The brand key (required)
- projection (string):  Filter list to only locations that exist in this projection.  Default is universal.

### patchLocations()
Applies the provided patch to each location in the list

Parameters:
- brandKey (string):  The brand key (required)
- source (string):  The source of the location data.
- body (object)
 - patch (array): The patch to apply.
 - locationKeys (array): The list of locations to which the patch should be applied

### getLocationList()
Returns a list of locations

Parameters:
- brandKey (string):  The brand key (required)
- body (object)
 - query (object): The query to execute.
 - view (object): The view name.
 - paths (array): A list of paths.
 - pageSize (integer): The number of results to return per page.
 - pageNumber (integer): The page index to return.
 - sortColumn (object): The column on which to sort results.
 - sortDirection (object): The sort direction.

### getLocationCount()
Returns a count of locations

Parameters:
- brandKey (string):  The brand key (required)
- body (object)
 - query (object): The query to execute.

### getLocation()
Returns a location

Parameters:
- brandKey (string):  The brand key (required)
- locationKey (string):  The location key. (required)
- projection (string):  The data projection to return.  Default is universal.
- includeRefs (string):  Set to true to include referenced data.

### putLocation()
Creates or updates a location

Parameters:
- brandKey (string):  The brand key (required)
- locationKey (string):  The location key. (required)
- source (string):  The source of the location data.
- document (object):  location data (required)

### deleteLocation()
Deletes a location

Parameters:
- brandKey (string):  The brand key (required)
- locationKey (string):  The location key. (required)
- source (string):  The source of the location data.

### getEvent()
Returns a specific event object

Parameters:
- brandKey (string):  The brand key (required)
- locationKey (string):  The location key. (required)
- eventId (string):  The event identifier. (required)
- source (string):  The source of the location data.

### patchLocation()
Updates a location at the specified event level

Parameters:
- brandKey (string):  The brand key (required)
- locationKey (string):  The location key. (required)
- eventId (string):  The event identifier. (required)
- source (string):  The source of the location data.
- document (object):  location data (required)

### deleteEvent()
Attempts to delete an event from a location's projection

Parameters:
- brandKey (string):  The brand key (required)
- locationKey (string):  The location key. (required)
- eventId (string):  The event identifier. (required)
- source (string):  The source of the location data.

### getLocationById()
Returns a location

Parameters:
- locationId (string):  The location identifier. (required)
- projection (string):  The data projection to return.  Default is universal.
- includeRefs (string):  Set to true to include referenced data.

### patchLocationSigned()
Applies the provided patch to the prescribed location

Parameters:
- locationId (string):  The location identifier. (required)
- patch (string):  The patch to be applied (required)
- source (string):  The source of the location data.
- redirect (string):  The URL to which the user should be redirected on success
- sig (string):  The URL signature (required)

### getLocationIntersect()
Returns the common data between all location projections

Parameters:
- body (object)
 - locationIds (array): location IDs

### getEvents()
Returns a list of events

Parameters:
- brandKey (string):  The brand key (required)
- locationKey (string):  The location key (required)
- source (string):  Filter events to only those from this source

### authorizeUpload()
Returns a signed upload request

Parameters:
- brandKey (string):  The brand key (required)
- fileMD5 (string):  The MD5 hex hash of the file to upload (required)

### bulkLoad()
Bulk load locations from a file

Parameters:
- brandKey (string):  The brand key (required)
- source (string):  The source of the location data.
- s3Path (string):  The full S3 URL for the gzipped JSON file (required)
- implicitDelete (boolean):  Whether locations missing from the file should be deleted (required)
- expectedRecordCount (integer):  The number of location records in the file. (required)
- successEmail (string):  The email address to email upon success. Can be a comma-delimited list.
- failEmail (string):  The email address to email upon failure. Can be a comma-delimited list.
- successCallback (string):  The URL to be requested upon success.
- failCallback (string):  The URL to be requested upon failure.

### getSchema()
Returns the validation schema for the brand

Parameters:
- brandKey (string):  The brand key (required)

### putSchema()
Create or update the validation schema for the brand

Parameters:
- brandKey (string):  The brand key (required)
- schema (object):  schema document (required)

### testSchema()
Returns a schema validation report

Parameters:
- brandKey (string):  The brand key (required)
- body (object)
 - schema (object): A JSON schema document.
 - query (object): A query used to filter the locations used in the schema test.

### getDocs()
Returns the API documentation

Parameters: none

### whoami()
Returns information on the current logged in user

Parameters: none

### logout()
Log out of Stormpath and this site

Parameters: none

### idsiteCallback()
Handle the result of Stormpath IDSite login

Parameters:
- jwtResponse (string):  The JWT-encoded result of the login. (required)

### idsiteLogout()
Handle the result of logging out of Stormpath

Parameters:
- jwtResponse (string):  The JWT-encoded result of the login. (required)

repository: balihoo/balihoo-blip-sdk-node

gha_language: CoffeeScript

repo_name: balihoo/balihoo-blip-sdk-node


text:
# DGHA-Proj
DGHA Members Static site and review page[GROUP PROJECT]

Project is to create a mobile app for members of Dog Guide Handlers Association to show business owners current and relevant legislation and information on Handler's Rights of Access etc. The second part of the project is set up a linked site for users of the mobile app to review accessibility of public places and businesses.

## Initial research.

Initial research was in WCAG guidelines for creating a site for any users that may need to use it.
Then looking into tech options.

I nominated myself to look into Prisma and GraphQL as I had an interest in these.
See [GraphQl](https://github.com/cecpoool/DGHA_graphqlReviewTest.git) and [Prisma](https://github.com/cecpoool/DGHA_prismatest.git)
We also initially looking into Angular as an option for the CMS - [Angular test](https://github.com/cecpoool/Angular-tutorial.git)
I also had a play with Gatsby.

## Backend

Backend will not be implemented until the next stage of this product. We will be working in GraphQL or Firebase for the user/review system.

## Frontend

Done in React JS
Initial front end was done in React Bootstrap. My first task in this was after inital build where I went in and separated out the navbar components - trying to figure out the best way to implement the navbars in a mobile browser with the mobile browser viewport issues. I tried a bunch of packages and code fixes but could not get it to work with the navbars at the bottom of the browser. So I moved it to the top(LOL). I implemented a few more CSS fixes and made the navbars fairly functional. Other teammembers inserting GeoLocation components and Translation components. Then a teammate added and implemented some React JS Context.

For the next stage we will be implementing golbal storage using Hooks so I have converted all the class components in the app to functional components to prepare for the next sprint.

gha_language: JavaScript

gha_license_id: MIT


text:
# Changelog
All notable changes to this project will be documented in this file.

## [0.0.3] - 2020-03-02
### Added
- Initial version

## [0.0.4] - 2020-03-30
### Fixed
- Pypi distribution package

## [0.0.5] - 2020-03-31
### Fixed
- Fix authentication error

### Added
- better communication handling

## [0.0.6] - 2020-05-12
### Added
 - support for self-signed certificates

## [0.0.6] - 2020-05-16
### Fixed
 - off-by-one error in output indexing.

## [1.0.3] - 2020-06-01
### Added
 - Major CLI redesign
 - Updated documentation

## [1.0.6] - 2021-04-07
### Added
 - fix argparse for python 3.6

## [1.0.8] - 2023-02-21
### Added
 - timeout parameter to JsonDevice

repository: netioproducts/PyNetio

gha_language: Python

repo_name: netioproducts/PyNetio