text:
Database Migration
==================

Like source code, the structure of a database evolves as a database-driven application is developed and maintained. For example, during development, a new table may be added; Or, after the application goes live, it may be discovered that an additional index is required. It is important to keep track of these structural database changes (called **migration**), just as changes to the source code is tracked using version control. If the source code and the database become out of sync, bugs will occur, or the whole application might break. For this reason, Yii provides a database migration
tool that can keep track of database migration history, apply new migrations, or revert existing ones.

The following steps show how database migration is used by a team during development:

1. Tim creates a new migration (e.g. creates a new table, changes a column definition, etc.).
2. Tim commits the new migration into the source control system (e.g. Git, Mercurial).
3. Doug updates his repository from the source control system and receives the new migration.
4. Doug applies the migration to his local development database, thereby syncing his database to reflect the changes Tim made.

Yii supports database migration via the `yii migrate` command line tool. This tool supports:

* Creating new migrations
* Applying, reverting, and redoing migrations
* Showing migration history and new migrations

Creating Migrations
-------------------

To create a new migration, run the following command:

```
yii migrate/create <name>
```

The required `name` parameter specifies a very brief description of the migration. For example, if the migration creates a new table named *news*, you'd use the command:

```
yii migrate/create create_news_table
```

As you'll shortly see, the `name` parameter
is used as part of a PHP class name in the migration. Therefore, it should only contain letters,
digits and/or underscore characters.

The above command will create a new
file named `m101129_185401_create_news_table.php`. This file will be created within the `protected/migrations` directory. Initially, the migration file will be generated with the following code:

```php
class m101129_185401_create_news_table extends \yii\db\Migration
{
	public function up()
	{
	}

	public function down()
	{
		echo "m101129_185401_create_news_table cannot be reverted.\n";
		return false;
	}
}
```

Notice that the class name is the same as the file name, and follows the pattern
`m<timestamp>_<name>`, where:

* `<timestamp>` refers to the UTC timestamp (in the
format of `yymmdd_hhmmss`) when the migration is created,
* `<name>` is taken from the command's `name` parameter.

In the class, the `up()` method should contain the code implementing the actual database
migration. In other words, the `up()` method executes code that actually changes the database. The `down()` method may contain code that reverts the changes made by `up()`.

Sometimes, it is impossible for the `down()` to undo the database migration. For example, if the migration deletes
table rows or an entire table, that data cannot be recovered in the `down()` method. In such
cases, the migration is called irreversible, meaning the database cannot be rolled back to
a previous state. When a migration is irreversible, as in the above generated code, the `down()`
method returns `false` to indicate that the migration cannot be reverted.

As an example, let's show the migration about creating a news table.

```php

use yii\db\Schema;

class m101129_185401_create_news_table extends \yii\db\Migration
{
	public function up()
	{
		$this->createTable('tbl_news', [
			'id' => 'pk',
			'title' => Schema::TYPE_STRING . ' NOT NULL',
			'content' => Schema::TYPE_TEXT,
		]);
	}

	public function down()
	{
		$this->dropTable('tbl_news');
	}

}
```

The base class [\yii\db\Migration] exposes a database connection via `db`
property. You can use it for manipulating data and schema of a database.

The column types used in this example are abstract types that will be replaced
by Yii with the corresponding types depended on your database management system.
You can use them to write database independent migrations.
For example `pk` will be replaced by `int(11) NOT NULL AUTO_INCREMENT PRIMARY KEY`
for MySQL and `integer PRIMARY KEY AUTOINCREMENT NOT NULL` for sqlite.
See documentation of [[QueryBuilder::getColumnType()]] for more details and a list
of available types. You may also use the constants defined in [[\yii\db\Schema]] to
define column types.

Transactional Migrations
------------------------

While performing complex DB migrations, we usually want to make sure that each
migration succeed or fail as a whole so that the database maintains the
consistency and integrity. In order to achieve this goal, we can exploit
DB transactions. We could use special methods `safeUp` and `safeDown` for these purposes.

```php

use yii\db\Schema;

class m101129_185401_create_news_table extends \yii\db\Migration
{
	public function safeUp()
	{
		$this->createTable('tbl_news', [
			'id' => 'pk',
			'title' => Schema::TYPE_STRING . ' NOT NULL',
			'content' => Schema::TYPE_TEXT,
		]);

		$this->createTable('tbl_user', [
			'id' => 'pk',
			'login' => Schema::TYPE_STRING . ' NOT NULL',
			'password' => Schema::TYPE_STRING . ' NOT NULL',
		]);
	}

	public function safeDown()
	{
		$this->dropTable('tbl_news);
		$this->dropTable('tbl_user');
	}

}
```

When your code uses more then one query it is recommended to use `safeUp` and `safeDown`.

> Note: Not all DBMS support transactions. And some DB queries cannot be put
> into a transaction. In this case, you will have to implement `up()` and
> `down()`, instead. And for MySQL, some SQL statements may cause
> [implicit commit](http://dev.mysql.com/doc/refman/5.1/en/implicit-commit.html).

Applying Migrations
-------------------

To apply all available new migrations (i.e., make the local database up-to-date),
run the following command:

```
yii migrate
```

The command will show the list of all new migrations. If you confirm to apply
the migrations, it will run the `up()` method in every new migration class, one
after another, in the order of the timestamp value in the class name.

After applying a migration, the migration tool will keep a record in a database
table named `tbl_migration`. This allows the tool to identify which migrations
have been applied and which are not. If the `tbl_migration` table does not exist,
the tool will automatically create it in the database specified by the `db`
application component.

Sometimes, we may only want to apply one or a few new migrations. We can use the
following command:

```
yii migrate/up 3
```

This command will apply the 3 new migrations. Changing the value 3 will allow
us to change the number of migrations to be applied.

We can also migrate the database to a specific version with the following command:

```
yii migrate/to 101129_185401
```

That is, we use the timestamp part of a migration name to specify the version
that we want to migrate the database to. If there are multiple migrations between
the last applied migration and the specified migration, all these migrations
will be applied. If the specified migration has been applied before, then all
migrations applied after it will be reverted (to be described in the next section).

Reverting Migrations
--------------------

To revert the last one or several applied migrations, we can use the following
command:

```
yii migrate/down [step]
```

where the optional `step` parameter specifies how many migrations to be reverted
back. It defaults to 1, meaning reverting back the last applied migration.

As we described before, not all migrations can be reverted. Trying to revert
such migrations will throw an exception and stop the whole reverting process.

Redoing Migrations
------------------

Redoing migrations means first reverting and then applying the specified migrations.
This can be done with the following command:

```
yii migrate/redo [step]
```

where the optional `step` parameter specifies how many migrations to be redone.
It defaults to 1, meaning redoing the last migration.

Showing Migration Information
-----------------------------

Besides applying and reverting migrations, the migration tool can also display
the migration history and the new migrations to be applied.

```
yii migrate/history [limit]
yii migrate/new [limit]
```

where the optional parameter `limit` specifies the number of migrations to be
displayed. If `limit` is not specified, all available migrations will be displayed.

The first command shows the migrations that have been applied, while the second
command shows the migrations that have not been applied.

Modifying Migration History
---------------------------

Sometimes, we may want to modify the migration history to a specific migration
version without actually applying or reverting the relevant migrations. This
often happens when developing a new migration. We can use the following command
to achieve this goal.

```
yii migrate/mark 101129_185401
```

This command is very similar to `yii migrate/to` command, except that it only
modifies the migration history table to the specified version without applying
or reverting the migrations.

Customizing Migration Command
-----------------------------

There are several ways to customize the migration command.

### Use Command Line Options

The migration command comes with four options that can be specified in command
line:

* `interactive`: boolean, specifies whether to perform migrations in an
  interactive mode. Defaults to true, meaning the user will be prompted when
  performing a specific migration. You may set this to false should the
  migrations be done in a background process.

* `migrationPath`: string, specifies the directory storing all migration class
  files. This must be specified in terms of a path alias, and the corresponding
  directory must exist. If not specified, it will use the `migrations`
  sub-directory under the application base path.

* `migrationTable`: string, specifies the name of the database table for storing
  migration history information. It defaults to `tbl_migration`. The table
  structure is `version varchar(255) primary key, apply_time integer`.

* `connectionID`: string, specifies the ID of the database application component.
  Defaults to 'db'.

* `templateFile`: string, specifies the path of the file to be served as the code
  template for generating the migration classes. This must be specified in terms
  of a path alias (e.g. `application.migrations.template`). If not set, an
  internal template will be used. Inside the template, the token `{ClassName}`
  will be replaced with the actual migration class name.

To specify these options, execute the migrate command using the following format

```
yii migrate/up --option1=value1 --option2=value2 ...
```

For example, if we want to migrate for a `forum` module whose migration files
are located within the module's `migrations` directory, we can use the following
command:

```
yii migrate/up --migrationPath=@app/modules/forum/migrations
```

### Configure Command Globally

While command line options allow us to configure the migration command
on-the-fly, sometimes we may want to configure the command once for all.
For example, we may want to use a different table to store the migration history,
or we may want to use a customized migration template. We can do so by modifying
the console application's configuration file like the following,

```php
'controllerMap' => [
    'migrate' => [
        'class' => 'yii\console\MigrateController',
        'migrationTable' => 'my_custom_migrate_table',
    ],
]
```

Now if we run the `migrate` command, the above configurations will take effect
without requiring us to enter the command line options every time. Other command options
can be also configured this way.


text:
### WhatsApp Android Helper

[![](https://jitpack.io/v/neel1998/WhatsappAndroidHelper.svg)](https://jitpack.io/#neel1998/WhatsappAndroidHelper)

This Android library allows to send messages from your Android app to any phone number (even unsaved) on WhatsApp.

### Depedency

To use this library add following repository in your `build.gradle` file.

```
allprojects {
		repositories {
			...
			maven { url 'https://jitpack.io' }
		}
	}
```
And then in `app.gradle` file add the following dependecy,

```
dependencies {
	        implementation 'com.github.neel1998:WhatsappAndroidHelper:1.0.2'
	}
```

### How to use

Using this library is absolutely easy. All you need to do is create an instance of `WhatsAppMessageSender` class and then call `sendMessage` method. This method takes the following three arguments:

1. Country code (String): Country code for phone number without preceeding "+". eg for India use "91"
2. Phone number (String): Phone number to which you wish to send the message. This number need not be saved in your contact but must be registered on whatsapp.
3. Message (String): The message you wish to send.

The following code snippet shows how to use this method,

```
import com.neel_trivedi.whatsappmessagesender.WhatsAppMessageSender;

import java.io.UnsupportedEncodingException;

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        WhatsAppMessageSender messageSender = new WhatsAppMessageSender(this);
        try {
            messageSender.sendMessage("91", "1234567890", "hey there!");
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
    }
}

```

### Contribute

If you find any issues bug do report on Github or file a PR. Thanks.

license: MIT

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
# Docusign with Sevabhava

> Node/Express/ API with Docusign API

## Quick Start

Add your Firebase and Docusign keys to the "config/config.env" file.

```bash
# Install dependencies
npm install

# Serve on localhost:5000
npm run dev (nodemon)
or
npm start

```


text:
---
title: Microsoft vs Javascript standards
date: '2015-07-09T12:38+11:00'
comments: true
tags: [windows, rant, javascript, standards]
---

`<rant>`

Microsoft's flagship browser has been causing web developers much anguish
for over a decade now,
and they appear to have unleashed an "improved" version of that mediocrity
upon us via WinJS in their offering for HTML apps for Windows.

In Javascript norms, when a function throws an error,
the error and its stack trace get output to the console,
all functions on this stack get aborted,
and execution of other parts of the page resume.
**Even IE** gets this right.
Microsoft has, however, decided to "improve" upon this behaviour
in their WinJS run time, where they decide that in the above scenario,
what should happen instead is to simply crash the program,
in a manner similar to that of a `SEGFAULT` in a C program.

This is most likely the root cause of the plentiful random crashes
in an app that we have been working on.

Even if we wrote our own code in defensively to work around this limitation
by *wrapping everything* in a *`try-catch` block*,
we simply **cannot enforce that the 3rd-party libraries**
we include do so as well.

... But there is *light at the end of the tunnel*.
After much sleuthing, [Chris](https://github.com/impaler)
and I have worked out that there is indeed a way to catch these errors:
by setting a `window.onerror` handler function,
and doing `evt.preventDefault()` inside it.

But that would be too easy, wouldn't it?
Why yes, of course, we should have had the foresight to realise that
the **spec would be ignored yet again**,
and be required to use a parallel API instead.
Here's the workaround that we ended up with that appears to work:

```
window.WinJS.Application.addEventListener('error', globalOnError);
function globalOnError(evt) {
  console.log('globalOnError', evt); // Replace with proper logging functions
  return true;
}
```

In a 3rd instance of a **flagrant disregard for Javascript norms**,
the `evt` parameter here has neither
`preventDefault()` nor `stopPropagation()` methods available.
On the other hand, `evt.details.error` does,
but that does not matter,
because calling those will crash the program `SEGFAULT` style as well -
but of course!
Instead, we have to do a `return true` to do so,
which takes us all the way back to Javascript event handling patterns
that fell out of favour in the 90's.

`</rant>`

We may have found a workaround for (at least some of) the random crashes,
and in doing so, found this caution to be vital:
When doing anything Microsoft Javascript platforms,
tread carefully, and be prepared to write a parallel set of code
from specification compliant Javascript.
**Do not expect** anything that *"should work"*
because *"it's standard Javascript"* to actually work,
because that does not appear to be a priority.

Javascript is a language that is supposed to be both
**community-driven** (ECMAScript and W3C) and **open**;
and vendor should be creating platforms that go forward
with the standards as they progress forward rather than break them
with works-for-me-only solutions.

Please **reconsider** your Javascript strategy.

repository: bguiz/blog-bguiz

gha_language: HTML

gha_license_id: MIT

repo_name: bguiz/blog-bguiz


text:
# Discourse Invites From File
Import user details from a file and generate invite links for discourse

[![Build Status](https://travis-ci.org/choiceaustralia/discourse-invites-from-file.svg?branch=master)](https://travis-ci.org/choiceaustralia/discourse-invites-from-file)

The invite link format is like this:

`http://discourse.example.com/invites/redeem/TOKEN?username=USERNAME&email=EMAIL&name=NAME&topic=TOPICID`

Replace following fields:

* `discourse.example.com` with the URL of your Discourse instance.
* `TOKEN` the invite token generated via the discourse api (that is what this gem does for you).
* `EMAIL` with the email of user you want to invite
* `USERNAME` with the desired username of invited user
* `NAME` with the first name of invited user
* `TOPIC` with the id of the topic to direct the user to after joining

## Steps

Visit ```/admin/api``` on your discourse installation and generate yourself an API key.

`cp env.example .env`

Edit ```.env``` adding your Host address, API key, Username and the names of any groups or topics.

Install the needed gems

`bundle install`

Run the rake task:

`bundle exec rake invites:generate:csv`

or with enviroment variables (these aren't set in ``.env`)

`bundle exec rake invites:generate:csv DISCOURSE_API_GROUP_NAMES=security,support DISCOURSE_API_TOPIC_ID=123`

This outputs to a file `tmp/output.csv`

gha_language: Ruby


text:
---

title: "Client usage"
aliases: "/sofa-registry/docs/Client-QuickStart"
---

## 1. Create a Maven project

After deploying the servers, we can create a new Maven project to use services provided by SOFARegistry. Create a new Maven project, and then import the following dependency:

```xml
<dependency>
    <groupId>com.alipay.sofa</groupId>
    <artifactId>registry-client-all</artifactId>
    <version>${registry.client.version}</version>
</dependency>
```

## 2. Publish data

```java
// Create a client instance.
RegistryClientConfig config = DefaultRegistryClientConfigBuilder.start().setRegistryEndpoint("<IP_ADDRESS>").setRegistryEndpointPort(9603).build();
DefaultRegistryClient registryClient = new DefaultRegistryClient(config);
registryClient.init();

// Create a publisher registry.
String dataId = "com.alipay.test.demo.service:1.0@DEFAULT";
PublisherRegistration registration = new PublisherRegistration(dataId);

// Register the registry with the client and publish data.
registryClient.register(registration, "<IP_ADDRESS>:12200?xx=yy");
```

Perform the following steps to publish data by using SOFARegistry:

1. Create a client instance.
1. Create a publisher registry.
1. Register the registry with the client and publish data.

### 2.1 Create a client instance

The key to creating a client instance is to create a RegistryClientConfig object. When creating a RegistryClientConfig object, you need to specify the RegistryEndpoint and RegistryEndpointPort.

* RegistryEndpoint: the endpoint of any session node of SOFARegistry
* RegistryEndpointPort: the session.server.httpServerPort port number configured for a session node

### 2.2 Create a publisher registry

To create a publisher registry, you only need to create a PublisherRegistration object and specify the dataId, which is the unique identifier of the publisher service.

### 2.3 Publish data

You can call the register method of the RegistryClient to publish data. This method requires two parameters: the first is a publisher registry with the specified dataId of a service, and the second is a string type data value.

## 3. Subscribe to the data

```java
// Create a client instance.
RegistryClientConfig config = DefaultRegistryClientConfigBuilder.start().setRegistryEndpoint("<IP_ADDRESS>").setRegistryEndpointPort(9603).build();
DefaultRegistryClient registryClient = new DefaultRegistryClient(config);
registryClient.init();

// Create SubscriberDataObserver.
SubscriberDataObserver subscriberDataObserver = new SubscriberDataObserver() {
  	public void handleData(String dataId, UserData userData) {
    		System.out.println("receive data success, dataId: " + dataId + ", data: " + userData);
  	}
};

// Create a subscriber registry and specify the subscription level. ScopeEnum covers three subscription levels: zone, dataCenter, and global.
String dataId = "com.alipay.test.demo.service:1.0@DEFAULT";
SubscriberRegistration registration = new SubscriberRegistration(dataId, subscriberDataObserver);
registration.setScopeEnum(ScopeEnum.global);

// Register the registry with the client and subscribe to the data. The subscribed data will be sent to SubscriberDataObserver in the form of a callback.
registryClient.register(registration);
```

Perform the following steps to subscribe to data by using SOFARegistry:

1. Create a client instance.
2. Create SubscriberDataObserver.
3. Create a subscriber registry.
4. Register the registry with the client and subscribe to data.

The client instance creation step is identical to that of the data publication step as described previously.

### 3.1 Create SubscriberDataObserver

SubscriberDataObserver is a callback interface that defines the handleData method, which provides two parameters: the dataId and the final data. This method will be called when the client receives the subscribed data. In SOFARegistry, data is returned from the servers in the form of UserData. This UserData class provides the following two methods:

```java
public interface UserData {
    Map<String, List<String>> getZoneData();
    String getLocalZone();
}
```

* getLocalZone: returns the current zone.
* getZoneData: returns data by taking zone as the key, and data of each zone as the value.

### 3.2 Create a subscriber registry

To create a subscriber registry, you need to create a SubscriberRegistration object by specifying the dataId and the SubscriberDataObserver.

### 3.3 Subscribe to data

You can call the register method of RegistryClient for data subscription. The register method requires only one parameter, that is the SubscriberRegistration object.

If we run first the data publication program and then the data subscription program, we can see the following output on the console:

```plain
receive data success, dataId: com.alipay.test.demo.service:1.0@DEFAULT, data: DefaultUserData{zoneData={DEFAULT_ZONE=[<IP_ADDRESS>:12200?xx=yy]}, localZone='DEFAULT_ZONE'}
```

gha_language: SCSS


text:
# Extra domain quota {#concept_zsf_cvd_n2b .concept}

## What is the default domain quota? {#section_pbn_cvd_n2b .section}

After you activate Alibaba Cloud WAF, you can deploy it for one domain name to provide protection. By default, a total of ten subdomains \(including the root domain\) of one domain name can be configured with a WAF instance. A subdomain can be a wildcard domain.

Taking `abc.com` for example, you can enable WAF protection for up to ten subdomains, such as `www.abc.com`, `\*.abc.com`, `mail.abc.com`, `user.pay.abc.com`, and `x.y.z.abc.com`. The root domain `abc.com` is also regarded as one of the ten subdomains.

## What is an extra domain quota? {#section_rbn_cvd_n2b .section}

If you want to enable WAF protection for more than one domain names or more than 10 subdomains, you can buy an extra domain quota. Assume that you have already configured `abc.com` or its subdomains with your WAF instance. When you try to add `xyz.com` \(another domain name\) to the WAF protection list, you will receive a system prompt informing you that the domain quota is exceeded.

![](http://static-aliyun-doc.oss-cn-hangzhou.aliyuncs.com/assets/img/15541/15419900087289_en-US.png)

In this case, you must upgrade the service to purchase an extra domain quota. For more information, see [Renewal and upgrade](intl.en-US/Pricing/Renewal and upgrade.md#).

On the Upgrade page, select the number of extra domains you want and complete the payment.

repository: hglakfs/waf

filename: Extra domain quota.md

repo_name: hglakfs/waf


text:
# CS294-112 HW 5a: Exploration

## Usage

To run all experiments and plot figures for the report, run

```bash
bash run_all.sh
```

## Results
### Problem 1
#### (a)

### Problem 2
#### (a)

### Problem 3
#### (a)

### Problem 4
#### (a)

#### (b)
Surprisingly, 3 curves are very similar. The baseline model without exploration has already achieved good performance, and EX2-based exploration cannot further improve the performance in this case.

## Original README

Dependencies:
 * Python **3.5**
 * Numpy version **1.14.5**
 * TensorFlow version **1.10.5**
 * MuJoCo version **1.50** and mujoco-py **<IP_ADDRESS>**
 * seaborn
 * tqdm==**4.26.0**

Before doing anything, first replace `gym/envs/mujoco/half_cheetah.py` with the provided `sparse_half_cheetah.py` file. It is always a good idea to keep a copy of the original `gym/envs/mujoco/half_cheetah.py` just in case you need it for something else.

You will implement `density_model.py`, `exploration.py`, and `train_ac_exploration_f18.py`.

See the [hw5a.pdf](hw5a_instructions.pdf) in this folder for further instructions.

repository: BaiLiping/BLP

repo_name: BaiLiping/BLP


text:
tablespoon-desktop
==================

An [electron](https://github.com/atom/electron)-based desktop client for
[tablespoon](https://github.com/ajam/tablespoon).

Currently [ractive](http://www.ractivejs.org/) is used for templating and data
binding, based largely on Max Ogden's [Monu](https://github.com/maxogden/monu/).

Building
--------

This is still a work in progress. Some node packages will need to be recompiled
natively to work within electron. For example, using `node-sqlite3` on Linux
required the following:

    node-gyp rebuild --target=0.26.1 --arch=x64 --target_platform=linux --dist-url=https://atom.io/download/atom-shell --module_name=node_sqlite3 --module_path=../lib/binding/node-v43-linux-x64

Otherwise you should be able to do the following to get going:

    npm install
    npm start

TODO
----

 * Build binaries for Mac, Windows, Linux
 * Drag and drop files including CSVs
 * Styling
 * Maps for geographic data
 * Notebook-style saving of queries

repository: ebrelsford/tablespoon-desktop

repo_name: ebrelsford/tablespoon-desktop


text:
# 524

—We explore techniques for imputing missing values
using machine learning. The presence of missing values is a
frequent problem encountered in data analysis and machine
learning applications. The purpose of this work is to create a data
imputation framework to impute values for a numerical dataset
using Generative Adversarial Networks. The approach discussed
attempts to provide an understandable solution through detailed
error analysis. Our analysis assesses the strength and weakness
of GAIN and demonstrates the potential and utility of using
GANs in multimodal and diverse UCI datasets. The framework
is based on an optimization of GAIN algorithm to impute missing
data with mixed continuous and categorical features for multiple
imputation with a visualisation toolkit to analyse errors.

branch_name: refs/heads/main


text:
# RCSignalProcessor
Mini project for processing standard RC signals on an arduino board, meant to extend functionality of RC models.

# Usage

Main value of this program is in its CppmInput and PwmInput classes, which
read CPPM or PWM inputs from interrupt pins (pins 2 or 3 on Arduino Nano).
This is implemented using interrupts, thus leaving main program loop free to
manage outputs.

To use this program, I suggest that you first uncomment serial debug messages
and make sure that the program can read input from RC receiver and also to
make note of values read.

Afterwards, you can comment out the debug messages and  modify main loop to
your needs. A simple light pattern is pre-programmed.

# Licensing
This project is distributed under MIT License

# MIT License

Copyright (c) 2017 Peter Pokojný

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: FooRider/RCSignalProcessor

repo_name: FooRider/RCSignalProcessor


text:
---
layout: post
permalink: /projects/keystone-docs
title:  "Keystone Form to Doc"
date:   2017-10-17 09:00 -0500
author: Jacob
github: https://github.com/janikgar/keystone-form-to-doc
---

This Google Apps Script App was designed for a client in order to convert their proprietary Google Forms to Google Docs.

-----
#### Error reporting
**If you are having issues with this app (error messages or the app timing out), please contact Jacob for support.** You can use the link above. It is most helpful if you can share the exact error you got as well as sharing the Google Doc that triggered the issue (view-only is fine).

[Privacy Policy](/docs/privacy-commercial)


text:
## Configuration
_Your repository must include:_

- `README.md` - with documentation regarding your lab and its current state of development. Check the "documentation" section below for more details on how that should look **AT MINIMUM**
- `.gitignore` - with standard NodeJS configurations
- `.eslintrc.json` - with Code 301 course standards for the linter

```
01-mobile-first
├── .eslintrc.json
├── .gitignore
├── LICENSE
├── README.md
├── index.html
├── styles
│   ├── base.css
│   ├── fonts
│   │   ├── icomoon.eot
│   │   ├── icomoon.svg
│   │   ├── icomoon.ttf
│   │   └── icomoon.woff
│   ├── icons.css
│   ├── layout.css
│   └── modules.css
└── vendor
    └── styles
        └── normalize.css
```

---

## User Stories and Feature Tasks

*As a user, I want to have an application that looks good, is easy to use, and is updated often, so that I want to come back and use it frequently.*

- Working from the provided comp images, write CSS such that the browser rendering matches the images as closely as possible.
- Utilize the icon fonts located in `styles/icons.css` for navigation features as shown in the comp images.

*As a developer, I want to use standard industry practices for setting up and organizing the code that handles the styling of my application so that my code is easy to edit and maintain.*

- Utilize a [`normalize.css`](https://github.com/necolas/normalize.css/blob/master/normalize.css) file, which should be placed in a `vendor/styles/` directory, to override default browser settings that affect the way documents render.
- Utilize SMACSS practices to organize CSS into separate files and appropriately order the loading of those files in the `<head>` of the HTML document.

*As a user, I want a familiar experience of the application so that I know how to use it on my smartphone and occasionally my laptop.*

 - Initially design the application to render per the comp images on mobile devices.
 - Set up the viewport and fluid media rules so content renders per the comp images in both mobile and desktop views. Use a breakpoint of 640 pixels.
 - Add a "Hamburger" menu button that reveals the nav links when tapped on a mobile device.
- Ensure that images are responsive and do not exceed the size of the viewport.

### Stretch Goal
<!-- Include any additional stretch goals for this assignment, which can vary depending on the class and their overall preparedness for additional work. -->
*As a user, I want a familiar experience when accessing the application on my tablet so that I can get the most out of the screen size.*
- Set up an intermediate media query for tablet devices (choose the maximum width at your own discretion).

---

## Documentation
_Your README.md must include:_

```md
# Project Name

**Author**: Your Name Goes Here
**Version**: 1.0.0 (increment the patch/fix version number up if you make more commits past your first submission)

## Overview
<!-- Provide a high level overview of what this application is and why you are building it, beyond the fact that it's an assignment for a Code Fellows 301 class. (i.e. What's your problem domain?) -->

## Getting Started
<!-- What are the steps that a user must take in order to build this app on their own machine and get it running? -->

## Architecture
<!-- Provide a detailed description of the application design. What technologies (languages, libraries, etc) you're using, and any other relevant design information. -->

## Change Log
<!-- Use this are to document the iterative changes made to your application as each feature is successfully implemented. Use time stamps. Here's an examples:

01-01-2001 4:59pm - Application now has a fully-functional express server, with GET and POST routes for the book resource.

## Credits and Collaborations
<!-- Give credit (and a link) to other people or resources that helped you build this application. -->
-->
```


text:
# Client Credentials Flow integration tests

These integration tests test Web API endpoints that return publicly available data using Client Credentials Flow. In order to run the tests locally:

- Get a Client ID and Client Secret by creating a new app in the [Spotify App Registration Portal](https://developer.spotify.com/dashboard/applications).
- Create new `secrets.json` file in project's folder with the following JSON code using provided Client ID and Client Secret:

```json
{
  "SpotifyClientCredentialsFlow": {
    "ClientId": "<ClientId>",
    "ClientSecret": "<ClientSecret>",
  }
}
```

repository: dotnetfan/FluentSpotifyApi

repo_name: dotnetfan/FluentSpotifyApi


text:
# Who uses Octoductor?

As the Octoductor Community grows, we'd like to keep track of our users. Please send a PR with your organization name if you are using Octoductor.

Currently, the following organizations are officially using Octoductor:

1. Intuit


text:
#  LIGHT

### Learning in Interactive Games with Humans and Text

The LIGHT project is a large-scale fantasy text adventure game research platform for training agents
that can both talk and act, interacting either with other models or with humans.

## Abstract

We introduce a large-scale crowdsourced text adventure  game  as  a  research  platform for studying grounded dialogue.  In it, agents can both perceive,  emote and act whilst conducting
dialogue  with  other  agents;  models  and humans can both act as characters within the game. We describe the results of
training state-of-the-art  generative  and  retrieval  models  in this setting.
We show that in addition to using past dialogue, these models are able to effectively  use  the  state given  by  the
underlying world. In particular, we show that ground-ing on the details of the local environment,
including location descriptions  and  the  objects (and affordances of those objects) and characters
(and their previous actions) present within it allows better predictions of agent behavior and dialogue.
We analyze the ingredients necessary for successful grounding in this setting, and how each of these factors
relate to agents that can talk and act successfully.

## Publications

_Original LIGHT paper_:

- **[Learning to Speak and Act in a Fantasy Text Adventure Game](https://arxiv.org/abs/1903.03094)**
Jack Urbanek, Angela Fan, Siddharth Karamcheti, Saachi Jain, Samuel Humeau, Emily Dinan, Tim Rocktäschel, Douwe Kiela, Arthur Szlam, Jason Weston.

_ML to build the interactive world in LIGHT_:

- **[Generating Interactive Worlds with Text](https://arxiv.org/abs/1911.09194)**
Angela Fan, Jack Urbanek, Pratik Ringshia, Emily Dinan, Emma Qian, Siddharth Karamcheti, Shrimai Prabhumoye, Douwe Kiela, Tim Rocktaschel, Arthur Szlam, Jason Weston.

_RL agents in the LIGHT world to achieve open-domain goals_:

- **[I love your chain mail! Making knights smile in a fantasy game world: Open-domain goal-oriented dialogue agents](https://arxiv.org/abs/2002.02878)**
Shrimai Prabhumoye, Margaret Li, Jack Urbanek, Emily Dinan, Douwe Kiela, Jason Weston, Arthur Szlam.

_Addressing gender bias concerns in LIGHT_:

- **[Queens are Powerful too: Mitigating Gender Bias in Dialogue Generation](https://arxiv.org/abs/1911.03842)**
Emily Dinan, Angela Fan, Adina Williams, Jack Urbanek, Douwe Kiela, Jason Weston.

_Deploying the LIGHT game for lifelong learning of models_:

- **[Deploying Lifelong Open-Domain Dialogue Learning](https://arxiv.org/abs/2008.08076)**
Kurt Shuster, Jack Urbanek, Emily Dinan, Arthur Szlam, Jason Weston.

_Training situated RL agents on natural language LIGHT quests_:

- **[How to Motivate Your Dragon: Teaching Goal-driven Agents to Speak and Act in Fantasy Worlds](https://arxiv.org/abs/2010.00685)**
Prithviraj Ammanabrolu, Jack Urbanek, Margaret Li, Arthur Szlam, Tim Rocktaschel, Jason Weston.

_Knowledgeable LIGHT agents_:

- **[Reason first, then respond: Modular Generation for Knowledge-infused Dialogue](https://arxiv.org/pdf/2111.05204.pdf)**
Leonard Adolphs, Kurt Shuster, Jack Urbanek, Arthur Szlam, Jason Weston

_Agents that maintain Identity (Role-play accurately)_:
- **[Am I Me or You? State-of-the-Art Dialogue Models Cannot Maintain an Identity](https://arxiv.org/abs/2112.05843)**
Kurt Shuster, Jack Urbanek, Arthur Szlam, Jason Weston

## Datasets

The original LIGHT dataset features 663 locations, 3462 objects and 1755 character types,
described entirely in natural language. Within that game world, we collected 11,000 episodes of
character interactions (talking and acting).

You can view the data or train your own ParlAI agent on the LIGHT tasks with
`-t light_dialog`. See the [ParlAI quickstart for help](http://parl.ai/docs/tutorial_quick.html).

An additional WILD dataset featuring 41,131 training episodes of dialogue from [deploying as a game](https://arxiv.org/abs/2008.08076)
is available, using:
`-t light_dialog_wild`.

Data containing annotated quests used in How to Motivate Your Dragon can be found [here](http://parl.ai/downloads/light_project/quests/quest_stems.tar.gz), their completions are available as part of the WILD dataset above, and the ATOMIC-LIGHT dataset can be found [here](http://parl.ai/downloads/light_project/light_atomic/atomic_tuned.tar.gz).

## Pretrained Models

The BERT Bi-Ranker dialogue model is available e.g. via this command (which automatically downloads it):

    parlai eval_model -t light_dialog -mf models:light/biranker_dialogue/model

## Citation

If you use the dataset or models in your own work, please cite with the
following BibTex entry:

    @inproceedings{urbanek2019light,
      author={Jack Urbanek, Angela Fan, Siddharth Karamcheti, Saachi Jain, Samuel Humeau, Emily Dinan, Tim Rocktäschel, Douwe Kiela, Arthur Szlam, Jason Weston},
      title={Learning to Speak and Act in a Fantasy Text Adventure Game},
      journal={arXiv preprint arXiv:1903.03094},
      year={2019},
    }

repository: facebookresearch/ParlAI

gha_language: Python

repo_name: facebookresearch/ParlAI


text:
Input
=====

Applies correct bindkeys for input events.

Without this module, you may experience oddities in how Zsh interprets input.
For example, using the UP key, then using the back arrow and pressing DELETE may capatalize characters rather than delete them.

This module also provides double-dot parent directory expansion.
It can be enabled by uncommenting `zdouble_dot_expand='true'` in your .zimrc


text:
# sail ⛵

A React library for Solana account management and transaction handling.

## Usage

```typescript
import { SailProvider } from "@saberhq/sail";

const MyApp = <SailProvider>{/* stuff */}</SailProvider>;
```

repository: TrendingTechnology/sail

repo_name: TrendingTechnology/sail


text:
# Unity-Solana Wallet
The First Open-Source Unity-Solana Wallet with NFT support

The Unity-Solana Wallet is an essential bridge connecting game developers and the Solana blockchain. With Solana’s quick and low-cost transactions, games can start using blockchain technology like never before - in real-time. Thousands of developers will bring millions of players into the Solana ecosystem. This will, in turn, make the Solana projects benefit from an increased number of participants, and cross-protocol interoperability in games will take us beyond the current understanding of DeFi.

Unity-Solana Wallet uses Solnet's implementation .NET SDK, but we had to modify the library to make it Unity compatible with .NET Standard 2.0 and .NET 4.x.
Solnet is Solana's .NET SDK to integrate with the .NET ecosystem.  [Solnet](https://blockmountain.io/Solnet/).

## Features
- Create/Backup wallet with mnemonic phrase
- Account handling
- Transaction building
- SOL balance
- SPL-token balances
- SPL-token transfers
- Basic UI examples

## Dependencies
- Newtonsoft.Json
- Chaos.NaCl.Standard
- Portable.BouncyCastle
- Zxing

## Roadmap
- Multiple wallet accounts
- Camera support with QR code scanning for token transfers
- Improved UI for in-game easy integration
- Metaplex NFT / NFT-PRO support with GameObjects
- Token swaps
- NFT swaps
- One-click in-game currency creator
- Themed UI support
- Metaplex auctions for in-game store items

## Installation

1. Clone this repository outside of the main Unity project
2. Go to Package Manager in your project
3. Click on the plus in the top left corner and select "Add package from disk"
4. Select package.json file from a cloned dir
5. Once the package is installed, in the Package Manager inspector you will have Samples. Click on Import

## License

This project is licensed under the MIT License - see the [LICENSE](https://github.com/bmresearch/Solnet/blob/master/LICENSE) file for details

repository: IBaaNB/unity-solana-wallet

repo_name: IBaaNB/unity-solana-wallet


text:
# Bayesian Analysis with Python (Second edition)

This is the code repository for [Bayesian Analysis with Python](https://www.packtpub.com/big-data-and-business-intelligence/bayesian-analysis-python-second-edition), published by Packt. It contains all the code necessary to work through the book from start to finish. You can find the code from the first edition in the folder `first_edition`

## Feedback

If you have read Bayesian Analysis with Python (second edition). I will really appreciate if you can answer this very brief [questionnaire](https://forms.gle/8wbUttTUHg3kwLHc8)

## Installation

The code in the book was written using Python version 3.6. To install Python and Python libraries, I recommend using Anaconda, a scientific computing distribution. You can read more about Anaconda and download it at [https://www.anaconda.com/download/](https://www.anaconda.com/download/). This will install many useful Python packages on you system. You will need to install two more packages. To install PyMC3 please use conda :

```
conda install -c conda-forge pymc3
```

And for ArviZ you can do it with the following command:

```
pip install arviz
```

An alternative way to install the necessary packages, once Anaconda is installed in your system, is to go to https://github.com/aloctavodia/BAP and download the environment file named `bap.yml`. Using it, you can install all the necessary packages by doing:

```
conda env create -f bap.yml
```

For your reference the book was writting using the following python packages:

* Ipython 7.0
* Jupyter 1.0 (or Jupyter-lab 0.35)
* NumPy 1.14.2
* SciPy 1.1
* Pandas  0.23.4
* Matplotlib 3.0.2
* Seaborn 0.9.0
* ArviZ 0.3.1
* PyMC3 3.6

## Updated code

* Folder code_3_11 has notebooks with the code upated to work with PyMC 3.11
* Folder code_5 has notebooks with the code upated to work with PyMC > 5

## Errata

If you find an error in the book please fill an issue or send a pull request. Please before reporting an error read the `errata.md` file and verify the error has not being reported before.

## Changes from first edition

I have tried to incorporate all comments and critics from the first edition as well as much as possible input from students that have taken Bayesian courses with me. I have tried to remove those sections that I consider not very useful from the first edition and focus on improving and sometimes expanding those that contribute to understanding the basic elements of the Bayesian Analysis. I have added some new exercises and I try to provide useful summaries at the end of the book, I realized the ones from the first edition were almost useless.

The code in the book has being updated to better reflect the new features of PyMC3. While the first edition was based on PyMC 3.0, the second edition uses PyMC 3.6. The books also relies on the new Python Library [ArviZ](https://arviz-devs.github.io/arviz/) (version 0.3.1) for summaries, diagnostics and most of the plots.

This is a list of the most important differences per chapter.

* Chapter 1: Thinking Probabilistically. The Chapter have been updated to ease the introduction of the basic concepts of probability and Bayesian statistics and its implications for data analysis.

* Chapter 2: Programming Probabilistically. Chapter 2 and 3 from first edition have been unified and revised. This is now a more solid chapter setting the fundamentals of Bayesian statistics and probabilistic programming. New examples have been added.

* Chapter 3: Modeling with Linear Regression. A new procedure to compute the R² score is explained. I have added a new example about performing linear regression with variable variance and using shared variables.

* Chapter 4. Generalizing Linear Models. Content that was previously part of the mixture model chapter has been moved here providing a more coherent description of GLM models.

* Chapter 5. Model comparison. The content has been revised. I have added a discussion of Bayesian p-values. A brief discussion of the entropy, KL divergence and it relation to WAIC and model averaging. A new example showing how to compute Bayes Factors with Sequential Monte Carlo is shown

* Chapter 6 Mixture models. This chapter have been rewritten from scratch. The focus in on the basic elements of finite and infinite (Gaussian) mixture models.

* Chapter 7 Gaussian process. This chapter have been rewritten from scratch. I am particularly happy with this chapter. New examples are used to intuitively explain what GP are before applying them. The chapter uses the GP module that is part of PyMC3. The new examples include regression, classification and Cox processes.

* Chapter 8 Inference engine. The discussion of numerical methods to approximate the posterior and how to diagnose samples has its own chapter now. An explanation of how Sequential Monte Carlo works is also included. Although the chapter (and book) is focused on Markov Chain Monte Carlo methods, there is also a brief discussion about Variational Methods.

* Chapter 9, Where To Go Next?, provides a list of resources for you to keep learning from beyond this book, and a very short _farewell speech_.

The main aim from the first edition remains. That is, to help people with some Python experience but with no previous statistical knowledge to get started with Bayesian data analysis and probabilistic programming.

## Get the Book

- Amazon US [link](https://www.amazon.com/Bayesian-Analysis-Python-Introduction-probabilistic/dp/1789341655
)
- Amazon UK [link](https://www.amazon.co.uk/Bayesian-Analysis-Python-Introduction-probabilistic/dp/1789341655)
- Packt [link](https://packt.link/Osvaldo)

## License
The contents of this repository is under an [MIT License](https://github.com/aloctavodia/BAP/blob/master/LICENSE)

repository: aloctavodia/BAP

gha_language: Jupyter Notebook

repo_name: aloctavodia/BAP


text:
[![Heta project](https://img.shields.io/badge/%CD%B1-Heta_project-blue)](https://hetalang.github.io/)
[![GitHub license](https://img.shields.io/github/license/hetalang/qsp-benchmark.svg)](https://github.com/hetalang/qsp-benchmark/blob/master/LICENSE)

# qsp benchmarks

Storing different cases for simulation using [HetaSimulator.jl](https://github.com/hetalang/HetaSimulator.jl)

Update heta compiler before run

```julia
heta_update()
```

## List of cases

- **/boehm** : reproduced model from "Boehm at al  J Proteome Res. 2014;13: 5685–5694. doi:10.1021/pr5006923", in LP article.
    conditions, experimental data, fitting, plot fitted

- **/jak2stat5** : reproduced "large" model with many datasets from ": Molecular Systems Biology 7:516", in draft LP article

- **/time-event** : testing TimeSwitcher multiple doses and injections

- **/sbml_00375** : example from [SBML test suite](https://github.com/sbmlteam/sbml-test-suite)

- **/alco** : pk model with saturation

- old_fitting : two PK one compartment models : non-saturable and saturable (not finished yet)

repository: stjordanis/qsp-benchmark

repo_name: stjordanis/qsp-benchmark


text:
# [Vue Material Dashboard](https://demos.creative-tim.com/vue-material-dashboard) [![Tweet](https://img.shields.io/twitter/url/http/shields.io.svg?style=social&logo=twitter)](https://twitter.com/home?status=Vue%20Material%20Dashboard,%20a%20free%20Material%20Admin%20Template%20%E2%9D%A4%EF%B8%8F%20https%3A//bit.ly/2Nh5aVy%20%20%23vue%20%23material%20%23design%20%23developers%20%23freebie%20%20via%20%40CreativeTim)

 ![version](https://img.shields.io/badge/version-1.2.0-blue.svg)  ![license](https://img.shields.io/badge/license-MIT-blue.svg) [![GitHub issues open](https://img.shields.io/github/issues/creativetimofficial/vue-material-dashboard.svg?maxAge=2592000)](https://github.com/creativetimofficial/vue-material-dashboard/issues?q=is%3Aopen+is%3Aissue) [![GitHub issues closed](https://img.shields.io/github/issues-closed-raw/creativetimofficial/vue-material-dashboard.svg?maxAge=2592000)](https://github.com/creativetimofficial/vue-material-dashboard/issues?q=is%3Aissue+is%3Aclosed) [![Join the chat at https://gitter.im/NIT-dgp/General](https://badges.gitter.im/NIT-dgp/General.svg)](https://gitter.im/creative-tim-general/Lobby) [![Chat](https://img.shields.io/badge/chat-on%20discord-7289da.svg)](https://discord.gg/E4aHAQy)

![Product Gif](https://s3.amazonaws.com/creativetim_bucket/github/gif/vue-material-dashboard.gif)

## Demo

| Dashboard | User Profile | Tables | Maps | Notification |
| --- | --- | --- | --- | --- |
| [![Start page](src/assets/github/dashboard.png)](https://demos.creative-tim.com/vue-material-dashboard) | [![User profile page](src/assets/github/user_profile.png)](https://demos.creative-tim.com/vue-material-dashboard/#/user) | [![Tables page ](src/assets/github/tables.png)](https://demos.creative-tim.com/vue-material-dashboard/#/table) | [![Maps Page](src/assets/github/maps.png)](https://demos.creative-tim.com/vue-material-dashboard/#/maps) | [![Notification page](src/assets/github/notification.png)](https://demos.creative-tim.com/vue-material-dashboard/#/notifications)

## Quick start

## :cloud: Build Setup

### install dependencies
`npm install`
### serve with hot reload at localhost:8080
`npm run dev`
### build for production with minification
`npm run build`

repository: rafiudd/sarjanatani-dashboard

gha_language: CSS

repo_name: rafiudd/sarjanatani-dashboard


text:
VPN gateway of Tencent Cloud is developed based on [strongSwan](https://www.strongswan.org/). It uses a non-routable ip address 169.254.x.x as its WAN interface private ip address. And it is mandatory to use FQDN method for peer identity. Otherwise, IKE establishment will be failed with the following error:

```
TANS/IKE_SA_ESTABLISH_FAIL: Failed to establish IKE SA for the reason of no peer config found by ID payload.
```

On Cisco ASA, you are recommended to config hostname and domain-name, and config `crypto isakmp identity hostname`.

There are many things that need to be taken care of when connecting Cisco ASA to Tencent Cloud VPN gateway.

IPSec fragmentation must be set to `after-encryption` instead of `before-encryption` by default. Otherwise, Tencent VPN gateway will be failed to parse hash payload.

Besides, tunnel-group name must be same as peer ip address. Otherwise, ASA cannot find a valid tunnel group.

The pre-shared-key on ASA cannot contain special charactors. But it's okay on IOSXE.

The last thing, after configure IKEv2 policy and choose an encryption method out of AES-128 on Cisco ASA, PRF (Pseudo-Random Function) will be enabled with MD5/SHA256/SHA384/SHA512 algrithm by default. But on Tencent Cloud VPN GW, there is not a knob to set RPF. Also, it seems like strongSwan has some problems in supporting PRF + SHA256. So you are recommended to replace `prf sha256` with `prf sha` manually.

```
crypto ikev2 policy 1
    encryption aes-256
    integrity sha
    group {{ dh_group }}
    prf sha
    lifetime seconds 86400
```


text:
# Tenby
Tenby is a simple JSON to CSV and CSV to JSON convertor. It's API has been designed to be simple and concise.

Tenby exposes two kinds of APIs:
- A file based API : responses are written to a temporary file and the file's URL is returned.
- An object based API : the processed object is directly returned.

The File based API writes to a temporary location, and it's the user's job to move to a preferable location for long term storage.

## API

    + (NSURL *)CSVFromJSON:(id)aObj;
    + (NSURL *)JSONFromCSV:(NSString *)csv;

    + (NSURL *)CSVFromJSON:(id)aObj delimiter:(NSString *)delimiter;
    + (NSURL *)JSONFromCSV:(NSString *)csv delimiter:(NSString *)delimiter;

    + (NSURL *)CSVFromJSON:(id)aObj delimiter:(NSString *)delimiter endOfLine:(NSString *)eol;
    + (NSURL *)JSONFromCSV:(NSString *)csv delimiter:(NSString *)delimiter endOfLine:(NSString *)eol;

    + (NSString *)CSVStringFromJSON:(id)aObj;
    + (NSArray *)JSONFromCSVString:(NSString *)csv;

    + (NSString *)CSVStringFromJSON:(id)aObj delimiter:(NSString *)delimiter;
    + (NSArray *)JSONFromCSVString:(NSString *)csv delimiter:(NSString *)delimiter;

    + (NSString *)CSVStringFromJSON:(id)aObj delimiter:(NSString *)delimiter endOfLine:(NSString *)eol;
    + (NSArray *)JSONFromCSVString:(NSString *)csv delimiter:(NSString *)delimiter endOfLine:(NSString *)eol;

All API methods have been documented inside the header file.

Feel free to suggest new APIs or fork and send a pull request.

## TODO
- Read CSV and JSON objects from a file for processing.
- ~~Process multi-level JSON objects.~~

repository: dezinezync/Tenby

repo_name: dezinezync/Tenby


text:
# PokeLang
An esoteric programming language where programs are represented as a Pokemon
battle.

http://daniellowtw.github.io/pokelang for demo

## General Overview

- PokeLang consists of a series turns in a Pokemon battle.
- Moves correspond to an operation or object.
- The moves are then transcribed into a stack-oriented language called PokeStack.
- The PokeStack program is then run using a PokeStack interpreter.

### Example Translation

    Go! SQUIRTLE!
    Foe GARY sends out BULBASAUR!

    // Turn 1
    Foe GARY calls back BULBASAUR!
    Foe GARY sends out BULBASAUR!           // Pass turn with no action
    SQUIRTLE uses TACKLE!                   // 1

    // Turn 2
    Foe GARY calls back BULBASAUR!
    Foe GARY sends out BULBASAUR!
    SQUIRTLE uses TACKLE!                   // 1

    // Turn 3
    SQUIRTLE! That's enough! Come back!
    Go! CHARMANDER!
    Foe GARY calls back BULBASAUR!
    Foe GARY sends out BULBASAUR!

    // Turn 4
    CHARMANDER uses EMBER!                 // +
    IT's SUPER EFFECTIVE!

    // end

The above program is ( 1 1 + ), which simply adds 1 and 1, resulting in 2.

### Sample move list for arithmetic operations

| Instruction | Move         | Type | Pre             | Post      | Description      |
| ---         | ---          | ---  | ---             | ---       | ---              |
| +           | EMBER        | op   | ( #a #b )       | ( #a+#b ) | addition         |
| -           | WATERGUN     | op   | ( #a #b )       | ( #a-#b ) | subtraction      |
| *           | FLAMETHROWER | op   | ( num 1 num 2 ) | ( #a*#b ) | multiplication   |
| /           | HYDROPUMP    | op   | ( #a #b )       | ( #a/#b ) | integer division |

[View complete move list][1]

[View detailed documentation][2]

Usage
========
`npm install . -g`

`pokelang <file>`

Web Compiler
========

`bower install` and start a webserver in the public folder.

Running tests
========

Create tests files in tests/test_files and run `npm tests`

[1]: docs/move_list.md
[2]: docs/documentation.md

repository: daniellowtw/PokeLang

repo_name: daniellowtw/PokeLang


text:
# Zenflow

[![Gem Version](https://badge.fury.io/rb/zenflow.png)](http://badge.fury.io/rb/zenflow)
[![Code Climate](https://codeclimate.com/repos/51bf6e3b7e00a411ad00f6c3/badges/111fbe3664cebffa8e23/gpa.png)](https://codeclimate.com/repos/51bf6e3b7e00a411ad00f6c3/feed)
[![Coverage Status](https://coveralls.io/repos/zencoder/zenflow/badge.png)](https://coveralls.io/r/zencoder/zenflow)
[![Dependency Status](https://gemnasium.com/zencoder/zenflow.png)](https://gemnasium.com/zencoder/zenflow)
[![Circle CI](https://circleci.com/gh/zencoder/zenflow.png?style=badge)](https://circleci.com/gh/zencoder/zenflow)

-------

* [Getting Started](#getting-started)
* [Usage](#usage)
* [Commands Quick Reference](#commands)
* [Requirements](#requirements)
* [Enterprise Configuration](#enterprise)

-------

### What is Zenflow?

Zenflow is a Ruby implimentation of the [GitFlow process](http://nvie.com/posts/a-successful-git-branching-model/) for managing development in Git. It's been used at [Zencoder](http://zencoder.com) since 2010 and we've benefitted greatly from the structure it helps enforce, so we wanted to share it with the world.

###  Getting Started

Start off by installing the gem.

    gem install zenflow

Once you've installed the gem there are a few questions to answer so that Zenflow knows what sort of branches you want to track and what your qa/staging/production setup looks like.

To get started make sure you're in the root directory of the repository you want to work with, then run

    zenflow init

and answer the questions, then you're ready to start using Zenflow!

## Add a Zenflow GitHub token to enable interaction with GitHub

Zenflow will perform some actions with GitHub (opening pull requests, for example), if it is able to access your GitHub account. In order for these behaviors to work, you must configure a GitHub Token:

Visit https://github.com/settings/tokens to create a token for Zenflow (for this purpose, "no expiration" is appropriate).

Once you have your token, you can add it to your `~/.gitconfig`, e.g.:

```
[zenflow]
	user = yourgithandle
	token = <snip>
```

###  Usage

#### Features

In Zenflow a feature branch is used to isolate the development of a new feature or refactoring of existing code.

To start a feature in Zenflow run `zenflow feature start`.

You'll be asked for the name of the feature - make it something descriptive - and a new branch will be creaated from master called feature/FEATURE-NAME.

Now you can work and commit normally. If you have Capistrano set up with a QA server, you can deploy the feature at any time by running `zenflow feature deploy`. This will merge the current feature branch in to the qa branch, deploy to the QA server if you have one configured with Capistrano, then go back to the feature branch.

If master has been updated and you want the latest code brought to your feature, you can run `zenflow feature update` to merge the latest code from master.

When you're ready for code review run `zenflow feature review` to create a pull request on GitHub, comparing the master branch and the feature branch. Work with any feedback from the rest of the team as necessary until the code is ready for production.

Once development of the feature is completed run `zenflow feature finish` to merge the feature branch in to master and delete the local and remote branches. If Zenflow is set up to confirm review and testing you'll be asked if you've tested this code on QA and had it code reviewed. Don't lie to Zenflow.

#### Releases

As features are finished they accumulate in the `master` branch. To get them to production we create a release.

To start a release in Zenflow run `zenflow release start` and provide a release name. Themed release names are fun - robots, spaceships, football players, flowers. Something there's a lot of.

There's typically not much that should be done within a new release - active development isn't supposed to happen at this stage. If code review turns up a bug fix it here, but anything more should be done in a feature or hotfix branch.

Once the release is made, typing `zenflow release deploy` will merge the release in to the staging branch, deploy to staging if you have a staging server configured with Capistano, then switch back to the release branch.

After confirming that things are running properly on Staging a release can be reviewed on GitHub by typing `zenflow release review`, which creates a pull request from the release to the production branch.

Once review is completed, type `zenflow release finish` to merge the release branch in to production and delete the local and remote release branches.

To deploy to production, type `zenflow deploy production`.

#### Hotfixes

Hotfixes are used for code updates that need to be deployed outside of a release, usually to address a breaking issue in production.

To start a hotfix type `zenflow hotfix start`. This creates a new hotfix branch off of the production branch.

After the hotfix branch is created you can work and commit as normally. Running `zenflow hotfix deploy` deploys to the staging and qa servers.

When you're ready for code review run `zenflow hotfix review` to create a pull request on GitHub, comparing the production branch and the hotfix branch. Work with any feedback from the rest of the team as necessary until the code is ready for production.

Once development of the feature is completed run `zenflow hotfix finish` to merge the feature branch in to production and master, plus delete the local and remote branches. If Zenflow is set up to confirm review and testing you'll be asked if you've tested this code on QA and had it code reviewed. Don't lie to Zenflow.

To deploy to production, type `zenflow deploy production`. Hotfixes are not automatically deployed to production when they are finished.

####  Commands Quick Ref

    zenflow init
    zenflow (feature|hotfix|release) start
    zenflow (feature|hotfix|release) deploy
    zenflow (feature|hotfix|release) review
    zenflow (feature|hotfix|release) finish
    zenflow deploy (qa|staging|production)
    zenflow admin (list|current|describe|config|authorize)

###  Requirements/Assumptions

* Git >= 1.8
* Ruby >= 1.9.3
* Capistrano and cap-ext
* A repository on GitHub

###  Enterpise Configuration

Zenflow now supports repositories hosted on enterprise github servers.  `zenflow init` will automatically detect which server is hosting your repository by examining the remote string returned by `git remote -v`.  If it is an enterprise server, Zenflow will ask for additional configuration parameters including the API base URL of the enterprise server and an optional over-ride for the User-Agent header that Zenflow submits to the server.  All configuration parameters are stored in git config.

Zenflow can handle any number of enterprise github servers in addition to working with the primary github server at github.com.  To examine the github server configurations of your Zenflow install use the `zenflow admin ...` set of commands.

repository: zencoder/zenflow

extension: markdown

repo_name: zencoder/zenflow


text:
Rubygems
========

Ansible's `gem` module fails to install Bundler on recent versions of macOS,
probably due to SIP (tested with Ansible 2.2).

This module takes care of that.
It just updates Rubygems and installs the latest Bundler.

No dependencies, no role variables.

Requirements
------------

Your ansible user must be an admin on macOS.
You also have to provide your password to make system-wide changes, i.e. by
running `ansible-playbook` with `-K` or `--ask-become-pass`.

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

```
ansible-galaxy install bjoernalbers.rubygems
```

Example Playbook
----------------

```yaml
- hosts: servers
  roles:
     - bjoernalbers.rubygems
```

License
-------

MIT

repository: bjoernalbers/ansible-role-rubygems

repo_name: bjoernalbers/ansible-role-rubygems


text:
<!-- START doctoc generated TOC please keep comment here to allow auto update -->
<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->
**Table of Contents**

- [indexed-db-observers](#indexed-db-observers)
- [Polyfill](#polyfill)
- [Usage](#usage)

<!-- END doctoc generated TOC please keep comment here to allow auto update -->

# indexed-db-observers
Prototyping and discussion around IndexedDB observers.

 * [Explainer & FAQ](EXPLAINER.md) **<-- read this for details & spec changes**
 * [Examples](https://dmurph.github.io/indexed-db-observers/)

# Polyfill
The polyfill is located here:
```html
<script src="//dmurph.github.io/indexed-db-observers/polyfill.js"></script>
```

**It is currently out of date, as the spec has been changing a bit. I'll update it when the spec has settled.**

**PLEASE SEE EXPLAINER.MD FOR UP-TO-DATE INFORMATION**

Caveats:
 * It doesn't broadcast changes across browsing contexts.
 * Not very memory efficient.

# Usage
The function `IDBTransaction.observe(function(changes){...}, options)` will be added.

You can drop this into your web page right now (with small customization) and it should work:
```html
<script src="//dmurph.github.io/indexed-db-observers/polyfill.js"></script>
<script>
// ##### START BOILERPLATE ######
var db;
var databaseName = 'database';
var objectStoreName = 'store1';
var req = indexedDB.open(databaseName);
req.onupgradeneeded = function() {
  db = req.result;
  db.createObjectStore(objectStoreName);
};
req.onsuccess = function() {
  db = req.result;
  main();
}
// ##### END BOILERPLATE ######

var control;
function main() {
  var txn = db.transaction([objectStoreName], 'readonly'];
  control = txn.observe(observerFunction);
  txn.oncomplete = function() {
    console.log('Observing is starting!');
  }
}

function observerFunction(changes) {
  console.log('Observer received changes!');
  // An object store that we're observing has changed.
  changes.records.forEach(function(records, objectStoreName) {
    console.log('Got changes for object store: ', objectStoreName);
    records.forEach(function(change) {
      // do something with change.type and change.key
      var type = change.type;
      switch (type) {
        case 'clear':
          console.log('object store cleared.');
          break;
        case 'add':
          console.log('key "', change.key, '" added.');
          break;
        case 'put':
          console.log('key "', change.key, '" putted.');
          break;
        case 'delete':
          console.log('key or range "', change.key, '" deleted.');
          break;
      }
    });
  });
}
</script>
```

Here we ask for a readonly transaction in our changes:
```js
var control = txn.observe(function(changes) {
  var objectStore = changes.transaction.objectStore('store1');
  // read in values, etc
}, { includeTransaction: true });
```

Here we ask for the values in our changes:
```js
var control = txn.observe(function(changes) {
  changes.records.get(objectStoreName).forEach(function(change) {
    var type = change.type;
    switch (type) {
      case 'add':
        console.log('value "', change.value, '" added with key "', change.key, '"');
        break;
    }
  });
}, { includeValues: true });
```

And when we're done...
```js
control.stop();
```

See the [explainer](EXPLAINER.md) for more info, and the [examples](https://dmurph.github.io/indexed-db-observers/) for hosted examples. The demo app is especially helpful, as it visualizes everything for you.

repository: dmurph/indexed-db-observers

branch_name: refs/heads/gh-pages

repo_name: dmurph/indexed-db-observers


text:
# ChangeLog

## [2.5.3](https://github.com/commtech/fscc-linux/releases/tag/v2.5.3) (02/27/2019)
- Added copy_to/from_user functions for IOCTL calls
- Fixed a bug for the FSCC-232 clock

## [2.5.2](https://github.com/commtech/fscc-linux/releases/tag/v2.5.2) (06/09/2017)
- Added support for SFSCC LVDS PCIe

## [2.5.1](https://github.com/commtech/fscc-linux/releases/tag/v2.5.1) (03/10/2016)
- Minor code cleanup and optimizations
- Added support for FSCC/4-PCIe
- Updated octal permissions
- Fixed receive_length value issue that cause kernel panic
- Changed logic to deal with incorrect fifo_bc_value

## [2.5.0](https://github.com/commtech/fscc-linux/releases/tag/v2.5.0) (02/13/2014)
- Updated SerialFC to
[v2.3.0](https://github.com/commtech/serialfc-linux/releases/tag/v2.3.0)
- Added support for FSCC/4-PCIe cards
- Fixed issue with setting clock frequency on 4-port cards
- Minor optimizations

## [2.4.9](https://github.com/commtech/fscc-linux/releases/tag/v2.4.9) (01/10/2014)
- Added checks to prevent status/timestamp while in streaming mode
- Added clock frequency range checks
- Reimplement sysfs support for quantity input/output frames
- Minor improvements

## [2.4.8](https://github.com/commtech/fscc-linux/releases/tag/v2.4.8) (12/09/2013)
- Updated SerialFC to
[v2.2.0](https://github.com/commtech/serialfc-linux/releases/tag/v2.2.0)
- Increased the default timeout duration to 50 cycles
- Added early support for getnstimeofday()
- Fixed setting the clock rate on 232 cards
- Fixed a buf where DMA frames were getting lost
- Various small fixes

## [2.4.7](https://github.com/commtech/fscc-linux/releases/tag/v2.4.7) (11/14/2013)
- Fixed a bug that prevented small frame sizes from being calculated  correctly when approaching the memory limit

## [2.4.6](https://github.com/commtech/fscc-linux/releases/tag/v2.4.6) (11/5/2013)
- Fixed a bug where outgoing frames wouldn't get cleared fast enough

## [2.4.5](https://github.com/commtech/fscc-linux/releases/tag/v2.4.5) (10/7/2013)
- Fixed a bug where input stream data wasn't being calculated in memory usage
- Fixed tx_modifiers ioctl to accept raw integers

## [2.4.4](https://github.com/commtech/fscc-linux/releases/tag/v2.4.4) (09/25/2013)
- Fixed a regression where card's weren't detected on kernels < (3.8)

## [2.4.3](https://github.com/commtech/fscc-linux/releases/tag/v2.4.3) (09/25/2013)
- Performance improvements when transmitting and receiving frames
- Fix bug preventing tx_modifiers from being set correctly
- Remove old CLI from project
- Add links to external libraries
- Fixed a bug where card won't be recognized if serialfc driver is loaded first
- Remove hot_plug option

## [2.4.2](https://github.com/commtech/fscc-linux/releases/tag/v2.4.1) (08/28/2013)
- Fixed a bug that would allow you to return more data than your buffer  size (introduced in 2.4.0)

## [2.4.1](https://github.com/commtech/fscc-linux/releases/tag/v2.4.1) (08/28/2013)
- Stability improvements

## [2.4.0](https://github.com/commtech/fscc-linux/releases/tag/v2.4.0) (08/26/2013)
- Added support for timestamps

## [2.3.0](https://github.com/commtech/fscc-linux/releases/tag/v2.3.0) (08/14/2013)
- Now use serialfc driver for asynchronous data
- Optimize write handling
- Added sysfs support for returning multiple frames

## [2.2.4](https://github.com/commtech/fscc-linux/releases/tag/v2.2.4) (06/20/2013)
- Added support for returning multiple frames per read call
- Added support for new card ID's

## [2.2.3](https://github.com/commtech/fscc-linux/releases/tag/v2.2.3) (06/13/2013)
- Fixed a bug where having NTB set wouldn't put you in a frame based mode
- Fixed a compiler issue on older kernels
- Several small performance improvements when handling incoming frames

## [2.2.2](https://github.com/commtech/fscc-linux/releases/tag/v2.2.2) (03/25/2013)
- Performance improvements
- Fixed a bug where asynchronous baud rates were off
- Fixed compiler errors introduced in linux 3.8
- Fixed random crash in framing based modes

## [2.2.1](https://github.com/commtech/fscc-linux/releases/tag/v2.2.1) (11/16/2012)
- Fixed a bug where X-Sync mode wasn't considered stream data if there wasn't any framing
- Fixed a data loss bug in transparent mode
- Improved debug prints

## [2.2.0](https://github.com/commtech/fscc-linux/releases/tag/v2.2.0) (10/09/2012)
- Added install option to Makefile
- Improve debug prints
- Fixed typos
- Include the gui, cli and pyfscc into the project
- Added some 'get' ioctls
- Added additional examples
- Rename flush{tx,rx} to purge{tx,rx}
- Update licenses
- Added fscc.rules file
- Fixed a bug causing the number of frames to be incorrect
- Added driver specific registers to sysfs when in debug mode
- Fixed an issue where a frame was left in the FIFO
- Optimize the memory consumtion while in streaming mode
- Fixed setting the clock on older green cards.

## [2.1.3](https://github.com/commtech/fscc-linux/releases/tag/v2.1.3) (02/06/2012)
- Fixed typos
- Remove sudo from install_tools
- Remove make all
- Added default transmit_modifiers
- Added tx_modifiers and ignore_timeout to sysfs
- Rearrange initialization code
- Use sema_init exclusively
- Clean up code
- See changesets for full list of changes

## [2.1.2](https://github.com/commtech/fscc-linux/releases/tag/v2.1.2) (09/14/2011)
- init_MUTEX(x) removed in 2.6.37, I replaced it with sema_init(x,1)

## [2.1.1](https://github.com/commtech/fscc-linux/releases/tag/v2.1.1) (07/19/2011)
- Fixed bug that caused the SuperFSCC/4-LVDS to not install correctly

## [2.1.0](https://github.com/commtech/fscc-linux/releases/tag/v2.1.0) (05/02/2011)
- Fixed comments in code
- Added make help target
- Migrate from google code to bitbucket
- Added code and examples for various transmit modes
- Fixed dma insmod parameter
- Added SuperFSCC-LVDS and SuperFSCC/104 to the driver
- See changesets for full list of changes

## [2.0.5](https://github.com/commtech/fscc-linux/releases/tag/v2.0.5) (02/17/2011)
- Added a force_fifo option that prevents DMA operation
- Added a simple example showing how to use the select() function to determine how much data is available in the card

## [2.0.4](https://github.com/commtech/fscc-linux/releases/tag/v2.0.4) (02/09/2011)
- Fixed a build error with kernels prior to 2.6.27 that used an older dma mapping function than we currently use
- Added a makefile command for removing the C headers
- Added a script to soft link against our sysfs directory
- Added a script to easily download related software
- Updated the README to address some confusing sections

## [2.0.3](https://github.com/commtech/fscc-linux/releases/tag/v2.0.3) (01/13/2011)
- Don't consider being in transparent mode as necessarily being streaming data

## [2.0.2](https://github.com/commtech/fscc-linux/releases/tag/v2.0.2) (01/12/2011)
- Synchronize version number of module with repo.

## [2.0.1](https://github.com/commtech/fscc-linux/releases/tag/v2.0.1) (01/12/2011)
- Added memory constraint checks when in transparent mode
- Use atomic memory allocation when in transparent mode

## [v2.0.0](https://github.com/commtech/fscc-linux/releases/tag/v2.0.0) (01/07/2011)
This is the initial release of the 2.0 driver series.

repository: commtech/fscc-linux

gha_language: C

repo_name: commtech/fscc-linux


text:
# Working with datasets

The implementation of dataset management within the MAO Orchestrator is based on git repositories. Datasets can be registered to the cluster, making them known to all members, and from that point on a member can clone them onto their system.

## Getting information

You can request a list of datasets, or information on a single dataset.

### CLI

```
python maoctl.py dataset get
```
```
python maoctl.py dataset get --name NAME
```

## Register a dataset

Registering a dataset creates a new entry in etcd, letting all cluster members know about the dataset.
### CLI

```
python maoctl.py dataset add --name NAME --git_url URL
```

## Un-register a dataset

Unregistering a dataset will remove it from etcd.
### CLI

```
python maoctl.py dataset remove --name NAME
```

## List local datasets
*currently unsupported*

List the datasets that have been cloned to the local filesystem.

### CLI

```
python maoctl.py dataset list-local
```
## Clone a registered dataset
*currently unsupported*

This will clone the specified dataset to the import directory set in the configuration file.

### CLI
```
python maoctl.py dataset clone <name>
```
## Delete a cloned dataset
*currently unsupported*

Delete a cloned dataset from the local filesystem.
### CLI
```
python maoctl.py dataset remove-local <name>
```


text:
cendot, `%.`, %cndt
============================

Slam, reverse order

`%.` is a synthetic rune that reverses the order of [`%-`](). `%.`
exists primarily for code readability and organization, see the [style
guide]().

Produces
--------

Twig: `[%cndt p=twig q=twig]`

Sample
------

`p` and `q` are [twig]()s.

Tall form
---------

    %.  p
        q

Wide form
---------

    %.(p q)

Irregular form
--------------

None

Examples
--------

    /~zod/try=> (dec 42)
    41
    ~zod/try=> %.(42 dec)
    41

In the most straightforward case `%.` allows us to reverse the order of
arm and arguments.

    /~zod/try=> %.
                  %+  add
                    %+  mul  2  20
                  2
                dec
    41

Here we add `2` to the product of `2` and `20`, and use `%.` to
decrement our result. As you can see, `%.` is most useful for code
organization, when you need to compute intermediate products for your
final result.

Equivalent to
-------------

    %-(q p)

repository: frodwith/urbit

repo_name: frodwith/urbit


text:
## CLI

NeurST provides various command line tools.

### Contents

* [`run_exp`: Train and evaluate](#train-and-evaluate)
* [`view_registry`: List registered classes and arguments](#list-registered-classes-and-arguments)
* [`view_tfrecord`: Examine a TFRecord file](#examine-a-tfrecord-file)
* [`inspect_checkpoint`: Inspect variables in a checkpoint](#inspect-variables-in-a-checkpoint)
* [`convert_checkpoint`: Convert a checkpoint from a well-trained model](#convert-a-checkpoint-from-a-well-trained-model)
* [`audio_tfrecord_analysis`: Analysis audio TFRecord dataset](#analysis-audio-tfrecord-dataset)

------

### Train and evaluate
See [examples/](/examples)

### List registered classes and arguments
This tool can list all registered classes (`Model`, `Task`, ...), their arguments and detailed explanation:

- to see user manual:
```bash
$ python3 -m neurst.cli.view_registry

Usage:
    >> python3 -m neurst.cli.view_registry registry_name
           Show registered classes and their aliases.

    >> python3 -m neurst.cli.view_registry registry_name class_name
           Show detailed parameters of the class.

All registry names:
    - criterion
    - metric
    - feature_extractor
    - data_pipeline
    - tokenizer
    - dataset
    - entry
    - base_layer
    - search_method
    - model
    - decoder
    - encoder
    - hparams_set
    - validator
    - optimizer
    - lr_schedule
    - task
```

- to list the registered tasks:
```bash
$ python3 -m neurst.cli.view_registry task

All registered task(s):
    |  Class  |  Aliases  |
    |  Seq2Seq  |  seq2_seq, Seq2Seq, seq2seq, seq_to_seq  |
    |  AudioToText  |  audio_to_text, audio2text, AudioToText, audiototext  |
```

- to see the detailed explanation of arguments for `Seq2Seq`:
```bash
$ python3 -m neurst.cli.view_registry task Seq2Seq

Flags for Seq2Seq:
    |  flag  |  type  |  default  |  help  |
    |  shuffle_buffer  |  <class 'int'>  |  0  |  The buffer size for dataset shuffle.  |
    |  batch_size  |  <class 'int'>  |  None  |  The number of samples per update.  |
    |  batch_size_per_gpu  |  <class 'int'>  |  None  |  The per-GPU batch size, that takes precedence of `batch_size`.  |
    |  cache_dataset  |  <class 'bool'>  |  None  |  Whether to cache the training data in memory.  |
    |  max_src_len  |  <class 'int'>  |  None  |  The maximum source length of training data.  |
    |  max_trg_len  |  <class 'int'>  |  None  |  The maximum target length of training data.  |
    |  truncate_src  |  <class 'bool'>  |  None  |  Whether to truncate source to max_src_len.  |
    |  truncate_trg  |  <class 'bool'>  |  None  |  Whether to truncate target to max_trg_len.  |
    |  batch_by_tokens  |  <class 'bool'>  |  None  |  Whether to batch the data by word tokens.  |
Dependent modules for Seq2Seq:
    |  name  |  module  |  help  |
    |  src_data_pipeline  |  data_pipeline  |  The source side data pipeline.  |
    |  trg_data_pipeline  |  data_pipeline  |  The target side data pipeline.  |
```

### Examine a TFRecord file
`view_tfrecord` can examine a TFRecord file by displaying one data sample and the element types.
```bash
$ python3 -m neurst.cli.view_tfrecord tests/examples/train-zh2en-tfrecords-00000-of-00004

features {
  feature {
    key: "feature"
    value {
      int64_list {
        value: 27
        value: 146
        ......
      }
    }
  }
  feature {
    key: "label"
    value {
      int64_list {
        value: 38
        value: 29
        ...
      }
    }
  }
}

elements: {
    "label": int64
    "feature": int64
}
```

### Inspect variables in a checkpoint
`inspect_checkpoint` can list all variable names and shapes in a TensorFLow checkpoint.

- to see the user manual:
```bash
$ python3 -m neurst.cli.inspect_checkpoint

Usage:
    >> python3 -m neurst.cli.inspect_checkpoint modeldir_or_checkpoint (--structured)
           List all variables and their shapes.

    >> python3 -m neurst.cli.inspect_checkpoint model_dir/checkpoint regular_expr
           List the variables and their shapes if the name matches the `regular_expr`.

    >> python3 -m neurst.cli.inspect_checkpoint model_dir/checkpoint var_name
           Print the variable tensor.
```

- to list all variables and shapes (a tiny transformer model):
```bash
$ python3 -m neurst.cli.inspect_checkpoint ./test_models

        variable name    shape
SequenceToSequence/TransformerDecoder/layer_0/encdec_attention_prepost_wrapper/encdec_attention/kv_transform/bias       [16]
SequenceToSequence/TransformerDecoder/layer_0/encdec_attention_prepost_wrapper/encdec_attention/kv_transform/kernel     [8, 16]
SequenceToSequence/TransformerDecoder/layer_0/encdec_attention_prepost_wrapper/encdec_attention/output_transform/bias   [8]
SequenceToSequence/TransformerDecoder/layer_0/encdec_attention_prepost_wrapper/encdec_attention/output_transform/kernel [8, 8]
SequenceToSequence/TransformerDecoder/layer_0/encdec_attention_prepost_wrapper/encdec_attention/q_transform/bias
......
```

- to list the specific variables (e.g. layer norm):
```bash
$ python3 -m neurst.cli.inspect_checkpoint ./test_models "/ln/"

        variable name (/ln/)     shape
SequenceToSequence/TransformerDecoder/layer_0/encdec_attention_prepost_wrapper/ln/beta  [8]
SequenceToSequence/TransformerDecoder/layer_0/encdec_attention_prepost_wrapper/ln/gamma [8]
SequenceToSequence/TransformerDecoder/layer_0/ffn_prepost_wrapper/ln/beta       [8]
SequenceToSequence/TransformerDecoder/layer_0/ffn_prepost_wrapper/ln/gamma      [8]
......
```

- to print the tensor (e.g. target embedding table)
```bash
$ python3 -m neurst.cli.inspect_checkpoint ./test_models "SequenceToSequence/target_symbol_modality_posenc_wrapper/target_symbol_modality/shared/weights"

Variable name: SequenceToSequence/target_symbol_modality_posenc_wrapper/target_symbol_modality/shared/weights
Tensor Shape: [164, 8]
Tensor Value:
[[-0.17575996  0.1493602  -0.18946414 ... -0.31306902  0.08493289
   0.23959549]
 [ 0.90474224 -0.609249    0.03951814 ...  0.35367873 -0.20142521
  -0.52413136]
 ...
 [-0.23102537 -0.21176471  0.00733235 ... -0.4419487   0.02791528
   0.37591913]]
```

### Convert a checkpoint from a well-trained model
`convert_checkpoint` can convert a well-trained model to neurst's checkpoint.

- to see the supported model names:
```bash
$ python3 -m neurst.cli.view_registry converter

All registered converter(s):
    |  Class  |  Aliases  |
    |  GoogleBert  |  googlebert, GoogleBert, google_bert  |
```

- to convert a publicly available `bert-base-uncased` model:
```bash
$ python3 -m neurst.cli.convert_checkpoint --model_name google_bert --from bert-base-uncased --to /path/to/save
```
or to convert a fairseq transformer model:
```bash
$ python3 -m neurst.cli.convert_checkpoint --model_name fairseq_transformer --from /path/to/transformer.pt --to /path/to/save
```

### Analysis audio TFRecord dataset
It will print the metadata of the audio dataset, i.e. the number of samples and the duration of all audio segments:
```bash
python3 -m neurst.cli.audio_tfrecord_analysis --data_path ... --feature_extractor fbank/float_identity ...
```

repository: ohlionel/Prune-Tune

repo_name: ohlionel/Prune-Tune


text:
# MiFare RT
A MiFare Classic library for Windows Phone 8.1, Windows Store 8.1 and Desktop apps

## Tijl Deneut --
Added two folders:
- Binary-Compiled-By-Tijl: Features .NET pre-built application that should work on Windows without setup
- mifclass_tools: Features C++ pre-built applications that should work on Windows without setup

## Hardware requirements

### Phone
You must have a Lumia 830 or newer device. Older devices do not have the chipset support for the low-level APDU access this library needs. This will not work on a Lumia 930 or any previous hardware, even after updating to 8.1.

This library contains a detection routine to determine if a device's NFC reader has a supported chipset.

You must enable the Proximity Capability and NFC Requirement.

### Windows Store 8.1
This will work in a Windows Store 8.1 app that is meant for enterprise distribution. It will not pass Store validation as it uses unsupported Win32 API calls (WinSCard.dll).

You must enable the Shared User Certificates capability to use this library. [I'm not totally sure why this particular capability controls access to WinSCard, but without it you get UnauthorizedAccess exceptions coming from the AppContainer.]

### Desktop
No special requirements.

### Tested desktop NFC readers
On the desktop, this library has been tested with the HID OMNIKEY 5x21 series readers and the HID OMNIKEY 5427 CK in CCID mode. It should work with other PC/SC compatible readers but if you find an issue please open up a bug.

## Samples
There are two sets of sample projects in this repo:

### MiFare Reader
This is in the `samples\MiFareReader.*` project directories. This project shows basic usage and will loop through the 16 sectors of a classic card to read whatever data the default keys will allow.

### Scenarios
A more advanced sample in the `samples\Scenarios.*` directories. This project shows atwo potential scenarios:

1.  A user provides a PIN used to protect some data on the card. An app can then authenticate a user against the card to read the stored data. This could be a generated secret known by a server as a surrogate/strong password.
2.  A ski lift ticket system where a cashier encodes the expiration date of the pass onto the card and a lift agent/gate validates the expiration date.

## Credits
This library is made possible by
- [NFC Smart Card Reader PC/SC Library](http://nfcsmartcardreader.codeplex.com/)
- [A .NET MiFare Helper Class](http://www.codeproject.com/Articles/144063/A-NET-MiFare-Helper-Class)
- NXP and HID's documentation
- PC/SC Working Group specs

## License
This library is licensed under the Apache 2.0 license.

repository: tijldeneut/MiFare

repo_name: tijldeneut/MiFare


text:
Serializer
==========

Introduction
------------
This library allows you to (de-)serialize data of any complexity. Currently, it supports XML, JSON, YAML and CSV (serialization only).
It is a fork of the popular JMS serializer.

It also provides you with a rich tool-set to adapt the output to your specific needs.

Built-in features include:

- (De-)serialize data of any complexity; circular references are handled gracefully.
- Supports many built-in PHP types (such as dates)
- Integrates with Doctrine ORM, et al.
- Supports versioning, e.g. for APIs
- Configurable via PHP, XML, YAML, annotations or PHP attributes

Installation
------------
This library can be easily installed via composer

```bash
$ composer require kcs/serializer
```

or just add it to your `composer.json` file directly.

Usage
-----
For standalone projects usage of the provided builder is encouraged

```php
$serializer = Kcs\Serializer\SerializerBuilder::create()->build();
$jsonContent = $serializer->serialize($data, 'json');
echo $jsonContent; // or return it in a Response
```

Or you can use the included symfony bundle

```php
new \Kcs\Serializer\Bundle\SerializerBundle();
```

Documentation
-------------

- [Configuration](./configuration.md)
- [Usage](./usage.md)
- [Events](./event_system.md)
- [Handlers](./handlers.md)

- Recipes
    * [Exclusion strategy](./cookbook/exclusion_strategies.md)

- Reference
    * [PHP Attributes](./reference/php_attributes.md)
    * [Annotations](./reference/annotations.md)
    * [XML Reference](./reference/xml_reference.md)
    * [YAML Reference](./reference/yml_reference.md)

License
-------

The code is released under the business-friendly `MIT license`.

repository: alekitto/serializer

gha_language: PHP

repo_name: alekitto/serializer


text:
# Order theory :: Index of order structures

https://en.wikipedia.org/wiki/List_of_order_structures_in_mathematics

- Cyclic orders
- Lattices
- Partially ordered sets (posets)
- Preorders
- Semiorders
- Total orders
- Weak orders
- Well-orders
- Well-quasi-orderings

## Types of ordered sets in order theory

* *Cyclic orders*: orderings in which triples of elements are either clockwise or counterclockwise.

* *Lattices*: partial orders in which each pair of elements has a greatest lower bound and a least upper bound. Many different types of lattice have been studied; see map of lattices for a list.

* *Complete lattice*: is a partially ordered set in which all subsets have both a supremum (join) and an infimum (meet).

* *Partially ordered sets* (posets): orderings in which some pairs are comparable and others might not be.

* *Preorders*: a generalization of partial orders allowing ties (represented as equivalences and distinct from incomparabilities).

* *Semiorders*: partial orders determined by comparison of numerical values, in which values that are too close to each other are incomparable; a subfamily of partial orders with certain restrictions.

* *Total orders*: orderings that specify, for every two distinct elements, which one is less than the other.

* *Weak orders*: generalizations of total orders allowing ties (represented either as equivalences or, in strict weak orders, as transitive incomparabilities).

* *Well-orders*: total orders in which every non-empty subset has a least element.

* *Well-quasi-orderings*: a class of preorders generalizing the well-orders.

license: Unlicense


text:
# componentPod

[![CI Status](http://img.shields.io/travis/wanjj8023/componentPod.svg?style=flat)](https://travis-ci.org/wanjj8023/componentPod)
[![Version](https://img.shields.io/cocoapods/v/componentPod.svg?style=flat)](http://cocoapods.org/pods/componentPod)
[![License](https://img.shields.io/cocoapods/l/componentPod.svg?style=flat)](http://cocoapods.org/pods/componentPod)
[![Platform](https://img.shields.io/cocoapods/p/componentPod.svg?style=flat)](http://cocoapods.org/pods/componentPod)

## Example

To run the example project, clone the repo, and run `pod install` from the Example directory first.

## Requirements

## Installation

componentPod is available through [CocoaPods](http://cocoapods.org). To install
it, simply add the following line to your Podfile:

```ruby
pod 'componentPod'
```

## Author

wanjj8023<EMAIL_ADDRESS>
## License

componentPod is available under the MIT license. See the LICENSE file for more info.