text:
# Agile Data UnionModel

In many cases report would have to contain data from multiple models. I'll use the following example:

### Example I'll be using

In my model scheam, Client may have multiple invoices and multiple payments. Payment is not related to the invoice.

``` php
class Client extends \atk4\data\Model {
  public $table = 'client';

  function init() {
  	parent::init();
      $this->addField('name');

      $this->hasMany('Payment');
      $this->hasMany('Invoice');
  }
}
```

(see tests/Client.php, tests/Payment.php and tests/Invoice.php files).

## Define a Union Model

Normally model is associated with a single table. UnionModel can have multiple nested models defined and it draws results from that. As a result, UnionModel will have no "id" field. Inside the init() body of UnionModel define:

``` php
$m_uni = new \atk4\report\UnionModel();

$m_pay = $m_uni->addNestedModel(new Invoice());
$m_inv = $m_uni->addNestedModel(new Payment());
```

Next, assuming that both models have a commont fields "name" and "amount", use this:

``` php
$m_uni->addField('name');
$m_uni->addFiled('amount', ['type'=>'money']);
```

Finally you can query data:

``` php
var_dump($m_uni->export());
```

## Types of Union Model fields

Let's look at 3 different ways to define fields for Union Model

``` php
// Will link the "name" field will all the nested models.
$m_uni->addField('client_id');

// Expression will not affect nested models in any way
$m_uni->addExpression('name_capital','upper([name])');

// Union model can be joined with extra tables and define
// some fields from those joins
$m_uni->join('client','client_id')
  ->addField('client_name', 'name');
```

Expressions and Joins are working just as they would on any other model, so refer to main documentation of Agile Data:

-   http://agile-data.readthedocs.io/en/develop/expressions.html
-   http://agile-data.readthedocs.io/en/develop/joins.html

## Field Mapping

Sometimes, the field you define may be named differently inside nested model. For instance, Invoice has field "description". Payment has field "note". When defining a nested model, you can specify field mapping:

``` php
$m_pay = $m_uni->addNestedModel(new Invoice());
$m_inv = $m_uni->addNestedModel(new Payment(), ['description'=>'[note]']);
$m_uni -> addField('description');
```

The left side of the mapping array must match the Union field. The right side is an expression. (See Model::addExpression()). This format can also be used to reverse sign on amounts. When we are creating "Transactions", then invoices would have a negative impact on the amount, while payments have a positive impact:

``` php
$m_pay = $m_uni->addNestedModel(new Invoice(), ['amount'=>'-[amount]']);
$m_inv = $m_uni->addNestedModel(new Payment(), ['description'=>'[note]']);
```

Should you need more flexibility, remember that you can add more expressions (or fields) directly inside nested models at this stage:

``` php
$m_pay = $m_uni->addNestedModel(new Invoice(), ['amount'=>'-[amount]']);
$m_inv = $m_uni->addNestedModel(new Payment(), ['description'=>'[note]']);

$m_pay->addExpression('type', '"payment"');
$m_inv->addExpression('type', '"invoice"');
$m_uni->addField('type');
```

I have defined a new column "type" that will be defined as a static constant. Again, this may differ from between nested models.

## Referencing a Union Model

Like any other model, you can assign Union model through a reference. In our case one Client can have multiple transactions. For a start, let's define a related union:

``` php
$client->hasMany('Transaction', new Transaction());
```

When condition is added on a UnionModel it will send it down to the every nested model. This way your SQL query remains most efficient.

The exception is of course when field is not mapped to nested model (if it's an expression or associated with a join).

In most cases you do not have to worry about optimizing your query and ModelUnion will simply work.

## Grouping Results

ModelUnion has a built-in grouping support.

``` php
$m_uni->groupBy('client_id', ['amount'=>'sum']);
```

When specifying a field to be used for grouping, if the field is associated with nested models, then grouping will be enabled on every nested model.

Report extension contains collection of various tools that can make data aggrigation in Agile Data simpler. We will continue to add more report-related functionality for this extension, so if you can think of any new ideas on what you would like to see here, please share with our developent team.

## Aggregate Extension

Aggregate adds few new actions which you can use:

### Grouping

``` php
$orders->add(new \atk4\report\Aggregate());

$aggregate = $orders->action('group');
```

$aggregate above will return a new object that's most appropriate for your persistence and which can be manipulated in various ways to fine-tune aggregation. Below is one sample use:

``` php
$aggregate = $orders->action(
  'group',
  'country_id',
  [
    'country',
    'count'=>'count',
    'total_amount'=>['sum', 'amount']
  ],
);

foreach($aggregate as $row) {
  var_dump(json_encode($row));
  // ['country'=>'UK', 'count'=>20, 'total_amount'=>123.20];
  // ..
}
```

Here is how we can build opening balance:

``` php
$ledger = new Report_Ledger($db);
$ledger->addCondition('date', '<', $from);

// we actually need grouping by nominal
$ledger->add(new \atk4\report\Aggregate());
$by_nominal = $ledger->action('group', 'nominal_id');
$by_nominal->addField('opening_balance', ['sum', 'amount']);
$by_nominal->join()

```

## Union Model

Regular model are capable of reading and updating records.

## Aggregate Extension

Audit Extension provides a mechanism to store all changes that happen during persistance of your model. This extension is designed to be extensive and flexible. Use Audit if you need to track changes performed by your users in great detail.

Audit supports a wide varietty of additional features such as ability to **undo** actions, record actions that have **failed** to execute (due to validation) along with the error, **retry** failed actions, retrieve **historical** records without modifying database, log **custom** actions and even **replay** all actions. Audit also records which **field values** were changed inside a model before executing `save()` and which fields were changed **reactively** (through other hooks) and will track and link reactive modifications to **multiple models**.

Huge focus on extensibility allow you to **customise** name of log table, change field names, database **engine** (e.g. store in CSV file, API or Cloud Database), **switch off** certain features, customise **human-readable** log entries and add additional information about **user**, **session** or **environment**.

(See also - [Full Example](full-example.md))

## Enabling Audit Log

To enable extension for your model, add the following line into Model's method `init`:

``` php
$this->add(new \atk4\audit\Controller());
```

For a basic usage you will also need to create `audit_log` table by importing `audit_log.sql` file. The audit-log is automatically populated when you perform an operation with the model next time:

``` php
$m->load(1);
$m['name'] = 'Ken'; // was Vinny before
$m->save();
```

The following new record will be stored inside `audit_log` table:

``` json
{
   "id":1,
   "initiator_audit_log_id":null,
   "ts":{
      "date":"2016-10-03 21:44:14.000000",
      "timezone_type":3,
      "timezone":"UTC"
   },
   "model":"atk4\\ui\\tests\\AuditableUser",
   "model_id":"1",
   "action":"update",
   "time_taken":0.00174,
   "descr":"update name=Ken",
   "user_info":null,
   "request_diff":{
      "name":[
         "Vinny",
         "Ken"
      ]
   },
   "reactive_diff":null,
   "is_reverted":null,
   "revert_audit_log_id":null
}
```

Here are some more advanced topics:

-   [Enable AuditLog for all your Models](system-wide.md)
-   [Configure which fields are logged](field-config.md)
-   [Custom event logging and customizing](custom.md)
-   [Various storage options](storage.md)

## Working With the Log Entries

Your model contains reference to AuditLog model. Let's see how many times the above record have been modified in the past:

``` php
echo $m->load(1)->ref('AuditLog')->action('count')->getOne();  // 1
```

You can also use it to access records individually or just access last record:

``` php
$m->load(1)->ref('AuditLog')->loadLast()->undo(); // revert last action
```

If you wish to undo all the actions for specific record, run:

```php
$yesterday = new DateTime();
$yesterday->sub(new DateInterval('P1D'));

$m->load(1)->ref('AuditLog')
    ->addCondition('date', '>=', $yesterday)
    ->addCondition('is_reverted')
    ->each('undo');
    // revert all actions, that have happened today
    // but exclude those that have been reverted already
```

More in depth:

-   [How does undo() and redo() work](undo.md)
-   [Recording sequences for your unit-tests](unit-tests.md)
-   [Fetching historical records](historical.md)

## Requested and Reactive field changes

AuditLog extension records fields that were `dirty` before execution of save() operation. Sometimes you would have a logic inside your model hooks that can change more records or even change other models. For example if you change `InvoiceLine` amount it might want to update amount of `Inovice` too.

## Requested vs Reactive actions

Agile Data incorporates rich volume of logic that allow you to make a lot of decision across the system when even a smallest change is requested. For example assuming you have the following structure:

-   Invoice
    -   `addFields(['total_net', 'total_vat', 'total_gross'], ['type' => 'money']);`
    -   `hasMany('Line')`
        -   `addField('qty', ['type => 'int'])`
        -   `addField('vat_rate', ['type' => 'float'])`
        -   `addFields(['price', 'vat', 'net', 'gross'], ['type' => 'money']);`

Your `afterSave` hooks will automatically recalculate and update `Invoice` whenever you change the `Line`. Additionally, changing `qty` will trigger change in `vat`, `net` and `gross`.

Looking at he following code:

``` php
$m = new Invoice($db);
$m->load(1);
$m['qty']++;
$m->save();
```

Only a single field falls into "requested" change, which is `qty`. The original value and a new value will be stored in JSON:

``` json
{"qty": [5, 6]}
```

However due to hooks, many other values have also been updated. For the Line the "reactive" changes are:

``` json
{"net": [50, 60], "vat": [11.5, 13.8], "gross": [51.5, 63.8]}
```

Then you have some "reactive" changes for the `Invoice` model too:

``` php
{"total_net": [100, 110], "total_vat": [23.0, 25.3], "total_gross": [123.0, 135.3]}
```

The default way for Audit Log is to store only "reactive" changes, however you can enable storing of both "requested" and "reactivte":

``` php
$audit = new \atk4\audit\Controller([
    new Audit(),
    ['requested_log' => true, 'reactive_log' => true, 'link' => true]
);
```

The option for `nested` will also associate changes inside `Invoice` with the requested changes of `Line`. If you need to customise settings on per-model basis, you should create individual controllers.

## How values are stored?

Audit Extension uses array persistence to prepare values for storage inside JSON. If you need to tweak how values are stored exactly, you shourd refer to documentation on [typecasting](http://agile-data.readthedocs.io/en/develop/persistence.html?highlight=typecasting#type-converting).

System is storing using business-domain field names. If "net" has an actual field of "sql_net", then audit will store "net". Additionally

## Undo and Replay features

Agile Audit Extension perform a strict type auditing which can be quite useful for automation. Certain actions can be "undone" or "replayed" (Redo).

Those action can be performed on the `Audit` model after you load the record:

``` php
$audit->load(20);
$audit->replay();
```

Assuming that audit log with ID=20 corresponds to the `qty` modifications as I was explaining above, the replay will perform the following:

-   start transaction
-   load model for `Line`
-   perform modification of `qty`
-   save value of `qty`
-   track changed fields in `Line` and `Invoice`
-   assert to make sure all the same reactive changes happened
-   commit

Similarly you can also call `undo()`, which will:

-   Reverse all `new` / `old` values for original Audit event and all related ones
-   Attempts to apply the replay()

Both `Undo` and `Replay` functionality can bypass the verification steps or can actually enforce `Reactive` changes to be used. Those modes are less safe but if that's what you want you can try it.

Finally, Replay feature can also override `id` of the original model. In this scenario changes will be re-applied to a different record.

### When Undo and Replay are useful?

Undo can be offered to a user as an option. Because implementation of `Undo` especially in transaction-supporting database is pretty safe, you can execute multiple `Undo` actions effectively allowing you to walk between revisions of your persistence.

``` php
$audit = new Audit($db);
$audit->addCondition('user_id', $this->app->user->id);
$audit->addCondition('date', '>', $unroll_to_date);
$audit->setOrder('id desc');
$audit->each('undo');
```

Applying `Replay` on the range of entries makes a pretty effective multi-record update technique.

```php
$invoices = $client->ref('Invoice'); // references multiple invoices
$invoices->add($audit);

// record action
$invoices->loadAny();
$invoices->save( $new_data );

$audit->last_action->applyOnOthers($invoices);
```

Finally, replay can be used in creating unit tests. If you have enabled Audit Log for your application and have already performed some actions, you can generate  `PHPUnit`-compatible code through Admin Audit Page.

## Admin Page

Audit Extension comes with [Agile UI](https://github.com/atk4/ui) based page that contains a handy management console where you can browse all the recent events, convert them into unit-tests, undo or re-apply some of those. Additionally selecting an event will also show you all the "Reactive" actions that have been done.

![data-audit-1-console](images/data-audit-1-console.png)

## Download and Install

Audit Extension is currently in Beta. You need to contact us if you wish to get early access.

branch_name: refs/heads/develop

gha_language: PHP


text:
# PandoRdio

![branding](http://f.cl.ly/items/2T3k0j2z2R3G2j1D2t3N/pandordio.png)

This is a Google Chrome Extension that will add a song to your Rdio
Collection when you "Thumbs Up" on Pandora.

## Installation

[The Chrome Web Store][1]

[1]: https://chrome.google.com/webstore/detail/fiobjnnhnijfdkgdmedcbennfngfnfff

license: MIT

repository: donnierayjones/pandordio-chrome

branch_name: refs/heads/master

extension: markdown

license_type: permissive

repo_name: donnierayjones/pandordio-chrome


text:
# Features

## Contents

  * [toArray](#toarray)
  * [Queryable and Extendable](#queryable-and-extendable)
  * [Functions](#functions)
  * [Actions](#actions)
  * [Actions.doNothing()](#actionsdonothing)
  * [SimpleLogger.logToNothing()](#simpleloggerlogtonothing)
  * [NullLogger](#nulllogger)
  * [ArrayUtils.addToArray()](#arrayutilsaddtoarray)

## toArray
see [ArrayUtils.toArray](ArrayUtils.md#toArray)
## Queryable and Extendable
see [Query](how_to/ExtendQueryable.md#top) a group of map-reduce functions based on the linq (sql) syntax.

## Functions

Function0 through Function9 are single method interfaces for use with lambdas where you take 0-9 parameters and return a result.
For Example Function3 has the single method :

```java
public Out call(In1 a, In2 b, In3 c);
```
snippet source | anchor

The first 3 have native java equivalents (that are hard to remember).
If it is preferred to use those, but can't remember their name, they are listed in the javadocs.

```
   Function0 -> java.util.function.Supplier
   Function1 -> java.util.function.Function
   Function2 -> java.util.function.BiFunction
```
## Actions

Action0 through Action9 are single method interfaces for use with lambdas where you take 0-9 parameters and all results are via side-effect (void return).

For Example Action3 has the single method:

```java
public void call(In1 a, In2 b, In3 c);
```
snippet source | anchor

The first 3 have native java equivalents (that are hard to remember).
If it is preferred to use those, but can't remember their name, they are listed in the javadocs.

```
   Action0 -> java.lang.Runnable
   Action1 -> java.util.function.Consumer
   Action2 -> java.util.function.BiConsumer
```

## Actions.doNothing()

Action0 thru Action9 all have an implementation of the null object pattern for your convenience.

## SimpleLogger.logToNothing()
 see [SimpleLogger.logToNothing()](reference/SimpleLogger.md#simpleloggerlogtonothing)

## NullLogger

Null Object Pattern for java.lang.Appendable

## ArrayUtils.addToArray()

Sometimes you wish you could add to an array the same way you can add to a list.

```java
Integer[] numbers = {1, 2, 3};
numbers = ArrayUtils.addToArray(numbers, 4, 5, 6);
```
snippet source | anchor

will result in a new copy of the array with the added items

```java
Integer[] resulting = {1, 2, 3, 4, 5, 6};
```
snippet source | anchor

[Back to User Guide](README.md#top)

extension: md

gha_language: Java


text:
> Dear participants, for the final due diligence on your submission, please use the below README format to describe your submission. We also encourage you to add useful comments in your code to help streamline the review process.

# Submission

## Submission Summary

* Submission ID: XXXXX
* Submitter: XXXXX
* Final rank: Xth place on leaderboard X
* Final scores on MDXDB21:

  | SDR_song | SDR_bass | SDR_drums | SDR_other | SDR_vocals |
  | :---:    | :---:    | :---:     | :---:     | :---:      |
  | X.XX     | X.XX     | X.XX      | X.XX      | X.XX       |

## Model Summary

Please describe here your approach, including
* the model that you used
  (please cite relevant references, e.g., [1] if you use open-unmix)
* the training and validation dataset you used
* hyperparameters that you tuned
  (e.g., blending strength for system that blends two models)

[1] Stöter, Fabian-Robert, et al. "Open-unmix-a reference implementation for
    music source separation." Journal of Open Source Software 4.41 (2019): 1667.

# Reproduction

## How to reproduce the submission

Please describe here how your submission can be reproduced.

## How to reproduce the training

Please describe here how your model could be trained.


text:
---
layout: page
title: "Self in Ruby"
description: "Meaning and use of self in Ruby"
tags: ['Ruby']
---

`Self` in Ruby has the same meaning as in our daily dictionary - the object of introspection i.e. Oneself. A more technical definition would be -
 `Self` gives you access to the current object in a program.

The `self` keyword is a very interesting concept in Ruby. It is globally accessible and always returns the current object to you. At the topmost level, when `self` is used outside of any class or method , it will always return Main. Lets see what are the basic uses of `self` in Ruby.

### When defined inside a class

Whenever `self` is used inside a class and outside any of its methods, it simply points to that particular class.

~~~ Ruby
class Ruby
  puts self
end
~~~

This use of `self` will return `Ruby` as expected i.e the class name.

### When defined inside a method
Whenever `self` is used inside a method, it will always point to the object that the method is called upon.

~~~ ruby
class Ruby
 def check
  puts self
 end
end
~~~
~~~ ruby
obj = Ruby.new
puts obj
puts obj.check
~~~

Both the commands will return

~~~ ruby
#<Ruby:0x007fa8128525e8>
~~~
 i.e. the value of the instance obj.

### To define class methods (Singleton methods)

Singleton methods are those methods which can be called only by a single object which owns that method. For a method defined in a class ,the calling object will always be the class.

~~~ ruby
class GameOfThrones
 def self.amaze
   puts “GoT is amazing”
 end
end
~~~

The method `amaze` will be called only by using the class `GameOfThrones`. You can try it yourself.
simply calling amaze  will return :

~~~ ruby
NameError: undefined local variable or method 'amaze' for main:Object
~~~

while calling the same method using the class name will give you the
desired output.

~~~ ruby
GameOfThrones.amaze
~~~

will return

~~~ ruby
GoT is amazing
~~~

### To define a singleton class
A more advanced way to make a bunch of methods use the class instance only is as follows

~~~ ruby
class GameOfThrones
  class<<self
    def daenerys
      puts “Daenerys is the mother of Dragons ”
    end
    def starks
      puts “Starks are attracted to death”
   end
 end
end
~~~

~~~ ruby
GameOfThrones.starks
~~~
 will return

~~~ Ruby
Starks are attracted to death
~~~

and

~~~ ruby
starks
~~~
 will give an error . Similar concept is for the other method. Try it by yourself to know better.


text:
# UpsertCatalogObjectRequest
> squareconnect.models.upsert_catalog_object_request

### Description

## Properties
Name | Type | Description | Notes
------------ | ------------- | ------------- | -------------
**idempotency_key** | **str** | A value you specify that uniquely identifies this request among all your requests. A common way to create a valid idempotency key is to use a Universally unique identifier (UUID).  If you're unsure whether a particular request was successful, you can reattempt it with the same idempotency key without worrying about creating duplicate objects.  See [Idempotency](/basics/api101/idempotency) for more information. |
**object** | [**CatalogObject**](CatalogObject.md) | A [CatalogObject](#type-catalogobject) to be created or updated. - For updates, the object must be active (the `is_deleted` field is not `true`). - For creates, the object ID must start with `#`. The provided ID is replaced with a server-generated ID. |

[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)

repository: square/connect-python-sdk

gha_language: Python

repo_name: square/connect-python-sdk


text:
# Contributing to Nebular

We would love for you to contribute to Nebular and help make it ever better together! :rocket:

- [Code of Conduct](#coc)
- [Question or Problem?](#question)
- [Issues and Bugs](#issue)
- [Feature Requests](#feature)
- [Submission Guidelines](#submit-pr)
- [Framework Structure](#framework-structure)
- [Coding Rules](#rules)
- [New Feature Checklist](#new-feature-checklist)
- [Commit Message Guidelines](#commit)

##  Code of Conduct

Help us keep Nebular open and inclusive. Please read and follow our [Code of Conduct][coc].

##  Got a Question or Problem?

Please do not open issues for general support questions as we want to keep GitHub issues for bug reports and feature requests. You've got much better chances of getting your question answered on [StackOverflow][stackoverflow] where the questions should be tagged with tag `nebular`.

StackOverflow is a much better place to ask questions since:

- there are thousands of people willing to help on StackOverflow
- questions and answers stay available for public viewing so your question / answer might help someone else
- StackOverflow's voting system assures that the best answers are prominently visible.

To save your and our time, we will be systematically closing all the issues that are requests for general support and redirecting people to StackOverflow.

##  Found an Issue?

If you find a bug in the source code or a mistake in the documentation, you can help us by
[submitting an issue](#submit-issue) to our [GitHub Repository][github]. Including an issue
reproduction (via CodePen, JsBin, Plunkr, GitHub repo, etc.) is the absolute best way to help the team quickly
diagnose the problem. Screenshots and error stack traces are also helpful.

Please follow this simple checklist before submitting:

- If you have a question about using Nebular, please ask on the [StackOverflow][stackoverflow].

- It is required that you clearly describe the steps necessary to reproduce the issue you are running into. Although we would love to help our users as much as possible, diagnosing issues without clear reproduction steps is extremely time-consuming and simply not sustainable.

- The issue list of this repository is exclusively for bug reports and feature requests. Non-conforming issues will be closed immediately.

- Issues with no clear steps to reproduce will not be triaged. If an issue is labeled with "needs info" and receives no further replies from the author of the issue for more than 5 days, it will be closed.

- If you think you have found a bug, or have a new feature idea, please start by making sure it hasn't already been [reported][issues]. You can search through existing issues to see if there is a similar one reported. Include closed issues as it may have been closed with a solution.

- Next, [create a new issue](#submit-issue) that thoroughly explains the problem. Please fill out the populated issue form before submitting the issue.

##  Want a Feature?

You can _request_ a new feature by [submitting an issue](#submit-issue) to our [GitHub
Repository][github]. If you would like to _implement_ a new feature, please submit an issue with
a proposal for your work first, to be sure that we can use it.
Please consider what kind of change it is:

- For a **Major Feature**, first open an issue and outline your proposal so that it can be
  discussed. This will also allow us to better coordinate our efforts, prevent duplication of work,
  and help you to craft the change so that it is successfully accepted into the project.
- **Small Features** can be crafted and directly [submitted as a Pull Request](#submit-pr).

###  Submitting an Issue

Before you submit an issue, search the archive, maybe your question was already answered.

If your issue appears to be a bug, and hasn't been reported, open a new issue.
Help us to maximize the effort we can spend fixing issues and adding new
features by not reporting duplicate issues. Please make sure to fill out the populated issue form before submitting the issue.

You can file new issues by providing the information [here][new_issue].

###  Submitting a Pull Request (PR)

Before you submit your Pull Request (PR) consider the following guidelines:

- Search [GitHub][pulls] for an open or closed PR
  that relates to your submission. You don't want to duplicate effort.
- Make your changes in a new git branch:

  ```shell
  git checkout -b my-fix-branch master
  ```

- Create your patch, **including appropriate test cases**.
- Follow our [Coding Rules](#rules).
- Test your changes with our supported browsers.
- Commit your changes using a descriptive commit message that follows our
  [commit message conventions](#commit). Adherence to these conventions
  is necessary because release notes are automatically generated from these messages.

  ```shell
  git commit -a
  ```

  Note: the optional commit `-a` command line option will automatically "add" and "rm" edited files.

- Push your branch to GitHub:

  ```shell
  git push my-fork my-fix-branch
  ```

- In GitHub, send a pull request to `nebular:master`.

That's it! Thank you for your contribution!

##  Framework Structure

- docs - Documentation and framework website built on top on the framework
- src
  - app - runner app for components playground
  - playground - independent module with runnable examples for each feature
  - backend - Small backend example
  - framework - Framework itself, divided into npm packages
    - theme - `@nebular/theme` npm package, main framework package
    - auth - `@nebular/auth` npm package, auth package (login, register, etc)
    - security - `@nebular/security` npm package, security framework package

##  Coding Rules

To ensure consistency throughout the source code, keep these rules in mind as you are working:

- All features or bug fixes **must be tested** by one or more specs (unit-tests).
- All public API methods **must be documented** following JsDoc notation.
- Never forget [document your changes add create some examples](#documentation)
- Create playground page per each new component/feature

##  New Feature Checklist

- lint checks are passing
- tests are added/updated and passing
- showcase in the playground updated
- Styles variables added/updated
- tsdocs added/updated
- commit message is properly formatted
- for the override styles - registered in a list of overrides
- component \*.theme registered in a list of component themes
- looks great on all default themes
- supports bidirectionality
- requires approval from several core team contributors

##  Commit Message Guidelines

We have very precise rules over how our git commit messages can be formatted. This leads to **more
readable messages** that are easy to follow when looking through the **project history**. But also,
we use the git commit messages to **generate the Nebular change log**.

### Commit Message Format

Each commit message consists of a **header**, a **body** and a **footer**. The header has a special
format that includes a **type**, a **scope** and a **subject**:

```
<type>(<scope>): <subject>
<BLANK LINE>
<body>
<BLANK LINE>
<footer>
```

The **header** is mandatory and the **scope** of the header is optional.

Any line of the commit message cannot be longer 100 characters! This allows the message to be easier
to read on GitHub as well as in various git tools.

### Revert

If the commit reverts a previous commit, it should begin with `revert: `, followed by the header of
the reverted commit. In the body it should say: `This reverts commit <hash>.`, where the hash is
the SHA of the commit being reverted.

### Type

Must be one of the following:

- **feat**: A new feature
- **fix**: A bug fix
- **docs**: Documentation only changes
- **style**: Changes that do not affect the meaning of the code (white-space, formatting, missing
  semi-colons, etc)
- **refactor**: A code change that neither fixes a bug nor adds a feature
- **perf**: A code change that improves performance
- **test**: Adding missing tests or correcting existing tests
- **build**: Changes that affect the build system, CI configuration or external dependencies
  (example scopes: gulp, broccoli, npm)
- **chore**: Other changes that don't modify `src` or `test` files
- **release**: Release version commit

### Scope

The scope could be anything specifying place of the commit change. For example
`menu`, `sidebar`, etc.

### Subject

The subject contains succinct description of the change:

- use the imperative, present tense: "change" not "changed" nor "changes"
- don't capitalize first letter
- no dot (.) at the end

### Body

Optional. Just as in the **subject**, use the imperative, present tense: "change" not "changed" nor "changes".
The body should include the motivation for the change and contrast this with previous behavior.

### Footer

Optional. The footer should contain any information about **Breaking Changes** and is also the place to
reference GitHub issues that this commit **Closes**.

**Breaking Changes** should start with the word `BREAKING CHANGE:` with a space or two newlines.
The rest of the commit message is then used for this.

[coc]: CODE_OF_CONDUCT.md
[github]: https://github.com/akveo/nebular
[stackoverflow]: https://stackoverflow.com/questions/tagged/nebular
[issues]: https://github.com/akveo/nebular/issues
[new_issue]: https://github.com/akveo/nebular/issues/new
[pulls]: https://github.com/akveo/nebular/pulls

repository: akveo/nebular

gha_language: TypeScript

gha_license_id: MIT

repo_name: akveo/nebular


text:
# General notes

- Docs are available in [HTML](https://api.commoncrypto.dev) and [Markdown](https://api.commoncrypto.dev/md)
- API runs at [https://api.commoncrypto.dev](https://api.commoncrypto.dev)
- Rate limit is 100 requests per second

# API documentation

### Get `/exchanges`

Returns a list of all exchanges as an array of strings.

### Get `/pairs/:exchange`

Returns a list of all pairs for the given exchange as an array of strings.

### Get `/tickers/:exchange`

Returns all tickers for the given exchange.

### Get `/ticker/:exchange/:pair`

Returns the ticker for the given exchange and pair. Pair format is `CURRENCYCURRENCY` like `BTCUSD`.

repository: Borodutch/commoncrypto-backend

branch_name: refs/heads/main

repo_name: Borodutch/commoncrypto-backend


text:
# Spring-Boot Camel Demo

This example demonstrates how you can use Apache Camel Spring XML with Spring Boot.

In this example, a fictitious workflow is dempnstrated whereby an email, having an excel spreadsheet attachment is sent to an email account. The email attachment (excel spreadsheet) contains JiraIDs which will be used to query a fictitious Jira API for a list of issues to create a report.

A route using the Mail component, polls the configured email account for unread emails having the subject 'Jira Issues'.  The route invokes a processor (MailAttachmentProcessor) which looks for an attachment and if one exists, it's saved to a file in the files/inbox folder as whatever file name was given to the attachment.

A second route uses the File component which polls the files/inbox folder for specific file extensions (*.xlxs).  If a file with this extension exists, it's picked up, processed and deleted.  Processing is done by invoking a processor bean that uses the Apache POI library to parse the excel file and pull out the list of Jira IDs and return them in an outbound exchange header. Conditional logic routes the message (containing the Jira ID header) to another route if the JiraID header is not empty.

A third route which is invoked directly from the second route, calls an external mocked API using the HTTP4 component, passing the JiraIDs.  The JSON response from the API is unmarshaled to a list of JiraIssue pojos which is split using the Splitter EIP pattern and persisted via JPA to an in-memory H2 database table (Issues) with a status set to 'P' (processed).

A fourth route uses a timer based JPA consumer to poll the Issues table for records having a status of 'P' (processed) and using an aggregation strategy (ArrayList), combines the records into a list of JiraIssue pojos and updates the status in the database to 'D' delivered.  The list of JiraIssue pojos is passed to a processor (IssueReportProcessor) that uses the Apache POI library to build a word (.docx) document report named JiraIssueReport.docx and places a file in the files/outbox folder.

A fifth and final route polls the files/outbox folder for files having the *.docx extension, generates an email and sends it along with the attached report to a configured email account.

The demo uses several camel components (Mail, File, HTTP4, JPA) to access local and external resources along with several EIP patterns (Splitter and Aggregator.

### Building

The example can be built with

    mvn clean install

### Running the example locally
The example can be run locally with

    mvn spring-boot:run


text:
# Tomodachi-Life-Save-Editor

![Tomodachi Llife SE main](https://i11.servimg.com/u/f11/19/11/94/79/tl_sav10.png)

# How to use :
- Extract your save with a homebrew (JK's Save Manager or other)
- Open savedataArc.txt, edit
- Re-import your save with a homebrew (JK's Save Manager or other)

# Features :
- Edit problems solved, StreetPass encounters, weddings, Island's name, money, and other things
- Edit Mii ( Name, Last name, level, experience, and other)
- Unlock all items (Interiors, Special foods, clothes, ...) by numbers or by shop catalog
- Repair save file if something wrong is used
- Remove time travel penality
- Reset StreetPass/SpotPass
- Edit island's buildings

# Releases :
https://github.com/Brionjv/Tomodachi-Life-Save-Editor/releases

repository: Quacemon/Tomodachi-Life-Save-Editor

repo_name: Quacemon/Tomodachi-Life-Save-Editor


text:
# Counter React App

**Author** Peter Cole
**Version** 1.0.4

## Overview

- Create a vanilla React app that increments a number rendered to the DOM with increment/decrement buttons
- Display intuitive css changes as the number is manipulated

## Developer Notes

- Developed using `yarn`
- This project was bootstrapped with [Create React App](https://github.com/facebook/create-react-app).


text:
# uiufsi

<!--- See https://shields.io for others or to customize this set of shields.  --->
![GitHub language count](https://img.shields.io/github/languages/count/ssabit/uiufsi?style=flat-square)
![GitHub top language](https://img.shields.io/github/languages/top/ssabit/uiufsi?style=flat-square)
![GitHub contributors](https://img.shields.io/github/contributors/ssabit/uiufsi?style=flat-square)
![GitHub last commit](https://img.shields.io/github/last-commit/ssabit/uiufsi?color=red&style=flat-square)
![GitHub license](https://img.shields.io/github/license/ssabit/uiufsi?style=flat-square)
![GitHub repo size](https://img.shields.io/github/repo-size/ssabit/uiufsi?style=flat-square)
![GitHub code size in bytes](https://img.shields.io/github/languages/code-size/ssabit/uiufsi?style=flat-square)
![GitHub stars](https://img.shields.io/github/stars/ssabit/uiufsi?style=flat-square)

An information sharing system for faculty members and students of United International University (UIU). Students can see counseling time, upload and download previous questions.

## Built With

* [HTML](https://www.w3schools.com/html/) - HTML is the standard markup language for creating Web pages
* [CSS](https://www.w3.org/Style/CSS/) - Cascading Style Sheets (CSS) is a simple mechanism for adding style (e.g., fonts, colors, spacing) to Web documents
* [JavaScript](https://www.javascript.com/) - JavaScript is the programming language of HTML and the Web
* [PHP](https://www.php.net/) - PHP Back-end language
* [MySQL](https://www.mysql.com/) - Used to store data

## Contributors

* **Saad Ibna Omar Sabit** - [linkedin](https://www.linkedin.com/in/sabit/)
* **Haider Ali** - [linkedin](https://www.linkedin.com/in/haideralibd/)

## License

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

repository: ssabit/uiufsi

repo_name: ssabit/uiufsi


text:
# Overall Tab

This tab shows a history of the mission's configuration. From here you can:

- SET a previous configuration to be the current configuration
- Download a configuration as a .json
- Clone the mission to duplicate it
- Upload a custom config.json
- Delete the mission (which will not delete its missions folder data)

repository: frasercl/MMGIS

gha_language: JavaScript

repo_name: frasercl/MMGIS


text:
---
title: Medium term CPU load
brief: Average CPU load per core over the last five minutes
metric_type: gauge
---
### Medium Term CPU Load

> Average number of schedulable processes per CPU core over the last five minutes

A value above 1.0 indicates the system was overloaded during the last 5 minutes.


text:
# SHopsManager

Real Time  based application shows nearby shops by getting user's position &  calculating the distance to the shop .

### Prerequisites

 you need to install nodejs

## Structure

* Front end on client folder .
* BAck end on API folder .

### Installing

```
git clone https://github.com/Taoufik-AJAANIT/Shops-Manager.git
```

```
cd Shops-Manager
```

* To install server dependencies :
```
npm install --prefix API
```

* To install client dependencies:
```
npm install --prefix client
```

* to run server :
```
npm run server --prefix API
```

### note

note that the default API url for the react app is heroku API's url .
to fetch the local server please change the url in  /client/src/API_url.js file
to <IP_ADDRESS>:5000

* To run client :
```
npm start --prefix client
```

## Built With

* [Node.js] - For using JS outside the navigator & for backend developement
* [Express.js] - NodeJS framework
* [React.js] - Fronend JS framework
* [MongoDb] - noSQL database

## Features

* Front end Validation .
* Front end Validation .
* Backend Validation .
* JWT based Authontication .
* Passwords encryption .
* Database hosted on MongoAtlas .
* Routes Protection .
* Routes & Coontrollers .
* No page refreshs .
* giving rondom coordinates to user every refresh considering that user is moving (for now) .
* user (after authontication) can display the list of shops sorted by distance .
* user (after authontication)  can like a shop, so it can be added to his preferred shops .
* user (after authontication)  can display the list of preferred shop .
* user (after authontication)  can remove a shop from his preferred shops list .
* Will be added and much more .. :  user (after authontication)  can dislike a shop, so it won’t be displayed within “Nearby Shops” list during the next 2 hours (Dislike Button not working now :)

## Authors

* **Taoufik AJAANIt**  *

## License

This project is licensed under the MIT License .

repository: Taoufik-AJAANIT/Shops-Manager

repo_name: Taoufik-AJAANIT/Shops-Manager


text:
# Epson ES-300

* <https://files.support.epson.com/docid/cpd5/cpd52019/index.html>

## Enabling a Direct Wi-Fi (AP Mode) Connection

1. Slide the cover latch to open the scanner.
2. Set the connection mode switch on the scanner to the  AP mode position.
3. Turn on the scanner.
4.From your computer or device, search for and select the SSID shown on the label on the back of the scanner.
	* SSID: DIRECT 26923CBF
No need if used before:
Enter the password shown on the label on the back of the scanner. When the ready and  Wi-Fi lights on the scanner stay on, an AP mode connection is established.
	* PW: D96DC340

Windows menu > Epson > Epson Scan 2


text:
About mve
=========

Home: https://www.gcc.tu-darmstadt.de/home/proj/mve/

Package license: Apache 2.0

Summary: The Multi-View Environment is an effort to ease the work with multi-view datasets and to support the development of algorithms based on multiple views. It features Structure from Motion, Multi-View Stereo and Surface Reconstruction. MVE is developed at the TU Darmstadt. Visit the following website for more details.

repository: robins-project/mve-feedstock

repo_name: robins-project/mve-feedstock


text:
/*
  Title:The Fizz Buzz Problem
  Date:2013/01/14
  Author:Karl Oscar Weber
  Slug:the-fizz-buzz-problem
*/

Today I was asked to "white board" fizz buzz while in an interview. Fizz Buzz is a simple problem that prints 1 to 100. For every number that is divisible by 3, print fizz, for every number divisible by 5, print buzz, and for the numbers that are divisible by both, print fizz buzz. I have never solved fizz buzz before, so it was hard. I had to ask for help: "Isn't there a function that divides a number and determines if it's a decimal or a whol number?" I asked. "Use the modulus operator" The CTO responded. Obviously I knew what had to be done to solve the problem instantly, I just didn't know which functions / operators to use to do so. A big fail on my part. The modulus operator returns the remainder if there is a remainder, or a 0 if there isn't.

Here is the code that I used for Fizz Buzz below:

for ($i = 1; $i < 101 ; $i++) {

  if (!($i % 3) && !($i % 5)) {
      echo "$i fizz buzz
";
  } else if(!($i % 3)) {
      echo "$i fizz
";
  } else if (!($i % 5)) {
      echo "$i buzz
";
  } else {
      echo $i;
      echo "
";
  }
}

Lesson learned. Know your control statements and operators.

Sincerely,
Karl Oscar Weber


text:
---
title: The US Bureau of Roads
tags:
  - Apr 1970
---

The U.S. Bureau of Roads rejects a plan to connect the now submerged Pelican Island to Julia Tuttle Causeway.

Newspapers: **Miami Morning News or The Miami Herald**

Page: **1**, Section: **C**


text:
# RxConnectivityState
Useful Android library to check connectivity state within your app

Include the following dependency in your build.gradle file.

**Gradle:**
```Gradle
    dependencies {
        compile 'io.laanayabdrzak.android:rxconnectivitystate:1.0'
    }
```
**Maven:**
```
<dependency>
  <groupId>io.laanayabdrzak.android</groupId>
  <artifactId>rxconnectivitystate</artifactId>
  <version>1.0</version>
  <type>pom</type>
</dependency>
```
## V1.0

stable version.

## Why use it

It is better to check internet connectivity status before making any HTTP Requests to avoid http exceptions. this libray is created with the powerful of Reactive extension.

## Usage

*For a working implementation of this library, just subscribe to observable* Like this:

MainActivity:

```java
public class MainActivity extends AppCompatActivity {

    private TextView status;
    private Subscription mSubscription;
    private RxConnectivityState mRxConnectivityState;

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

        status = (TextView) findViewById(R.id.state);
        mRxConnectivityState = new RxConnectivityState();
        mSubscription = mRxConnectivityState.observeConnectivity(getApplicationContext())
                                 .subscribeOn(Schedulers.io())
                                 .observeOn(AndroidSchedulers.mainThread())
                                 .subscribe(new Action1<UtilityNetworkState>() {
                                     @Override
                                     public void call(UtilityNetworkState utilityNetworkState) {

                                            if (utilityNetworkState == UtilityNetworkState.WIFI_CONNECTED){
                                                status.setText("Connected");
                                            }
                                     }
                                 });
    }

    @Override
    protected void onPause() {
        mRxConnectivityState.safelyUnsubscribeToRxConnectivityState(mSubscription);
        super.onPause();
    }
}
```

## Developed By
 Author: **Abderrazak LAANAYA**

License
=======

    Copyright 2016 Abderrazak Laanaya

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

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

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

repository: laanayabdrzak/RxConnectivityState

repo_name: laanayabdrzak/RxConnectivityState


text:
# localStorage-by-IndexedDB-shim
The tiny polyfill makes available localStorage functions by using IndexedDB

_______________________________
![logo_msedge](http://static.dnaindia.com/sites/default/files/styles/half/public/2015/12/07/402206-microsoft-edge-logo.jpg?itok=-4FTLJur)

The library uses native implementation if it isn't too poor, or polls indexedDB with interval from options (start of the file, parameter `poll_time`, even minified), saves it and gives You ability to use it almost like normal regular `localStorage`! (see belowe why almost: it's a function). Poll interval is set to 200ms by default.

For the sake of EDGE support, where we cannot replace native `localStorage`, the library makes own variable (`localStorageShim` by default, but can be changed easily by changing it in one of first lines :)

In types the library behave like standard `localStorage`: makes ALL just strings. Even Objects. Be careful.

Example:

```javascript
  // Here the library or <script> tag.

  localStorageShim.getItem(14); // -> undefined

  localStorageShim.setItem(14, 42)  // -> undefined
  localStorageShim.setItem('next to all', 43)  // -> undefined

  localStorageShim.getItem(14)  // -> "42"
```

... page reloads, browser reloads, or it's another tab from that source...

```javascript
  localStorageShim.getItem(14)  // -> "42"
  localStorageShim.setItem('next to all') // -> "43"
```


text:
# Pixyll

Pixyll is a simple, beautiful theme for [Hugo](http://gohugo.io/).
Based on [Pixyll for Jekyll](https://github.com/johnotander/pixyll)

## Features

- Basic tag support.
- Disqus comments supported.
- Google Analytics supported.
- Social links (currently only for twitter).
- [Formspree](http://formspree.io/) for contact form.
- Pagination support.
- [Search](#search), executes in client side javascript.

NOTE: Content under `content/posts` is not rendered with this theme! Please move your content to `content/post`.

Example config:

```toml
languageCode = "en-us"
contentdir = "content"
publishdir = "public"
builddrafts = false
baseUrl = ""
canonifyurls = true
title = "Pixyll"
author = "admin"
theme = "pixyll"
disqusShortname = "sitename"

[indexes]
  category = "categories"
  tag = "tags"

[params]
  search_engine = true
  google_analytics_id = "XX-XXXXXXXX-X"
  twitter_username = "username"
  paginate = true
```

## Search
We decided to use [Tipue Search](http://www.tipue.com/search/) with custom script
to generate index. Search is being done completely in browser, you don't need to
run webserver for search. Current version of Tipue Search is 7.0

To activate search ensure that `[params]` section has line `search_engine = true`.
Then you need to generate search index:
1. Copy script `create_search_index.py` to your website root location,
where `config.toml` is located.
1. Install python requirements: `pip install -r requirements.txt`
1. Run `python2 create_search_index.py`

Script was tested with python 2.7 only.

Index will be placed into `public/tipuesearch/tipuesearch_content.js`. Every time you add
new article you need to regenerate index with command above.
If you run hugo as a server, please append option `--renderToDisk` othervise hugo
will not pick up files generated by search script.

![Pixyll Screenshot](https://raw.githubusercontent.com/azmelanar/hugo-theme-pixyll/master/images/tn.png)

repository: azmelanar/hugo-theme-pixyll

gha_language: CSS

repo_name: azmelanar/hugo-theme-pixyll


text:
---
title: "Calculating the RETURN_AUTHCODE"
draft: false
weight: 4
---

{{
}}

            ORDER_NUMBER
            ORDER-12345

            PAYMENT_ID
            123456789012

            AMOUNT
            200.00

            TIMESTAMP
            1491896573

            STATUS
            PAID

            Merchant authentication hash
            6pKF4jkv97zmqBJ3ZL8gUw5DfT2NMQ

{{
}}

Combining these fields using the `|` character as separator, the following string is formed:

```plain
ORDER-12345|123456789012|200.00|1491896573|PAID|6pKF4jkv97zmqBJ3ZL8gUw5DfT2NMQ
```

Calculating the **SHA-256** hash of this string, we get (note uppercase):

```plain
86CC6A9B9433D3AC1D8D1B8D21ED87DA3ABE2E980D3F826D1901FEF0925F5D03
```

If the calculated value equals the one received from the Payment Gateway (`RETURN_AUTHCODE`), the receipt is correct.

repository: eeturoponen/documentation

repo_name: eeturoponen/documentation


text:
+++
title = "May 2019 Meetup"
date = "2019-05-29T19:00:00"
where = "inviqa"
+++

Hi,

we're back. Come and join us for the March 2019 meetup,
Interested? We are always interested in short-talks, longer talks as well as presentations about what you've learned.
Post your proposals under
<https://github.com/vimberlin/vimberlin.de/issues/35>.

## Talks

- [@wikimatze](https://twitter.com/wikimatze "@wikimatze"): Flog, a New Git Branch extension

## The venue

- internet: yes. cable+wifi
- projector: 2 projectors. (VGA+HDMI), if you have a Mac, don't forget your adapters and/or install
  [teamviewer.com/](http://www.teamviewer.com/de/)
  - room: 15 people
  - drinks: fridge with drinks. 1€ each.

Bring your laptops - and join the fun! And show us *your* use with Vim! Be brief.. 5min for each presentation. We are
open to any kind of questions and suggestions.

Your host will be [Sven Guckes (@guckes)](http://www.guckes.net "Sven Guckes") & [Matthias Guenther
(@wikimatze)](https://wikimatze.de/ "Matthias Guenther (@wikimatze)")

See you there!

## Recap

Video about the talk "Flog, a New Git Branch extension" by [@wikimatze](https://twitter.com/wikimatze "wikimatze")

Video about the talk "Vimb a vim-like browser" by [@danleech](https://twitter.com/dantleech "danleech")

Video about the talk "dwim, vim-dadbod, and firenvim" part one by [@justinmk](https://twitter.com/justinmk "justinmk")

Video about the talk "veonim, oni2, wildoptions=pum, and floats" part two by [@justinmk](https://twitter.com/justinmk "justinmk")

Video about the talk "floats and latest Neovim features" part tree by [@justinmk](https://twitter.com/justinmk "justinmk")

Video about the latest vim news by [@wikimatze](https://twitter.com/wikimatze "wikimatze")

Other things and tools mentioned:

- [fbr to checkout branches](https://github.com/junegunn/fzf/wiki/examples#git "fbr to checkout branches")
- [qutebrowser](https://www.qutebrowser.org/ "qutebrowser")
- [dwim](https://en.wikipedia.org/wiki/DWIM "dwim"): do what I mean (smart)
- [vim-dadbod](https://github.com/tpope/vim-dadbod "vim-dadbod"): Modern database interface for Vim
- [firenvim](https://github.com/glacambre/firenvim "firenvim"):  Embed Neovim in your browser
- [veonim](https://github.com/veonim/veonim "veonim"): is simple modal IDE built on neovim.
- [oni2](https://github.com/onivim/oni2 "oni2"): Native, lightweight modal code editor
- [wildoptions=pum](https://twitter.com/Neovim/status/1107014096908664832 "wildoptions=pum"):
- [floats](https://twitter.com/Neovim/status/1101893773561348096 "float"): floating windows in nvim
- vimnews:
  - Neighbors in near the Rhein: vimrheinmain <https://twitter.com/vimrheinmain>
  - Videos from vimlondon: <https://vimeo.com/vimlondon>
  - Vim after 15 years: <https://statico.github.io/vim3.html>
  - Delicious Sushi in your statusbar plugin: https://github.com/pocke/sushibar.vim
  - Ask us anything - either in German or English: https://tellonym.me/vimberlin

gha_language: HTML


text:
The following is an example of a modal message in which the `variant` property is assigned the enum value `VARIANT.NEGATIVE`.
```jsx
import { VARIANT } from 'mark-one';

<ModalMessage
  variant={VARIANT.NEGATIVE}
>
  Error: Please try again.
</ModalMessage>
```

The following is an example of a modal message in which the `variant` property is assigned the enum value `VARIANT.PRIMARY`.
```jsx
import { VARIANT } from 'mark-one';

<ModalMessage
  variant={VARIANT.PRIMARY}
>
  Success: The information has been updated.
</ModalMessage>
```

The following is an example of a modal message in which the `variant` property is assigned the enum value `VARIANT.INFO`.
```jsx
import { VARIANT } from 'mark-one';

<ModalMessage
  variant={VARIANT.INFO}
>
  Note: All fields are required to submit the form.
</ModalMessage>
```

The following is an example of a modal message in which the `variant` property is assigned the enum value `VARIANT.BASE`.
```jsx
import { VARIANT } from 'mark-one';

<ModalMessage
  variant={VARIANT.BASE}
>
  Note: All fields are required to submit the form.
</ModalMessage>
```

repository: seas-computing/mark-one

repo_name: seas-computing/mark-one


text:
# Reading Charity Connect

## Git
1. Clone the git repository locally, and switch to the integration branch to work

## ojet
1. install ojet using npm;

```
cd ui
npm install --save-dev @oracle/ojet-cli
ojet restore
ojet build  --release
```

2. Start the ojet server as follows;

``ojet serve``

Note, we aren't going to actually run from that server, but having it active means the deployment gets rebuilt every time we edit a file.

## Development Environment Installation

1. Install the latest version of xampp from https://www.apachefriends.org/index.html
2. Run mysql and apache from xampp
3. Open the mysql admin (phpMyAdmin), and create a database called connect_reading and import the connect_reading_schema.sql file in to that
4.  Open the apache config file, and change the DocumentRoot to point to the directory where the git repository is, e.g. ``DocumentRoot "C:\Users\Bob\Documents\git\charity-connect"`` and set the directory to that too, e.g. ``<Directory "C:\Users\Bob\Documents\git\charity-connect">``

## Run the code
To run the code, just go to http://localhost/ui/web/index.html and the UI should render and the rest services should operate correctly

repository: RubiopRaul/reading-charity-connect

path: /Getting Started.md

filename: Getting Started.md

repo_name: RubiopRaul/reading-charity-connect


text:
# Setup

1. setup jar file
    you need download and copy below components to lib folder.
    * [elasticsearch-hadoop](http://mvnrepository.com/artifact/org.elasticsearch/elasticsearch-hadoop)

# Compile

1. install jdk 1.8 and sbt
2. execute sbt-assembly

    *※ if you execute on windows, use "win.compile.bat" in this folder or copy this folder to "c:\" before execute below.*
    ```console
    cd /to-this-folder
    sbt assembly
    ```

# Execute on Spark

1. copy files to "/opt/spark.to-words" on Spark client server.
   * spark.to-words.properties
   * target/scala-2.11/spark.to-words-assembly-1.0.jar
   * execute.sh

1. execute app by execute.sh

   ```console
   cd /opt/spark.to-words
   command ./execute.sh "hoge-search-word"
   ...
   ...
   ...
   Count of records founds is 10000
   ...
   ```

# What's the "execute.sh" doing

1. remove and put "spark.to-words.properties" to hdfs.

    ```console
    sudo -u hdfs hdfs dfs -rm /tmp/spark.to-words.properties
    sudo -u hdfs hdfs dfs -put /opt/spark.to-words/spark.to-words.properties /tmp/spark.to-words.properties
    ```

1. execute app (using yarn)

   ```console
   ${SPARK_HOME}/bin/spark-submit \
   --master yarn-client \
   --class mad_nectarine.spark.GetSearchCount \
   /opt/spark.to-words/spark.to-words-assembly-1.0.jar \
   $1
   ```


text:
# Baobab API

Built using Flask and SQLAlchemy

## Prerequisites
### Running with Docker.

The development environment uses [Docker](http://www.docker.com/) and [Docker Compose](https://docs.docker.com/compose/). This makes it super easy to get up and running with a configuration that would closely mirror production.

### Running locally
- TBC

## Installation

With Docker/Compose installed, use the following steps to launch for the first time:

* `docker-compose up` to start the web app. This will download and provision two containers: one running PostgreSQL and one running the Flask app. This will take a while, but once it completes subsequent launches will be much faster.
* When `docker-compose up` completes, the app should be accessible at [http://<IP_ADDRESS>:5000](http://<IP_ADDRESS>:5000).

## Environment Variables

There are just a couple of configurations managed as environment variables. In the development environment, these are injected by Docker Compose and managed in the `docker-compose.yml` file.

* `DATABASE_URL` - This is the connection URL for the PostgreSQL database. It is not used in the **development environment**.
* `DEBUG` - This toggle debug mode for the app to True/False.
* `SECRET_KEY` - This is a secret string that you make up. It is used to encrypt and verify the authentication token on routes that require authentication.

## Project Organization

* Application-wide settings are stored in `config.py` at the root of the repository. These items are accessible on the `config` dictionary property of the `app` object. Example: `debug = app.config['DEBUG']`
* The directory `/app` contains the API application
* URL mapping is managed in `/app/routes.py`
* Functionality is organized in packages. Example: `/app/users` or `/app/utils`.
* Tests are contained in each package. Example: `app/users/tests.py`

## Running Tests

Tests are run with [nose](https://nose.readthedocs.org/en/latest/) from inside the `docker-compose` web container.

### Run All

```
docker-compose run web nosetests
```

### Run Specific Tests
As the project has grown, so has the number of tests and the amount of time needed to run them all. Luckily, you can progressively get more and more specific about which tests you can run making your feedback loop shorter and thus speeding up the development process.

#### Run all tests in a file
We will use `invitedGuest` as the example.
```
docker-compose run web bash -c 'cd api; nosetests -v app.invitedGuest.tests'
```
On Windows, you may need to break the command above up to get into the container, open the correct directory, and then finally to run the tests
```
docker-compose run web bash
cd api
nosetests -v app.invitedGuest.tests
```

#### Run all tests in a class

```
nosetests -v app.invitedGuest.tests:InvitedGuestTest
```

#### Run a specific test
```
nosetests -v app.invitedGuest.tests:InvitedGuestTest.test_create_invitedGuest
```

## Database Migrations

When a class inherits from the SQL Alchemy `db.Model` class, it represents the code format of an actual table in the database. This means that whenever fields are added, edited, or removed from these classes, the corresponding change needs to be made in the database. Luckily, this process can be automated in the form of a _migration_ so you usually only ever have to make the changes in code.

Migrations for the provided models are part of the seed project. To generate a new migration use `Flask-Migrate`:

```
docker-compose run web python ./api/run.py db migrate --directory api/migrations
```

Assuming no errors occurred (generally this will happen if there's a syntax error in your code), this should generate the script. If you look in your project directory, you will see a new file has been added to `./app/migrations/versions`. You'll also see all the other files that have been generated previously.

Open the file and verify that in the `upgrade()` method the changes you made have been added and in the `downgrade()` method, the changes have been removed. The `upgrade()` is for when we deploy and the `downgrade()` is for if we decide to rollback a change on production.

Once you're happy with the script, run the following command.

```
docker-compose run web python ./api/run.py db upgrade --directory api/migrations
```

This should now actually run the script that was generated and apply the changes to the local instance of the database.

### Merging migrations

If you run into the following error while attempting a migration, it means that a migration was created on separate concurrent git branches from the same base.

`Multiple head revisions are present for given argument 'head'; please specify a specific target revision, '@head' to narrow to a specific head, or 'heads' for all heads`

Running the below command should create a new migration that will merge them (note it will be empty although you will notice multiple entries in the `down_revision` variable). See this [link](https://blog.jerrycodes.com/multiple-heads-in-alembic-migrations/) to understand this error and solution in more detail.
```
docker-compose run web python ./api/run.py db merge --directory api/migrations heads
```

## API Routes

This API uses token-based authentication. A token is obtained by registering a new user (`/api/v1/user`) or authenticating an existing user (`/api/v1/authenticate`). Once the client has the token, it must be included in the `Authorization` header of all requests.

### Register a new user

**POST:**
```
/api/v1/user
```

**Body:**
```json
{
    "email"<EMAIL_ADDRESS>    "password": "123456"
}
```

**Response:**
```json
{
    "id": 2,
    "token": "eyJhbGciOiJIUzI1NiIsImV4cCI6MTQxMDk2ODA5NCwiaWF0IjoxNDA5NzU4NDk0fQ.eyJpc19hZG1pbiI6ZmFsc2UsImlkIjoyLCJlbWFpbCI6InRlc3QyQHRlc3QuY29tIn0.goBHisCajafl4a93jfal0sD5pdjeYd5se_a9sEkHs"
}
```

**Status Codes:**
* `201` if successful
* `400` if incorrect data provided
* `409` if email is in use

### Get the authenticated user

**GET:**
```
/api/v1/user
```

**Response:**
```json
{
    "id": 2,
    "email"<EMAIL_ADDRESS>}
```

**Status Codes:**
* `200` if successful
* `401` if not authenticated

### Authenticate a user

**POST:**
```
/api/v1/authenticate
```

**Body:**
```json
{
    "email"<EMAIL_ADDRESS>    "password": "123456"
}
```

**Response:**
```json
{
    "id": 2,
    "token": "eyJhbGciOiJIUzI1NiIsImV4cCI6MTQxMDk2ODA5NCwiaWF0IjoxNDA5NzU4NDk0fQ.eyJpc19hZG1pbiI6ZmFsc2UsImlkIjoyLCJlbWFpbCI6InRlc3QyQHRlc3QuY29tIn0.goBHisCajafl4a93jfal0sD5pdjeYd5se_a9sEkHs"
}
```

**Status Codes:**
* `200` if successful
* `401` if invalid credentials

repository: deep-learning-indaba/Baobab

repo_name: deep-learning-indaba/Baobab


text:
# Registration for React app

## Description

Just a small full-stack exercise from DCI one year web developer course.

Demo of the registration in the react app:

- Possibilities of register (e-mail has to be unique) and login

- logged user can change password

- logged user can also change profile photo (usage of multer package)

- basic verification by registration using express-validator

No final product - no special styling (just basic bootstrap), no cleanly ordered code, etc. just playground.

Full stack with Express.js backend and MongoDB database, backend part is [MongoDB-Playground repository](https://github.com/Alice-Rez/MongoDB-Playground).

Passwords are not correctly handled yet, so this exercise do not show correct way how to handle passwords!

## Setup

1. clone this repository as well as [MongoDB-Playground repository](https://github.com/Alice-Rez/MongoDB-Playground)
2. instal all dependencies using ` npm install` in both of the cloned repositories
3. start server by `nodemon start`
4. start frontend part by `npm start`
5. enjoy exploring of the application

## Acknowledgement

This project was bootstrapped with [Create React App](https://github.com/facebook/create-react-app).

repository: Alice-Rez/React-Registration-Form

gha_license_id: NOASSERTION

repo_name: Alice-Rez/React-Registration-Form


text:
# RamokSelfbot-Rewritten
DISCORD : https://discord.gg/GxvKJ5kgPR

I made this project to learn c#, this is not the best selfbot ever (lol its a beta and the only opensource selfbot in c# that i know the existence)

# Legality
The selfbot has been made for educational purposes. I do not take responsability on the bad usage of this selfbot.

# First start !
When you download the selfbot, the first thing you need to do before launching the bot is :

- Set your token at token.txt
- Customize the bot

Or :

- Check your files with argument "/checkfiles"
- Open the selfbot with argument "/config"

 # Set your token

   - Use this tutorial to get your token, and then put it in token.txt : https://www.youtube.com/watch?v=YEgFvgg7ZPI
   - (Do not share this string to nobody, only this is necessary for login to ur Discord account, this bypass A2F too !)

 # Customize the bot

   API KEYS :

   - Create a Youtube API key here : https://console.developers.google.com/

   - (You can modify embed color in the selfbot without restarting !)

# FOR THE DEVLOPPERS

  - If you want to reuse the code, keep my name in it
  - Keep my name in the README.md
  - Make an credits command with my name in it

  - OR ITS SKID.

repository: hylo-kek/RamokSelfbot-Rewritten

repo_name: hylo-kek/RamokSelfbot-Rewritten


text:
# data-constraint-checker

This is for data constraints checking.

## Set up
Install required gems:

Ensure you have installed ruby 2.3.7

`rvm use 2.3.7`

`gem install yard`

`gem install regexp-examples -v 1.4.4`

`gem install pg_query`

`gem install activesupport -v 5.2.3`

`gem install write_xlsx -v 0.85.6`

cloc for line of code analysis:
* linux
```export PATH=`pwd`/cloc-1.82/cloc:$PATH```
* mac
`brew install cloc`

bs4 under python3

`apt-get install python3-bs4`

or

`pip3 install beautifulsoup4`

## Prepare

### clone all 12 apps

`ruby clone_repo.rb`

## Run

### Extract the latest version constraints:

`$ ruby run_apps.rb -l`

### Traverse all versions

`$ ruby run_apps.rb --tva`
* This will extract the evolution history of constraints, also the column associated with constraints

### Compare the onstraints defined in the first and last versions

`$ ruby run_apps.rb --first-last-num`

### Extract the breakdown of different type constraints:

`$ ruby run_apps.rb  --api-breakdown`

  * This will generate a single log file for each application under log/api_breakdown_#{app_name}.log

`$ ruby api_breakdown_spread_sheets.rb `

  * The summarized breakdown will be written to output/api_total_breakdown.xlsx.


text:
# Heartbeat

Heartbeat是distributed computing中广泛采用的一种technique。

## 素材

### Heartbeat (computing)

> https://en.wanweibaike.com/wiki-Heartbeat%20protocol

In [computer science](https://en.wanweibaike.com/wiki-Computer_science), a **heartbeat** is a periodic signal generated by hardware or software to indicate normal operation or to synchronize other parts of a [computer system](https://en.wanweibaike.com/wiki-Computer_system).[[1\]](https://en.wanweibaike.com/wiki-Heartbeat protocol#cite_note-pcmag.com-1) Usually a heartbeat is sent between machines at a regular interval in the order of seconds. If the endpoint does not receive a heartbeat for a time—usually a few heartbeat intervals—the machine that should have sent the heartbeat is assumed to have failed.[[2\]](https://en.wanweibaike.com/wiki-Heartbeat protocol#cite_note-2)

### Heartbeat message

> https://en.wanweibaike.com/wiki-Heartbeat%20message

A **heartbeat message** in signal processing is a message sent from an originator to a destination that enables the destination to identify if and when the originator fails or is no longer available.[[1\]](https://en.wanweibaike.com/wiki-Heartbeat message#cite_note-att01-1) Heartbeat messages are typically sent non-stop on a [periodic](https://en.wanweibaike.com/wiki-Periodic_function) or recurring basis from the originator's start-up until the originator's shutdown. When the destination identifies a lack of heartbeat messages during an anticipated arrival period, the destination may determine that the originator has failed, shutdown, or is generally no longer available. Heartbeat messages may be used for [high-availability](https://en.wanweibaike.com/wiki-High-availability) and [fault tolerance](https://en.wanweibaike.com/wiki-Fault_tolerance) purposes.

### Heartbeat network

> https://en.wanweibaike.com/wiki-Heartbeat%20network

In [computer clusters](https://en.wanweibaike.com/wiki-Computer_clusters), a **heartbeat network** is a [private network](https://en.wanweibaike.com/wiki-Private_network) which is shared only by the nodes in the cluster, and is not accessible from outside the cluster. It is used by cluster nodes in order to monitor each node's status and communicate with each other messages necessary for maintaining operation of the cluster.

## Case study

### Case: Linux-HA

> https://en.wanweibaike.com/wiki-Heartbeat%20(program)

### Case: zookeeper

在 [ZooKeeper Getting Started Guide](https://zookeeper.apache.org/doc/r3.6.2/zookeeperStarted.html) 中有这样的介绍:

> ***`tickTime`*** : the basic time unit in milliseconds used by ZooKeeper. It is used to do **heartbeats** and the minimum **session timeout** will be twice the `tickTime`.

repository: dengking/Parallel-computing

repo_name: dengking/Parallel-computing


text:
---
title: Overview
page_title: Visual Studio Code Integration Overview | Telerik UI for Blazor
description: "Learn how to enhance your experience in developing web applications with Progress Telerik UI for Blazor."
slug: getting-started-vs-code-integration-overview
position: 1
---

# Visual Studio Code Integration Overview

The **Telerik UI for Blazor Template Wizard** [Visual Studio Code](https://code.visualstudio.com/) Extension enhances the experience in developing Blazor web applications with Telerik UI for Blazor.

As its primary advantage, the VS Code extension facilitate the creation of projects through a wizard directly in Visual Studio Code.

## Get the Extension

You can get the extention:

* from the [Visual Studio Marketplace](https://marketplace.visualstudio.com/items?itemName=TelerikInc.blazortemplatewizard)

* by opening the **Extensions** tab in Visual Studio Code, then searching for **Telerik UI for Blazor Template Wizard** and clicking **Install**

## Create a Telerik Project

To create a Telerik-enabled Blazor project:

1. Press `Ctrl`+`Shift`+`P` in Windows/Linux or `Cmd`+`Shift`+`P` on Mac to open VSCode's extension launcher

    ![launch Telerik Blazor VS Code extension](images/launch-extension.png)

1. Type/Select `Telerik UI for Blazor Template Wizard: Launch` and press `Enter` to launch the extension

1. The wizard will now guide you through the project creation steps:
    1. choose a project name and location,

        ![choose Telerik project name and location](images/project-name-and-location.png)

    1. the type of project (WASM or Server-side) and your Telerik license (trial or commercial, depending on what you have),

        ![choose Blazor project type and Telerik license](images/project-type-and-license.png)

    1. add some sample pages to get you started (a grid with CRUD operations form a service, a form, charts),

        ![add sample pages](images/add-pages.png)

    1. choose a Theme.

        ![choose Telerik Theme](images/choose-theme.png)

1. When you open the project, to run it:

    1. Open the Terminal and navigate to the `Server` project folder. For a server project this is the folder with the project name, for a WASM project it will be the `Server` folder.

    1. Execute `dotnet run` and navigate your browser to the link you see in the console output.

1. You now have a Blazor SPA app running!

repository: EduVencovsky/blazor-docs

repo_name: EduVencovsky/blazor-docs


text:
+++
title = "Variations on a theme: evolution of the phage-shock-protein system in Actinobacteria"
date = 2018-02-27T00:00:00

slug = "anto" # still works?

# Authors. Comma separated list, e.g. `["Bob Smith", "David Jones"]`.
authors = ["Janani Ravi", "Vivek Anantharaman", "L Aravind Iyer", "Maria L Gennaro"]

# Publication type.
# Legend:
# 0 = Uncategorized
# 1 = Conference paper
# 2 = Journal article
# 3 = Preprint / Working Paper
# 4 = Report
# 5 = Book
# 6 = Book section
# 7 = Thesis
# 8 = Patent
publication_types = ["2"]

# Publication name and optional abbreviated version.
publication = "*Antonie Van Leeuwenhoek*, Springer."
publication_short = "*Anto*"

# Abstract and optional shortened version.
abstract = " "
summary = ""

# Digital Object Identifier (DOI)
doi = ""

# Is this a featured publication? (true/false)
featured = false

# Projects (optional).
#   Associate this publication with one or more of your projects.
#   Simply enter your project's folder or file name without extension.
#   E.g. `projects = ["deep-learning"]` references
#   `content/project/deep-learning/index.md`.
#   Otherwise, set `projects = []`.
projects = ["stress-response"]

# Slides (optional).
#   Associate this publication with Markdown slides.
#   Simply enter your slide deck's filename without extension.
#   E.g. `slides = "example-slides"` references
#   `content/slides/example-slides.md`.
#   Otherwise, set `slides = ""`.
slides = "" # example-slides

# Tags (optional).
#   Set `tags = []` for no tags, or use the form `tags = ["A Tag", "Another Tag"]` for one or more tags.
tags = ["stress-response", "phylogeny-evolution", "host/pathogen", "compbio-bioinfo", "R"]
categories = ["Research"]

# Links (optional).
url_pdf = "https://link.springer.com/content/pdf/10.1007%2Fs10482-018-1053-5.pdf"
url_preprint = ""
url_code = ""
url_dataset = ""
url_project = "//jananiravi.github.io/projects/stress-response"
url_slides = ""
url_video = ""
url_poster = ""
url_source = ""

# Custom links (optional).
#   Uncomment line below to enable. For multiple links, use the form `[{...}, {...}, {...}]`.
links = [{name = "PubMed", url = "https://www.ncbi.nlm.nih.gov/pubmed/29488183"}, {name = "GitHub", url = "http://github.com/jananiravi/2018-psp-actino"}]

# Does this page contain LaTeX math? (true/false)
math = true

# Featured image
# To use, add an image named `featured.jpg/png` to your page's folder.
[image]
  # Caption (optional)
  caption = ""

  # Focal point (optional)
  # Options: Smart, Center, TopLeft, Top, TopRight, Left, Right, BottomLeft, Bottom, BottomRight
  focal_point = "Center"

  # Show image only in page previews?
  preview_only = false

# [header]
# image = "psp-actino.png"

+++

repository: jananiravi/jananiravi-webpage

repo_name: jananiravi/jananiravi-webpage


text:
# DOCX/Word Document Template Automation Tool

Given a template word document. This python notebook allows a user to substitute in records of data and create N documents.

## Example

Given document.docx (the template) and data.csv (the records of data) we want to substitute to create a separate form for each user in the CSV file. This will take the template and substitute $name and $email for each records in the dataset and create its own word document.

repository: awhipp/docx-template-generator

repo_name: awhipp/docx-template-generator


text:
## Benchmark for Image Retrieval (BKIR)

[![License](https://img.shields.io/badge/license-BSD-blue.svg)](../LICENSE)

This project tries to build a benchmark for image retrieval, particularly for Instance-level image retrieval.

## Running on Scores Dataset

Fisher vector and VLAD are both currently working on the scores dataset. To run them,

1. install `score-retrieval`,
2. run `make`, follow the instructions, then run `make` again,
3. run `make yael`,
4. run `make hesaff`,
5. run `make setup-dataset`,
6. run the commands in the `fv` or `vlad` make target manually (`make fv`/`make vlad` isn't working right now for some reason).

Note: The training parameters in `gmm.py` (for FV) and `kmeans.py` (for VLAD) have been massively reduced for ease of testing. If you want a real training run, increase them.

## Methods

<!-- The following methods are evaluated on [Oxford Building dataset](http://www.robots.ox.ac.uk/~vgg/data/oxbuildings/). The evaluation adopts mean Average Precision (mAP), which is computed using the code provided by [compute_ap.cpp](http://www.robots.ox.ac.uk/~vgg/data/oxbuildings/compute_ap.cpp). -->

method | feature |  mAP (best) | status | links
:---:|:---:|:---:|:---:|:---:
fc_retrieval | CNN | 60.2% | finished | [fc_retrieval](https://github.com/willard-yuan/cnn-cbir-benchmark/tree/master/fc_retrieval)
rmac_retrieval | CNN | to be tested | finished | [rmac_retrieval](https://github.com/willard-yuan/cnn-cbir-benchmark/tree/master/rmac_retrieval)
crow_retrieval | CNN | to be tested | finished | [crow_retrieval](https://github.com/willard-yuan/cnn-cbir-benchmark/tree/master/crow_retrieval)
fv_retrieval | SIFT | 67.29% | finished | [fv_retrieval](https://github.com/willard-yuan/cnn-cbir-benchmark/tree/master/fv_retrieval)
vlad_retrieval | SIFT | 63.13% | finished | [vlad_retrieval](https://github.com/willard-yuan/cnn-cbir-benchmark/tree/master/vlad_retrieval)

the methods on above have the following characteristics:

- **Low dimension**
- **Time - tested**
- **Used in industry**

## Contribution

If you are interested in this project, feel free to contribute your code. Only Python and C++ code are accepted.

repository: evhub/cnn-cbir-benchmark

repo_name: evhub/cnn-cbir-benchmark


text:
# fingerwrite-mnist

## Overview

Identify finger-written digit image as number with IBM Watson.

## Pre-requisites

Follow and complete this page, and generate Web Service(REST API) to identify digit image as number.

https://qiita.com/ishida330/items/b093439a1646eba0f7c6

## Settings

- Edit settings.js with your own IBM Watson Service instance:

    - exports.wml_url: **url** value of service credential information in IBM Watson Machine Learning service instance

        - Usually this value would be **https://ibm-watson-ml.mybluemix.net**

    - exports.wml_username: **username** value of service credential information in IBM Watson Machine Learning service instance

    - exports.wml_password: **password** value of service credential information in IBM Watson Machine Learning service instance

    - ![IBM Watson Machine Learning](http://livedoor.blogimg.jp/dotnsf/imgs/6/8/68efa162-s.png)

    - exports.ws_endpoint: **Scoring End-point** from IBM Watson Studio service instance

    - ![IBM Watson Studio](http://livedoor.blogimg.jp/dotnsf/imgs/1/9/190f378d-s.png)

- Install dependencies

    - `$ npm install`

## Run

- Run application

    - `$ node app`

## Reference

https://qiita.com/ishida330/items/b093439a1646eba0f7c6

http://dotnsf.blog.jp/archives/1070827338.html

## Licensing

This code is licensed under MIT.

## Copyright

2018 K.Kimura @ Juge.Me all rights reserved.

repository: dotnsf/fingerwrite-mnist

repo_name: dotnsf/fingerwrite-mnist


text:
# Covid-19-UK-Reporting

[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/Dorset-Health-And-Care/Covid-19-UK-Reporting/master?filepath=Covid19%20UK.ipynb)

Jupyter notebooks demonstrating the use of the UK Governments API for retrieving Covid-19 case and test result data.

API access details are at: [https://coronavirus.data.gov.uk/developers-guide](https://coronavirus.data.gov.uk/developers-guide)

+ Testing downloads and displays test results for the four national of the UK.
+ Covid 19 UK downloads historic cases at Lower Tier Local Authority level and then displays trend graphs for Dorset and BCP, as well as box plot and outlier analysis for all areas to identify those with case rates which may require further investigation.

Minimum requirements

Conda:

+ python >=3.7
+ jupyter
+ numpy
+ pandas
+ plotly
+ tqdm
+ xlrd

Pip only:

+ tsmoothie
+ uk_covid19


text:
---
layout: postag
title: 'PUNCT'
shortdef: 'punctuation'
udver: '2'
---

### Definition

Punctuation marks are non-alphabetical characters and character groups used to delimit linguistic units in printed text. They can consist of a sequence of symbols, such as a question mark followed by an exclamation mark (?!), an exclamation mark followed by two full stops (!..) and ellipsis (…) and appear: a) in abbreviations (_ა.შ._ 'etc.', _ე.ი._ 'i.e.', etc.) and b) in numeric expressions (1.2, 0,5, etc.).

### Corresponding language-specific part-of-speech tags

F: Punctuation marks

### Examples

Period: _._
Comma: _,_
Parentheses: _(_, _)_

repository: UniversalDependencies/docs

branch_name: refs/heads/pages-source

repo_name: UniversalDependencies/docs


text:
# Serverless PyPI

[![terraform](https://img.shields.io/github/v/tag/amancevice/terraform-aws-serverless-pypi?color=62f&label=version&logo=terraform&style=flat-square)](https://registry.terraform.io/modules/amancevice/serverless-pypi/aws)
[![test](https://img.shields.io/github/actions/workflow/status/amancevice/terraform-aws-serverless-pypi/test.yml?logo=github&style=flat-square)](https://github.com/amancevice/terraform-aws-serverless-pypi/actions/workflows/test.yml)
[![coverage](https://img.shields.io/codeclimate/coverage/amancevice/terraform-aws-serverless-pypi?logo=code-climate&style=flat-square)](https://codeclimate.com/github/amancevice/terraform-aws-serverless-pypi/test_coverage)
[![maintainability](https://img.shields.io/codeclimate/maintainability/amancevice/terraform-aws-serverless-pypi?logo=code-climate&style=flat-square)](https://codeclimate.com/github/amancevice/terraform-aws-serverless-pypi/maintainability)

[![ko-fi](https://ko-fi.com/img/githubbutton_sm.svg)](https://ko-fi.com/smallweirdnumber)

S3-backed serverless PyPI.

Requests to your PyPI server will be proxied through a Lambda function that pulls content from an S3 bucket and responds with the same HTML content that you might find in a conventional PyPI server.

Requests to the base path (eg, `/simple/`) will respond with the contents of an `index.html` file at the root of your S3 bucket.

Requests to the package index (eg, `/simple/fizz/`) will dynamically generate an HTML file based on the contents of keys under that namespace (eg, `s3://your-bucket/fizz/`). URLs for package downloads are presigned S3 URLs with a default lifespan of 15 minutes.

Package uploads/removals on S3 will trigger a Lambda function that reindexes the bucket and generates a new `index.html` at the root. This is done to save time when querying the base path when your bucket contains a multitude of packages.

![Serverless PyPI](./docs/serverless-pypi.png)

## Usage

As of v3 users are expected to bring-your-own HTTP (v2) API instead of providing one inside the module. This gives users greater flexibility in choosing how their API is set up.

The most simplistic setup is as follows:

```terraform
#######################
#   SERVERLESS PYPI   #
#######################

module "serverless_pypi" {
  source  = "amancevice/serverless-pypi/aws"
  version = "~> 7"

  api_execution_arn             = aws_api_gateway_rest_api.pypi.execution_arn
  api_id                        = aws_api_gateway_rest_api.pypi.id
  api_root_resource_id          = aws_api_gateway_rest_api.pypi.root_resource_id
  event_rule_name               = "serverless-pypi-reindex"
  iam_role_name                 = "serverless-pypi"
  lambda_api_fallback_index_url = "https://pypi.org/simple/"
  lambda_api_function_name      = "serverless-pypi-api"
  lambda_reindex_function_name  = "serverless-pypi-reindex"
  s3_bucket_name                = "serverless-pypi-us-west-2"

  # etc …
}

################
#   REST API   #
################

resource "aws_api_gateway_rest_api" "pypi" {
  description = "Serverless PyPI example"
  name        = "serverless-pypi"

  endpoint_configuration { types = ["REGIONAL"] }
}

resource "aws_api_gateway_deployment" "pypi" {
  rest_api_id = aws_api_gateway_rest_api.pypi.id

  triggers = { redeployment = module.serverless_pypi.api_deployment_trigger }

  lifecycle { create_before_destroy = true }
}

resource "aws_api_gateway_stage" "simple" {
  deployment_id = aws_api_gateway_deployment.pypi.id
  rest_api_id   = aws_api_gateway_rest_api.pypi.id
  stage_name    = "simple"
}
```

## S3 Bucket Organization

This tool is highly opinionated about how your S3 bucket is organized. Your root key space should only contain the auto-generated `index.html` and "directories" of your PyPI packages.

Packages should exist one level deep in the bucket where the prefix is the name of the project.

Example:

```plain
s3://your-bucket/
├── index.html
├── my-cool-package/
│   ├── my-cool-package-0.1.2.tar.gz
│   ├── my-cool-package-1.2.3.tar.gz
│   └── my-cool-package-2.3.4.tar.gz
└── my-other-package/
    ├── my-other-package-0.1.2.tar.gz
    ├── my-other-package-1.2.3.tar.gz
    └── my-other-package-2.3.4.tar.gz
```

## Fallback PyPI Index

You can configure your PyPI index to fall back to a different PyPI in the event that a package is not found in your bucket.

Without configuring a fallback index URL the following `pip install` command will surely fail (assuming you don't have `boto3` and all its dependencies in your S3 bucket):

```bash
pip install boto3 --index-url https://my.private.pypi/simple/
```

Instead, if you configure a fallback index URL in the terraform module, then requests for a pip that isn't found in the bucket will be re-routed to the fallback.

```terraform
module "serverless_pypi" {
  source  = "amancevice/serverless-pypi/aws"
  version = "~> 4.1"

  lambda_api_fallback_index_url = "https://pypi.org/simple/"

  # etc …
}
```

## Auth

Please note that this tool provides **NO** authentication layer for your PyPI index out of the box. This is difficult to implement because `pip` is currently not very forgiving with any kind of auth pattern outside Basic Auth.

### Cognito Basic Auth

I have provided a _very_ simple authentication implementation using AWS Cognito and API Gateway authorizers.

Add a Cognito-backed Basic authentication layer to your serverless PyPI with the `serverless-pypi-cognito` module:

```terraform
module "serverless_pypi" {
  source  = "amancevice/serverless-pypi/aws"
  version = "~> 4.1"

  api_authorization_type = "CUSTOM"
  api_authorizer_id      = module.serverless_pypi_cognito.api_authorizer.id

  # …
}

module "serverless_pypi_cognito" {
  source  = "amancevice/serverless-pypi-cognito/aws"
  version = "~> 2.0"

  api_id                 = aws_apigatewayv2_api.pypi.id
  cognito_user_pool_name = "serverless-pypi-cognito-pool"
  iam_role_name          = module.serverless_pypi.iam_role.name
  lambda_function_name   = "serverless-pypi-authorizer"
}
```

gha_language: HCL


text:
# electron-react-typescript

I extracted this from my commercial projects so I can reuse it for new ones. I don't use [create-react-app](https://github.com/facebook/create-react-app) because I inevitably need to eject and support a snowflake case. This project uses Webpack 4 which has great defaults and I've configured hot reloading for you.

It's barebones and has few opinions:

* [TypeScript](https://www.typescriptlang.org/)
* [React](https://reactjs.org/)
* [react-router](https://reacttraining.com/react-router)
* [Jest](https://facebook.github.io/jest/)
* [Ant Design](https://ant.design/)

I can start making anything with this immediately and hope you can too. It's easy to swap out Ant Design if that's not your cup of tea.

## Electron

For some projects I need to distribute a desktop app. [Electron](https://electronjs.org/) is perfect for this requirement. If you don't need it you can easily remove it.

1. Delete *src/main.ts*, *src/renderer.ts*
1. Delete the `dev:renderer` script in *package.json*
1. Update other scripts in *package.json* to match the language of a typical React app

## Getting Started

Install all the dependencies

```shell
$ npm install
```

Run the script to watch and build your app files

```shell
$ npm run dev:renderer
```

If building an Electron app, run this script to load your app inside of it

```shell
$ npm run dev:main
```

## Build

TODO

repository: locnguyen/electron-react-typescript

repo_name: locnguyen/electron-react-typescript


text:
# SkyprepRubySDK

The SkyPrep Ruby SDK is a wrapper on top of the HTTP SkyPrep API(https://skyprep.com/api). All JSON responses are automatically converted to similar Ruby Objects(hashes).

All API calls are mapped to a corresponding method. For example, get_all_users is mapped to api.get_users.

The wrapper uses some metaprogramming so that any new methods that are added to the API should work automatically in the SDK.

## Installation

Add this line to your application's Gemfile:

```ruby
gem 'skyprep_rubySDK'
```

And then execute:

    $ bundle

Or install it yourself as:

    $ gem install skyprep_rubySDK

## Usage

First and foremost you need to include the module SkyprepRubySDK where you want to use it. So write

		include SkyprepRubySDK

then initialize your own instance of the api by passing in your skyprep api key and account key.

		your_api = SkyPrepApi.new('*api_key*', '*acct_key*')

Then if you want to find a user with the get_user method from the api, just call the method on your api instance(methods all have the same names as call from the api). So get a user will be your_api.get_user({params}). i.e.

		your_api.get_user({"user_id" => "*ID*"})

		#sample response {
			"id" : 32,
			"first_name" : "John",
			"last_name" : "Doe"
			...
		}

## Development

After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).

## Contributing

Bug reports and pull requests are welcome on GitHub at https://github.com/zhangmyihua/skyprep_rubySDK.

## License

The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).


text:
SPECS:
=====================================
•Runs but below minimum specs: 80gb, 2.20ghz, 2gb ram

•Recomended specs: 300gb SSD, 4x 2.20 ghz and 12 gb ram

•Ultra specs: 300gb SSD, 4x 2.20 ghz and 96 gb ram (run the os in ram its self)

An open-source crypto currency exchange
=====================================
[![Gitter](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/peatio/peatio?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
[![Build Status](https://travis-ci.org/Gensia/Open-Source-Cryptocurrency-Exchange.svg?branch=master)](https://travis-ci.org/Gensia/Open-Source-Cryptocurrency-Exchange)

[![Total Downloads](https://img.shields.io/npm/dt/hacktimer.svg)](https://github.com/Gensia/Open-Source-Cryptocurrency-Exchange)
[![Week Downloads](https://img.shields.io/npm/dw/hacktimer.svg)](https://github.com/Gensia/Open-Source-Cryptocurrency-Exchange)
[![Month Downloads](https://img.shields.io/npm/dm/hacktimer.svg)](https://github.com/Gensia/Open-Source-Cryptocurrency-Exchange)
[![Day Downloads](https://img.shields.io/npm/dy/hacktimer.svg)](https://github.com/Gensia/Open-Source-Cryptocurrency-Exchange)

### Introduction
This branch is a fork of Peatio that will provide an open source cryptocurrency exchange platform that uses 0xBitcoin (https://0xbitcoin.org/) as the default base currency.

0xbitcoin-exchange focuses on 0xbitcoin support and user friendly, non-geeky trading experience.

The exchange in http://0xbitcoin.exchange (not live, sorry folks) is community-based, non-corporate one and it proceedings will support promotion and adoption of 0xBitcoin.

~ 0xBitcoin combines groundbreaking features of Bitcoin with capabilities of Ethereum ~

### Recently done / News

•Installer with minimal steps:

      sudo adduser deploy
      sudo usermod -a -G sudo deploy
      wget https://raw.githubusercontent.com/0xbitcoin-exchange/Open-Source-Cryptocurrency-Exchange/master/install1.sh
      source install1.sh

NOTE: it is critical you launch this with "SOURCE" not "SH" not "BASH" etc
NOTE2: less than 4GB of ram you should disable the line that reads bitcoind or you wont have enough memory to launch the page

•Multi Server Support https://github.com/Gensia/Open-Source-Cryptocurrency-Exchange/blob/master/MultiServerReadme.md

### Todo

- Add 0xBitcoin support
-

README in English
=====================================
Peatio is a free and open-source crypto currency exchange implementation with the Rails framework and other cutting-edge technology.

[ORIGINAL PEATIO README](README-English.md)


text:
---
layout: default
username: Grandpa's Lost Legacy
user_title: Mysterious Ruins, Straightforward Puzzles
focus: "#projects"
permalink: /GrandpasLostLegacy/
---

 Grandpa's Lost Legacy

 Team & Assignment

Project Duration: 2 Weeks

Team: Freya Li (Sound Designer), Wren Tong (Artist), Ruoxi Li (Artist), Charley Li (Programmer), Myself (Programmer & Producer)

This assignment was to create an experience that is "naive-guest" friendly. That is to say, as accessible as possible.

 Overview

Grandpa's Lost Legacy was an experience designed with naive guests in mind. My team and I crafted it with the hope that we could both tell a story of old, unsolved mysteries and ancient ruins while also preventing new players from becoming too stuck or confused at any point. To this end, we had a firefly particle system, the brightest moving object in the scene, that would constantly be flying from the tip of the player's staff to their next objective. The player's main goal was to trace patterns on the stones, which are all relatively simple. Some curveballs thrown include spider-webs blocking the stone or the stone needing to be rotated using the player's hand.

 My Contributions

I was both producer and programmer for this project. I scheduled and helped mediate our discussions. I made sure to solicit the opinions and ideas of all present so that we could make the best possible product. On the programming side, I handled many varied tasks. I created the firefly particle system and wrote the script that guided them from one stone to another. I also handled the general sequence of events for the game, going from the map to ruins to floating rocks to study, and the required steps to achieve them therein. I put the webbing in the world and used Unity's cloth system to make them appear more sticky and interactable. My fellow programmer helped out with some of these tasks, but was primarily responsible for writing the pattern-tracing mechanic.

 Challenges

Most of our challenge came from our feedback or indirect control not being strong or intuitive enough. For example, people would often try to sweep away the webs, but it originally took too long to clear them and would leave guests confused and frustrated. The rotating stone near the end originally did not have a handprint on the back, which left guests perplexed as to what to do with it and why this particular stone had no pattern to trace. We did our best to rectify these problems and other smaller issues like them by playtesting with a variety of naive guests. We briefly interviewed them afterwards, taking notes on their feedback and performance to allow us to make more informed design decisions.

    Check it out