text:
#Products

##Index

List of products

`GET /api/products`

**Parameters**

Parameter | Function | Form
--------- | -------- | ----
page | To get an specific page of products | `GET /api/products?page=2`
per_parge | The number of products to get per page | `GET /api/products?per_page=25`

**Successful status**

`Status code: 200`

> Request response

```
{
	"pages": 5,
	"currentPage": 1,
	"count": 25,
	"products": [
		{
			"productId": 1,
			"name": "Example product",
			"description": "This is the description for a product",
			"displayPrice": "15.99",
			"permalink": "ruby-on-rails-tote",
			"availableOn": "2012-10-17T03:43:57Z",
			"images": {
				"miniUrl": "https://bucket.com/12343242323423",
				"smallUrl": "https://bucket.com/12343242323423",
				"normalUrl": "https://bucket.com/12343242323423",
				"largeUrl": "https://bucket.com/12343242323423"
       		}
       }
   ]
}
```

##Show

Details of a product

By _permalink_:

`GET /api/products/a-product`

By _id_:

`GET /api/products/123`

**Successful status**

`Status code: 200`

>Request response

```
{
	"master": {
		"productId": 1,
		"name": "Example product",
		"description": "This is a product example.",
		"displayPrice": "15.99",
		"permalink": "ruby-on-rails-tote",
		"inStock": true,
		"availableOn": "2012/10/17 14:04",
		"images": {
				"miniUrl": "https://bucket.com/12343242323423",
				"smallUrl": "https://bucket.com/12343242323423",
				"normalUrl": "https://bucket.com/12343242323423",
				"largeUrl": "https://bucket.com/12343242323423"
       }
	},
	"variants": [
		{
			"productId": 1,
			"name": "Example product",
			"description": "This is a product example.",
			"displayPrice": "15.99",
			"permalink": "ruby-on-rails-tote",
			"inStock": true,
			"availableOn": "2012/10/17 14:04",
			"images": {
					"miniUrl": "https://bucket.com/12343242323423",
					"smallUrl": "https://bucket.com/12343242323423",
					"normalUrl": "https://bucket.com/12343242323423",
					"largeUrl": "https://bucket.com/12343242323423"
       	}
		},
		{
			"productId": 1,
			"name": "Example product",
			"description": "This is a product example.",
			"displayPrice": "15.99",
			"permalink": "ruby-on-rails-tote",
			"inStock": true,
			"availableOn": "2012/10/17 14:04",
			"images": {
					"miniUrl": "https://bucket.com/12343242323423",
					"smallUrl": "https://bucket.com/12343242323423",
					"normalUrl": "https://bucket.com/12343242323423",
					"largeUrl": "https://bucket.com/12343242323423"
       	}
		}
	]
}
```

repository: ciscoflores/slate

repo_name: ciscoflores/slate


text:
# 1.7.1

* FIX: BSON 4+ returns BSON::Document instead of Hash, [#15](https://github.com/Sign2Pay/mongoid-archivable/pull/15)

# 1.7.0

* `restore` returns nil if save unsuccessful, [#14](https://github.com/Sign2Pay/mongoid-archivable/pull/14)
* added `restore!` method, [#14](https://github.com/Sign2Pay/mongoid-archivable/pull/14)
* updated `ProcessLocalizedFields` to correctly restore embedded polymorphic relations, [#13](https://github.com/Sign2Pay/mongoid-archivable/pull/13)

# 1.6.0

* Support different database or client for archived documents, [#12](https://github.com/Sign2Pay/mongoid-archivable/pull/12), thanks to [@jackbit](https://github.com/jackbit)

# 1.5.2

* correctly restore localized fields on self and embedded documents

# 1.5.0

* support Mongoid 6

license: MIT

branch_name: refs/heads/master

extension: md

gha_language: Ruby

gha_license_id: MIT

license_type: permissive


text:
# allure-report-attachments-cleaner
![views](https://raw.githubusercontent.com/aleksandr-kotlyar/allure-report-attachments-cleaner/traffic-2021/traffic-allure-report-attachments-cleaner/views.svg)
![views](https://raw.githubusercontent.com/aleksandr-kotlyar/allure-report-attachments-cleaner/traffic-2021/traffic-allure-report-attachments-cleaner/views_per_week.svg)
![clones](https://raw.githubusercontent.com/aleksandr-kotlyar/allure-report-attachments-cleaner/traffic-2021/traffic-allure-report-attachments-cleaner/clones.svg)
![clones](https://raw.githubusercontent.com/aleksandr-kotlyar/allure-report-attachments-cleaner/traffic-2021/traffic-allure-report-attachments-cleaner/clones_per_week.svg)

Script to free space from unnecessary AllureReport attachments.

### Usage example
Execute python script file with python and send it AllureReport path and status to filter attachments you want to remove.
```python
python clean_allure_attachments.py allure-report passed
```

### Algorithm
1. From `allure-report/data/test-cases/` files collect all `*.json` files with some "status". As example: "passed".
2. From each collected "passed" test-case jsonFile get all "attachments.source" from "beforeStage" "testStage" "afterStage" steps and sub-steps.
3. Go to `allure-report/data/attachments/` and clean each "attachment.source" one by one.
4. Rewrite all necessary test-cases with empty `"attachments": [ ]`.


text:
# Using TensorTrade for Making a Simple Trading Algorithm

This project serves as a guide for how to make basic trading algorithms in TensorTrade. This code can either run locally or within a Docker container. Just make sure that all the libraries needed are properly downloaded.

```sh
$ pip install -r requirements
```

If you are going to run the code locally use,
```sh
$ python scripts/main.py
```

If you are going to run the in the docker container use,
```sh
$ docker build -t ssc .
$ docker run -it -v <absolute-project-path>:/app --entrypoint /bin/bash ssc
$ python scripts/main.py
$ exit
```

repository: KY-BChain/simple-sine-curve

branch_name: refs/heads/main

repo_name: KY-BChain/simple-sine-curve


text:
/builder was the bridge between ORQ v1.0 and the modern Rails version.

In ORQ v.10 issues used to get built out from Google Docs to a set of .html files using Python. This all got held together by a [Middleman](http://middlemanapp.com/) app, which is basically Rails without a database.

The code currently in /builder used Python to convert those files into series of Rails database **.new()** calls to be run through the console to build out the initial database.

repository: adamgreenhall/openreviewquarterly

repo_name: adamgreenhall/openreviewquarterly


text:
## **v0.4.0**

* Added new models (SentenceTransformers, Gensim, USE, Spacy)
* Added `.fit`, `.transform`, and `.fit_transform` methods
* Added `.save` and `PolyFuzz.load()`

**SentenceTransformers**
```python
from polyfuzz.models import SentenceEmbeddings
distance_model = SentenceEmbeddings("all-MiniLM-L6-v2")
model = PolyFuzz(distance_model)
```

**Gensim**
```python
from polyfuzz.models import GensimEmbeddings
distance_model = GensimEmbeddings("glove-twitter-25")
model = PolyFuzz(distance_model)
```

**USE**
```python
from polyfuzz.models import USEEmbeddings
distance_model = USEEmbeddings("https://tfhub.dev/google/universal-sentence-encoder/4")
model = PolyFuzz(distance_model)
```

**Spacy**
```python
from polyfuzz.models import SpacyEmbeddings
distance_model = SpacyEmbeddings("en_core_web_md")
model = PolyFuzz(distance_model)
```

**fit, transform, fit_transform**
Add `fit`, `transform`, and `fit_transform` in order to use PolyFuzz in production [#34](https://github.com/MaartenGr/PolyFuzz/issues/34)

```python
from sklearn.datasets import fetch_20newsgroups
from sklearn.feature_extraction.text import CountVectorizer
from polyfuzz import PolyFuzz

train_words = ["apple", "apples", "appl", "recal", "house", "similarity"]
unseen_words = ["apple", "apples", "mouse"]

# Fit
model = PolyFuzz("TF-IDF")
model.fit(train_words)

# Transform
results = model.transform(unseen_words)
```

In the code above, we fit our TF-IDF model on `train_words` and use `.transform()` to match the words in `unseen_words` to the words that we trained on in `train_words`.

After fitting our model, we can save it as follows:

```python
model.save("my_model")
```

Then, we can load our model to be used elsewhere:

```python
from polyfuzz import PolyFuzz

model = PolyFuzz.load("my_model")
```

## **v0.3.4**

- Make sure that when you use two lists that are exactly the same, it will return 1 for identical terms:

```python
from polyfuzz import PolyFuzz

from_list = ["apple", "house"]
model = PolyFuzz("TF-IDF")
model.match(from_list, from_list)
```

This will match each word in `from_list` to itself and give it a score of 1. Thus, `apple` will be matched to `apple` and
`house` will be mapped to `house`. However, if you input just a single list, it will try to map them within the list without
mapping to itself:

```python
from polyfuzz import PolyFuzz

from_list = ["apple", "apples"]
model = PolyFuzz("TF-IDF")
model.match(from_list)
```

In the example above, `apple` will be mapped to `apples` and not to `apple`. Here, we assume that the user wants to
find the most similar words within a list without mapping to itself.

## **v0.3.3**
- Update numpy to "numpy>=1.20.0" to prevent [this](https://github.com/MaartenGr/PolyFuzz/issues/23) and this [issue](https://github.com/MaartenGr/PolyFuzz/issues/21)
- Update pytorch to "torch>=1.4.0,<1.7.1" to prevent save_state_warning error

## **v0.3.2**
- Fix exploding memory usage when using `top_n`

## **v0.3.0**
- Use `top_n` in `polyfuzz.models.TFIDF` and `polyfuzz.models.Embeddings`

## **v0.2.2**
- Update grouping to include all strings only if identical lists of strings are compared

## **v0.2.0**
- Update naming convention matcher --> model
- Update documentation
- Add basic models to grouper
- Fix issues with vector order in cosine similarity
- Update naming of cosine similarity function

## **v0.1.0**
- Additional tests
- More thorough documentation
- Prepare for public release

## **v0.0.1**
- First release of `PolyFuzz`
- Matching through:
    - Edit Distance
    - TF-IDF
    - Embeddings
    - Custom models
- Grouping of results with custom models
- Evaluation through precision-recall curves

repository: MaartenGr/PolyFuzz

gha_language: Python

repo_name: MaartenGr/PolyFuzz


text:
# **Discord Distances**
A Discord bot that computes how similarly Discord users text using NLP and word2vec finetuning.

## **Setup**

This bot was designed to work within a Linux environment. Though, it probably still runs in Windows and Mac.

1. Clone the repo ```git clone https://github.com/tdude92/discord-distances.git```
2. Move into the repo from the terminal ```cd ./discord-distances/```
3. Install NodeJS dependencies ```npm install```
4. Install Python dependencies ```pip3 install -r requirements.txt```
5. Run ```python3 config.py``` and input your bot token + other required information.
6. Move into src/ ```cd src/```
7. Start the bot server ```node index.js```
8. Type ```>dd help``` and read the disclaimer.

## **Examples**

Four example users are present in the following demonstrations. *dutwo*, *duthree*, and *dududududu* use Brothers Grimm fairy tales in place of actual message data while *BeeBoi* uses the script of the Bee Movie.

1. Distance between *dutwo* and others

![dutwo example](demo/user_self.jpg)

2. Distance between *duthree* and others

![dutwo example](demo/user_duthree.jpg)

3. Distance between *dududududu* and others

![dutwo example](demo/user_dududududu.jpg)

4. Distance between *BeeBoi* and others

![dutwo example](demo/user_beeboi.jpg)

5. Scatterplot of users in an example guild, **Beep Bop Bot Land**

![guild plot example](demo/guild_plot.jpg)

Notice that *dutwo*, *duthree*, and *dududududu*, who used Brothers Grimm fairy tales for their training data, are grouped together and separated from *BeeBoi*, who used the Bee Movie script for their training data.

## **Features**

1. Dynamically updates the distance in texting style between the users of a Discord guild.
2. Fully automatic! No need to manually update the bot's models.
3. Offers efficient access to information due to caching mechanisms.

For ethical reasons, only users that type ```>dd accept``` will be visible to the **discord-distances** bot.

## **Commands**

![Commands](demo/help.png)

**Some super secret debug commands for dev purposes (for admins only, aka you)**
1. ```>dd errortest```: Throws an error lol. It should get handled by a try-catch.
2. ```>dd lockedecho <text>```: Same as echo but is affected by the lock mechanism (If this command is called while the bot is updating models and distances, execution will be deferred until these computations are complete. The lock is necessary so as to stop the node script and python script from accessing and writing to the same files at the same time).
3. ```>dd testlock <t>```: Activates the locking mechanism for ```t``` seconds.
4. ```>dd update```: Forces the bot to update models and distances. Probably the most useful debug command.


text:
---
layout: documentation
title: Composability
category: authoring
sidebar: sidebars/authoring.md
excerpt: Sometimes generators should work together
---

> Composability is a way to combine smaller parts to make one large thing. Sort of [like Voltron®](http://25.media.tumblr.com/tumblr_m1zllfCJV21r8gq9go11_250.gif)

Yeoman offers multiple ways for generators to build upon common ground. There's no sense in rewriting the same functionality, so an API is provided to use generators inside other generators.

In Yeoman, composability can be initiated in two ways:

 * A generator can decide to compose itself with another generator (e.g., `generator-backbone` uses `generator-mocha`).
 * An end user may also initiate the composition (e.g., Simon wants to generate a Backbone project with SASS and Rails). Note: end user initiated composition is a planned feature and currently not available.

**Note:** The User composability feature landed in core in version **0.17.0**. It is a work in progress but is stable enough to start using. Further documentation will come after a few refinements to the process and can be expected sooner rather than later!

## `generator.composeWith()`

The `composeWith` method allows the generator to run side-by-side with another generator (or subgenerator). That way it can use features from the other generator instead of having to do it all by itself.

When composing, don't forget about [the running context and the run loop](/authoring/running-context.html). On a given priority group execution, all composed generators will execute functions in that group. Afterwards, this will repeat for the next group. Execution between the generators is the same order as `composeWith` was called, see [execution example](#order).

### API

`composeWith` takes three parameters.

 1. `namespace` - A String declaring the namespace of the generator to compose with. The default matches generators installed on the end user's system. Use [`peerDependencies`](https://nodejs.org/en/blog/npm/peer-dependencies/) to install needed generators with this one.
 2. `options` - An Object containing an `options` object and/or an `args` array. The called generator will receive these when it runs.
 3. `settings` - An Object used to declare composition settings. The generator uses these when determining how to run other generators.
    * `settings.local` - A String that defines a path to the requested generator. This allows the use of sub-generators. It also allows the use of a specific version of a generator. To do so, declare it in the [`dependencies` section inside `package.json`](https://docs.npmjs.com/files/package.json#dependencies). Then reference the path to that generator, usually `node_modules/generator-name`.
    * `settings.link` - A String that is either `weak` (default), or `strong`.

      A `weak` link will not run when the composability is user initiated. A `strong` link will always run.

      A `weak` link is for features unrelated to the core of the generator like backend frameworks or CSS preprocessors. A `strong` link is for features requiring an action to occur. An example is scaffolding a _module_ by composing a _route_ generator and a _model_ generator.

When composing with a `peerDependencies` generator:

```js
this.composeWith('backbone:route', { options: {
  rjs: true
}});
```

When composing with a `dependencies` generator:

```js
this.composeWith('backbone:route', {}, {
  local: require.resolve('generator-bootstrap')
});
```
`require.resolve()` returns the path from where Node.js would load the provided module.

### execution example
```js
// In my-generator/generators/turbo/index.js
module.exports = require('yeoman-generator').Base.extend({
  'prompting' : function () {
    console.log('prompting - turbo');
  },

  'writing' : function () {
    console.log('writing - turbo');
  }
});

// In my-generator/generators/electric/index.js
module.exports = require('yeoman-generator').Base.extend({
  'prompting' : function () {
    console.log('prompting - zap');
  },

  'writing' : function () {
    console.log('writing - zap');
  }
});

// In my-generator/generators/app/index.js
module.exports = require('yeoman-generator').Base.extend({
  'initializing' : function () {
    this.composeWith('my-generator:turbo');
    this.composeWith('my-generator:electric');
  }
});
```

Upon running `yo my-generator`, this will result in:

```
prompting - turbo
prompting - zap
writing - turbo
writing - zap
```

However, you can alter this by switching the calls for `this.composeWith`, also keep in mind, these can be generators from npm packages, see below.

For a more complex example of composability, check out
[generator-generator](https://github.com/yeoman/generator-generator/blob/master/app/index.js)
which is composed of
[generator-node](https://github.com/yeoman/generator-node).

## dependencies or peerDependencies

*npm* allows three types of dependencies:

 * `dependencies` get installed local to the generator. It is the best option to control the version of the dependency used. This is the preferred option.
 * `peerDependencies` get installed alongside the generator, as a sibling (* See note at bottom). If `generator-backbone` declared `generator-gruntfile` as a peer dependency, the folder tree would look this way:

    ```
    ├───generator-backbone/
    └───generator-gruntfile/
    ```
 * `devDependencies` for testing and development utility. This is not needed here.

When using `peerDependencies`, be aware other modules may also need the requested module. Take care not to create version conflicts by requesting a specific version (or a narrow range of versions). Yeoman's recommendation with `peerDependencies` is to always request _higher or equal to (>=)_ or _any (*)_ available versions. For example:

```json
{
  "peerDependencies": {
    "generator-gruntfile": "*",
    "generator-bootstrap": ">=1.0.0"
  }
}
```

**Note**: as of npm@3, `peerDependencies` are no longer automatically installed. To install these dependencies, they must be manually installed: `npm install generator-yourgenerator generator-gruntfile<EMAIL_ADDRESS>

branch_name: refs/heads/source

gha_language: CSS


text:
# Manage your VDC

The VDCs under your control can be found by clicking on the `LIST VDCS` button of the homepage.

![](cloud__00_vdc_homepage.png  )

A list is shown of available VDCs, with a link to the VDC itself, or to manager the funding of the capacity for it. On the same page, you can also start the setup of a new VDC.

![](cloud__11_vdc_overview.png  )

Clicking on the url link of the VDC brings you to a login page. Log in using your Threefold Connect App.

![](cloud__21_vdc_portal_login.png  )

Before starting to run your VDC, a welcome screen is shown, as well as `Terms and conditions`. Please have a read and push `Àgree` before continuing.

![](cloud__22_vdc_portal_welcome.png  )

![](cloud__23_vdc_portal_t_and_c.png  )

The portal is made of two parts. In case you are in the Marketplace, you can easily switch to `MY VDC`by clicking the button in the upper right corner.

![](cloud__vdc_portal_marketplace.png  )

The `COMPUTE NODES` section of `MY VDC` part shows you the Kubernetes cluster that has been created corresponding to the chosen size.

![](cloud__24_vdc_portal_compute.png  )

Details on both master and workers are visible.

![](cloud__25_vdc_portal_compute_detail_master.png  )

![](cloud__26_vdc_portal_storage_nodes.png  )


text:
---
layout: page
title: split-bins [artifact]
categories: [anvio]
comments: false
image:
  featurerelative: ../../../images/header.png
  display: true
---

{% include _toc.html %}

A CONCEPT-type anvi'o artifact. This artifact is typically generated, used, and/or exported **by anvi'o** (and not provided by the user)..

Back to the **[main page](../../)** of anvi'o programs and artifacts.

## Provided by

[anvi-split](../../programs/anvi-split)

## Required or used by

There are no anvi'o tools that use or require this artifact directly, which means it is most likely an end-product for the user.

## Description

This is the result of [anvi-split](/software/anvio/help/7/programs/anvi-split): self-contained anvi'o projects that contain just the contents of a single [bin](/software/anvio/help/7/artifacts/bin) from your original database.

This describes a directory that either contains either a [genomes-storage-db](/software/anvio/help/7/artifacts/genomes-storage-db) and [pan-db](/software/anvio/help/7/artifacts/pan-db) (if that's what you gave [anvi-split](/software/anvio/help/7/programs/anvi-split) as an input) or a [profile-db](/software/anvio/help/7/artifacts/profile-db) and [contigs-db](/software/anvio/help/7/artifacts/contigs-db) pair. The contigs or genomes and gene clusters described in these databases will be only those contained in the bin that the directory's name corresponds to.

{:.notice}
Edit [this file](https://github.com/merenlab/anvio/tree/master/anvio/docs/artifacts/split-bins.md) to update this information.

repository: genomewalker/web

repo_name: genomewalker/web


text:
# Vector allocator
An allocator with memory pool which can support std::vector for homework.

It is as fast as std::allocator, or maybe faster.

For awesome speed performance, you may use -O3 to compile this code.


text:
# UnityExtensions
[![openupm](https://img.shields.io/npm/v/net.slothsoft.unity-extensions?label=openupm&registry_uri=https://package.openupm.com)](https://openupm.com/packages/net.slothsoft.unity-extensions/)

C# extension functions, attributes and editor tools for common Unity problems.

[Documentation](https://faulo.github.io/UnityExtensions/api/Slothsoft.UnityExtensions.html)

## Key features:
- Additional Linq-like IEnumerable extensions.
- Expandable attribute, to in-place edit asset references.
- HDRP <=> URP Asset converter.
- Project file fixer, to set C# version and warning level for .csproj files.
- A .cs template for proper namespace support.
- A WebGL template for use in iframes.

## Requirements
- Unity 2020.3

## Installation
### Install via manifest.json
The package is available on the [openupm registry](https://openupm.com/packages/net.slothsoft.unity-extensions/). The easiest way to install it is to set up a scoped registry via Unity's manifest.json:
```
{
  "scopedRegistries": [
    {
      "name": "OpenUPM",
      "url": "https://package.openupm.com",
      "scopes": [
		"net.slothsoft.unity-extensions"
      ]
    }
  ],
  "dependencies": {
    "net.slothsoft.unity-extensions": "2.5.0",
  }
}
```

### Install via OpenUPM-CLI
Alternatively, you may install it via [openupm-cli](https://github.com/openupm/openupm-cli):
```
openupm add net.slothsoft.unity-extensions
```

repository: Faulo/UnityExtensions

repo_name: Faulo/UnityExtensions


text:
# neo4j-social-network
A simple social network I made using Neo4j, a graph database, and Flask in Python. You can create users who can connect over multiple popular mediums such as Facebook, Twitter, Snapchat and Instagram.

It uses the 1.6.4 py2neo library to interface with the graph database (only tested with Neo4j version 2.0.2).

Most of the logic is in app/neo4j.py

Terminology:

mekid - the user identifier or username

konnect - connect


text:
---
title: Clustering
page_title: Clustering
description: Check our "Clustering" documentation article for the RadMap {{ site.framework_name }} control.
slug: radmap-heatures-visualization-layer-clustering
tags: clustering
published: True
position: 11
---

# Clustering

Many applications operate with collections of items which are placed close to others and it's uncomfortable to use them as separate objects for low zoom levels. The __VisualizationLayer__ supports the __Clustering__ feature. It allows grouping of items according to condition.

* [Using of the clustering](#using-of-the-clustering)
* [Clustering Invalidated Event](#clustering-invalidated-event)
* [Items Grouping Example](#items-grouping-example)
* [DefaultClusterGenerator class](#defaultclustergenerator-class)
* [The ClusterData object](#the-clusterdata-object)

## Using of the clustering

The __VisualizationLayer__ exposes the following properties which are related to the __Clustering__ feature:

* __ClusterGenerator__: Gets or sets an instance of the class which implements the __IClusterGenerator__ interface. It can be used when you want to define your own grouping algorithm. As default it uses the instance of the built-in __DefaultClusterGenerator__ class.

* __ClusteringEnabled__: Gets or sets a __boolean__ value which indicates whether the clustering is enabled.

* __ClusteringEnabledThreshold__: A property of type __int__ that gets or sets clustering enabled threshold. This value sets the max zoom level for clustering. If current zoom level of the control is greater than this value then clustering will be disabled.

>tipYou should set the __AutoCalculateClusteringThreshold__ to __False__ to allow the RadMap to respect the __ClusteringEnabledThreshold__. The default value of this property is __True__. This means that you need to explicitly set it to false in all cases when you need to predefine the clustering threshold.

* __ClusteringEnabledThresholdMinItems__: A property of type __int__ that gets or sets the minimum number of items in the cluster for auto calculated clustering threshold. The clustering threshold will be set if number of the items in every cluster is less than this value.

* __ClusterItemTemplate__: Gets or sets the data template which represents the cluster item.

* __ClusterTemplateSelector__: Gets or sets the custom logic for choosing a template used to display each cluster.

* __DefaultClusterTemplate__: Gets or sets the default cluster data template. It’s used when the __ClusterTemplateSelector__ and __ClusterItemTemplate__ properties are not specified.

* __GenerateClustersOnZoom__: A property of type __bool__ that gets or sets value which indicates whether clusters should be re-generated when the zoom level is changed. The default value of this property is __true__.

In order to enable the __Clustering__ feature you can specify just the __ClusteringEnabled__ property to __true__. Also you can configure the __ItemTemplate__ and __ClusterItemTemplate__ properties for customizing the appearance of the item and of the cluster.

More information about using of the __ItemTemplate__ property you can find in the [Data Binding]({%slug radmap-visualization-layer-data-binding%}) article.

## ClustersInvalidated Event

To get notified when the cluster elements are created, the __ClustersInvalidated__ event of the VisualizationLayer can be utilized.

#### __[XAML] Example 1: Subscribe to ClustersInvalidated event__

{{region xaml-radmap-visualization-layer-clustering_0}}
    <telerik:VisualizationLayer x:Name="VisualizationLayer1" ClustersInvalidated="VisualizationLayer_ClustersInvalidated"/>
{{endregion}}

#### __[C#] Example 2: ClustersInvalidated event handler__

{{region csharp-radmap-visualization-layer-clustering_1}}
    private void VisualizationLayer_ClustersInvalidated(object sender, System.EventArgs e)
	{
		// custom logic
	}
{{endregion}}

## Items Grouping Example

The following example demonstrates how to use the __Clustering__ feature to display the airports of USA. The example displays the point type data which can be found in the “airports” shape-file of our {% if site.site_name == 'WPF' %}[Virtualization and Grouping](https://demos.telerik.com/wpf/#Map/ClusterVirtualization){% endif %}{% if site.site_name == 'Silverlight' %}[Virtualization and Grouping](https://demos.telerik.com/silverlight/#Map/ClusterVirtualization){% endif %} demo. The file contains 940 airports.

If you try to load this file using the shape-file reader directly, like the sample XAML code below, then the performance of zooming and panning will be slow. Also the data items will be overlapped for low zoom levels (1-7).

#### __[XAML] Example 3: Displaying Airports of USA__
{{region radmap-visualization-layer-clustering_4}}
    <UserControl x:Class="ItemsGroupingExample.MainPage"
                 xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
                 xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
                 xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
                 xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
                 xmlns:telerik="http://schemas.telerik.com/2008/xaml/presentation"
                 d:DesignHeight="300"
                 d:DesignWidth="400"
                 mc:Ignorable="d">
        <Grid x:Name="LayoutRoot">
            <telerik:RadMap x:Name="RadMap1"
                            Center="40, -100"
                            ZoomLevel="3">
                <telerik:RadMap.Provider>
                    <telerik:OpenStreetMapProvider />
                </telerik:RadMap.Provider>
                <telerik:VisualizationLayer x:Name="VisualizationLayer1">
                    <telerik:VisualizationLayer.Reader>
                        <telerik:AsyncShapeFileReader Source="/ItemsGroupingExample;component/Resources/airports.shp" ToolTipFormat="AIRPT_NAME" />
                    </telerik:VisualizationLayer.Reader>
                </telerik:VisualizationLayer>
            </telerik:RadMap>
        </Grid>
    </UserControl>
{{endregion}}

Here is a snapshot of the displayed items for zoom level 3:

![Rad Map Features Virtualization Layer Clustering](images/RadMap_Features_VirtualizationLayer_Clustering.png)

Such performance is a reason to use the __Clustering__ feature to improve the performance of rendering. Also, it allows to avoid displaying the overlapped objects which are placed close to others.

You can set the __ClusteringEnabled__ property to __true__ for enabling the feature.

#### __[XAML] Example 4: Enable clustering functionality__

{{region xaml-radmap-visualization-layer-clustering_5}}
    <telerik:VisualizationLayer x:Name="VisualizationLayer1" ClusteringEnabled="True">
        <telerik:VisualizationLayer.Reader>
            <telerik:AsyncShapeFileReader Source="/ItemsGroupingExample;component/Resources/airports.shp" ToolTipFormat="AIRPT_NAME" />
        </telerik:VisualizationLayer.Reader>
    </telerik:VisualizationLayer>
{{endregion}}

Here is a snapshot of the displayed items for zoom level 3 when the grouping is used:

![Rad Map Features Virtualization Layer Clustering 1](images/RadMap_Features_VirtualizationLayer_Clustering_1.png)

By default the cluster looks like above and it shows how many items it contains.

You can configure the __ItemTemplate__ and __ClusterItemTemplate__ properties to customize the appearance of the item and of the cluster.

#### __[XAML] Example 5: Customizing the appearance of the cluster__
{{region radmap-visualization-layer-clustering_6}}
    <UserControl x:Class="ItemsGroupingExample.MainPage"
                 xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
                 xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
                 xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
                 xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
                 xmlns:telerik="http://schemas.telerik.com/2008/xaml/presentation"
                 d:DesignHeight="300"
                 d:DesignWidth="400"
                 mc:Ignorable="d">
        <UserControl.Resources>
            <DataTemplate x:Key="ItemTemplate">
                <Border>
                    <telerik:MapLayer.HotSpot>
                        <telerik:HotSpot ElementName="Pin"
                                         X="0.5"
                                         Y="1.0" />
                    </telerik:MapLayer.HotSpot>
                    <Canvas x:Name="Pin"
                            Width="20"
                            Height="32">
                        <Path Width="20.01"
                              Height="32.005"
                              Data="M1054.5088,458.105L1065.5188,458.105C1067.7278,458.105,1069.5188,459.896,1069.5188,462.105L1069.5188,473.084C1069.5188,475.293,1067.7278,477.084,1065.5188,477.084C1065.5188,477.084,1062.6868,476.831,1062.2128,479.103C1061.6608,481.751,1060.2208,489.11,1060.2208,489.11L1059.3548,489.11C1059.3548,489.11,1058.0138,482.546,1057.2888,479.106C1056.8538,477.041,1054.5088,477.084,1054.5088,477.084C1052.2998,477.084,1050.5088,475.293,1050.5088,473.084L1050.5088,462.105C1050.5088,459.896,1052.2998,458.105,1054.5088,458.105z"
                              Fill="Yellow"
                              Stretch="Fill"
                              Stroke="Black"
                              StrokeEndLineCap="Flat"
                              StrokeLineJoin="Miter"
                              StrokeMiterLimit="10"
                              StrokeStartLineCap="Flat"
                              StrokeThickness="1" />
                        <Path Canvas.Left="3.188"
                              Canvas.Top="2.989"
                              Width="13.42"
                              Height="14.219"
                              Data="M1066.6162,472.8125C1066.6212,473.9125,1065.7252,474.8125,1064.6252,474.8125L1055.2502,474.8125C1054.1502,474.8125,1053.2462,473.9125,1053.2412,472.8125L1053.1962,462.5935C1053.1912,461.4935,1054.0872,460.5935,1055.1872,460.5935L1064.5622,460.5935C1065.6622,460.5935,1066.5662,461.4935,1066.5712,462.5935z"
                              Fill="Black"
                              Stretch="Fill" />
                    </Canvas>
                </Border>
            </DataTemplate>

            <DataTemplate x:Key="ClusterTemplate">
                <Border Background="#af3f3f3f"
                        CornerRadius="3"
                        telerik:MapLayer.HotSpot="0.5,0.5">
                    <StackPanel x:Name="Text" Margin="3">
                        <TextBlock HorizontalAlignment="Center"
                                   Foreground="Yellow"
                                   Text="{Binding Path=Count}" />
                    </StackPanel>
                </Border>
            </DataTemplate>
        </UserControl.Resources>

        <Grid x:Name="LayoutRoot">
            <telerik:RadMap x:Name="RadMap1"
                            Center="40, -100"
                            ZoomLevel="3">
                <telerik:RadMap.Provider>
                    <telerik:OpenStreetMapProvider />
                </telerik:RadMap.Provider>
                <telerik:VisualizationLayer x:Name="VisualizationLayer1"
                                            ClusterItemTemplate="{StaticResource ClusterTemplate}"
                                            ClusteringEnabled="True"
                                            ItemTemplate="{StaticResource ItemTemplate}">
                    <telerik:VisualizationLayer.Reader>
                        <telerik:AsyncShapeFileReader Source="/ItemsGroupingExample;component/Resources/airports.shp" ToolTipFormat="AIRPT_NAME" />
                    </telerik:VisualizationLayer.Reader>
                </telerik:VisualizationLayer>
            </telerik:RadMap>
        </Grid>
    </UserControl>
{{endregion}}

There are the results of using custom templates for clusters and items:
![Rad Map Features Virtualization Layer Clustering 2](images/RadMap_Features_VirtualizationLayer_Clustering_2.png)
![Rad Map Features Virtualization Layer Clustering 3](images/RadMap_Features_VirtualizationLayer_Clustering_3.png)

## DefaultClusterGenerator class

The VisualizationLayer has an __IClusterGenerator__ instance member which is responsible for the clustering behavior. By default it uses an instance of the built-in __DefaultClusterGenerator class__. This class can be used to customize the default grouping algorithm. The __DefaultClusterGenerator class__ exposes the following properties:

* __AutoExpandWhenSingle:__ A property of type __Boolean__ that gets or sets the value which indicates whether cluster should be automatically expanded when it contains one data item only.
* __CloseDistance:__ A property of type __double[]__ that gets or sets an array of the doubles which every item define the max distance between the cluster center and the item for the corresponding ZoomLevel.
* __DeleteWhenEmpty:__ A property of type __Boolean__ that gets or sets the value which indicates whether cluster should be deleted if it is empty.
* __ExpandRadius:__ A property of type __double__ that gets or sets the radius (in pixels) which will be used to calculate coordinates of the items when a cluster is expanded to the polygon vertices.
* __HideExpanded:__ A property of type __Boolean__ that gets or sets whether expanded cluster should be hidden or not.
* __Layer:__ A property of type __VisualizationLayer__ that gets or sets layer which the current map belongs to.

The __DefaultClusterGenerator__ class also provides several methods which can be overridden in order to further customize the clustering algorithm.

* __CreateCluster(Location center, object item):__ This method creates a cluster at the specified location.
* __IsItemInClusterRegion(ClusterData cluster, MapObjectInfo info, int zoomLevel):__ This method checks if a data item belongs to a given cluster.
* __RegenerationNeeded(ClusterData cluster, int zoomLevel)__: This method can be overridden so you can customize if given cluster should be regenerated at a given zoom level. The default value is __true__.

## The ClusterData object

The __VisualizationLayer__ uses the __ClusterData__ object to visualize the cluster. The __ClusterData__ exposes the following properties which can be used in applications:

* __AutoCalculateBounds__: Gets or sets value which indicates whether bounding box of the cluster should be calculated automatically.

* __AutoExpandWhenSingle__: Gets or sets value which indicates whether cluster should be automatically expanded when it contains 1 data item only.

* __Bounds__: Gets or sets bounding box of the cluster.

* __Children__: Gets data items which belong to this cluster.

* __ClusterState__: A property of type __ClusterState__ that gets or sets state of the cluster. It can be __Collapsed__, __Expanded__ and __ExpandedToPolygon__. The difference between expanded cluster and cluster expanded to polygon is as following: the expanded cluster uses original locations of the items to show them, the cluster which is expanded to polygon uses vertices of the regular polygon with center at the cluster’s center to show items.

* __Count__: Gets number of the items in the cluster.

* __Data__: Gets or sets additional cluster's data. This data can be used to pass extra information to the cluster's data template or by cluster generator when detecting belonging of the item to the particular cluster.

* __DeleteWhenEmpty__: Gets or sets value which indicates whether cluster should be deleted if it is empty.

* __ExpandRadius__: Gets or sets radius (in pixels) which will be used to calculate coordinates of the items when cluster is expanded to the polygon vertices.

* __HideExpanded__: Gets or sets value which indicates whether the expanded cluster should be hidden.

* __Hotspot__: Gets or sets hotspot of the cluster.

* __Location__: Gets or sets center of the cluster.

* __ZIndex__: Gets or sets the Z-Index of the cluster.

Many of these properties are used by the cluster generator, only. It calculates them automatically during the process of generating clusters. Usually, applications use the __ClusterState__ property to expand the cluster’s items. The following example demonstrates how this can be achieved.

## Expand Cluster Example

The __ClusterState__ property allows displaying the items of cluster without increasing of the zoom level. You can attach the mouse events in the cluster template like the XAML code below.

#### __[XAML] Example 6: Subscribing to MouseLeftButtonDown and MouseRightButtonDown events__
{{region radmap-visualization-layer-clustering_7}}
    <DataTemplate x:Key="ClusterTemplate">
        <Border Background="#af3f3f3f"
                CornerRadius="3"
                MouseLeftButtonDown="ExpandClusterToPolygon"
                MouseRightButtonDown="ExpandCluster"
                telerik:MapLayer.HotSpot="0.5,0.5">
            <StackPanel x:Name="Text" Margin="3">
                <TextBlock HorizontalAlignment="Center"
                           Foreground="Yellow"
                           Text="{Binding Path=Count}" />
            </StackPanel>
        </Border>
    </DataTemplate>
{{endregion}}

The following *MouseLeftButtonDown* event handler uses to expand the items of cluster to the polygon vertices:

#### __[C#] Example 8: MouseLeftButtonDown event handler__
{{region radmap-visualization-layer-clustering_9}}
	private void ExpandClusterToPolygon(object sender, MouseButtonEventArgs e)
	{
	    FrameworkElement element = sender as FrameworkElement;
	    if (element != null)
	    {
	        ClusterData data = element.DataContext as ClusterData;
	        if (data != null)
	        {
	            if (data.ClusterState != ClusterState.ExpandedToPolygon)
	            {
	                data.HideExpanded = false;
	                data.ClusterState = ClusterState.ExpandedToPolygon;
	            }
	            else
	            {
	                data.ClusterState = ClusterState.Collapsed;
	            }
	        }
	    }

	    e.Handled = true;
	}
{{endregion}}

#### __[VB.NET] Example 8: MouseLeftButtonDown event handler__
{{region radmap-visualization-layer-clustering_10}}
    Private Sub ExpandClusterToPolygon(sender As Object, e As MouseButtonEventArgs)
        Dim element As FrameworkElement = TryCast(sender, FrameworkElement)
        If element IsNot Nothing Then
            Dim data As ClusterData = TryCast(element.DataContext, ClusterData)
            If data IsNot Nothing Then
                If data.ClusterState <> ClusterState.ExpandedToPolygon Then
                    data.HideExpanded = False
                    data.ClusterState = ClusterState.ExpandedToPolygon
                Else
                    data.ClusterState = ClusterState.Collapsed
                End If
            End If
        End If

        e.Handled = True
    End Sub
{{endregion}}

The following *MouseRightButtonDown* event handler uses to expand the items of cluster to their original locations:

#### __[C#] Example 9: MouseRightButtonDown event handler__
{{region radmap-visualization-layer-clustering_11}}
	private void ExpandCluster(object sender, MouseButtonEventArgs e)
	{
	    FrameworkElement element = sender as FrameworkElement;
	    if (element != null)
	    {
	        ClusterData data = element.DataContext as ClusterData;
	        if (data != null)
	        {
	            if (data.ClusterState != ClusterState.Expanded)
	            {
	                data.HideExpanded = false;
	                data.ClusterState = ClusterState.Expanded;
	            }
	            else
	            {
	                data.ClusterState = ClusterState.Collapsed;
	            }
	        }
	    }

	    e.Handled = true;
	}
{{endregion}}

#### __[VB.NET] Example 9: MouseRightButtonDown event handler__
{{region radmap-visualization-layer-clustering_12}}
    Private Sub ExpandCluster(sender As Object, e As MouseButtonEventArgs)
        Dim element As FrameworkElement = TryCast(sender, FrameworkElement)
        If element IsNot Nothing Then
            Dim data As ClusterData = TryCast(element.DataContext, ClusterData)
            If data IsNot Nothing Then
                If data.ClusterState <> ClusterState.Expanded Then
                    data.HideExpanded = False
                    data.ClusterState = ClusterState.Expanded
                Else
                    data.ClusterState = ClusterState.Collapsed
                End If
            End If
        End If

        e.Handled = True
    End Sub
{{endregion}}

In the snapshots below you can see how the above example will be displayed using different __ClusterState__ values. The __ClusterState__ of cluster which contains six items is __Collapsed__.
![Rad Map Features Virtualization Layer Clustering 4](images/RadMap_Features_VirtualizationLayer_Clustering_4.png)

The __ClusterState__ value is __ExpandedToPolygon__.
![Rad Map Features Virtualization Layer Clustering 5](images/RadMap_Features_VirtualizationLayer_Clustering_5.png)

The __ClusterState__ value is __Expanded__.
![Rad Map Features Virtualization Layer Clustering 6](images/RadMap_Features_VirtualizationLayer_Clustering_6.png)

## See Also
 * [Reading Map Shapes]({%slug radmap-visualization-layer-reading-map-shapes%})

repository: telerik/xaml-docs

gha_language: JavaScript

gha_license_id: NOASSERTION

repo_name: telerik/xaml-docs


text:
# Overview

The Dacast API allows developers to access and integrate the functionality of
Dacast with other applications and websites.

Some example applications that can be built using the Dacast API include:

- A video streaming website or application
- A video on demand website or application
- A live streaming website or application
- A video content management system


text:
+++
# Project title.
title = "Bringing Boosting Black Box Variational Inference to Pyro"

# Date this page was created.
date = 2020-04-05T12:20:00

# Project summary to display on homepage.
summary = "In this project, we contributed an implementation of Boosting Black Box Variational Inference to the Pyro probabilistic programming library."

# Tags: can be used for filtering projects.
# Example: `tags = ["machine-learning", "deep-learning"]`
tags = ["probabilistic-programming", "machine-learning"]

# Optional external URL for project (replaces project detail page).
external_link = ""

# Links (optional).
url_pdf = "https://pyro.ai/examples/boosting_bbvi.html"
url_slides = ""
url_video = ""
url_code = "https://github.com/lorenzkuhn/pyro"

# Custom links (optional).
#   Uncomment line below to enable. For multiple links, use the form `[{...}, {...}, {...}]`.
#links = [{icon_pack = "fab", icon="twitter", name="Follow", url = "https://twitter.com/georgecushen"}]

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

  # Focal point (optional)
  # Options: Smart, Center, TopLeft, Top, TopRight, Left, Right, BottomLeft, Bottom, BottomRight
  focal_point = "Smart"
+++
## Abstract:
In collaboration with [Gideon Dresdner](https://scholar.google.com/citations?user=zCsVb4IAAAAJ&hl=en), [Samuel Harrison](https://scholar.google.co.uk/citations?user=SpoKPkgAAAAJ&hl=en) and [Yu Yao](https://www.tnu.ethz.ch/en/team/faculty-and-scientific-staff/dr-yu-yao.html), I implemented the paper [Boosting Black Box Variational Inference](https://arxiv.org/abs/1806.02185) using Pyro. We have contributed [a tutorial](https://pyro.ai/examples/boosting_bbvi.html) to the Pyro documentation to illustrate how to use our implementation.

To quote from the tutorial: "This tutorial demonstrates how to implement boosting black box Variational Inference in Pyro. In boosting Variational Inference, we approximate a target distribution with an iteratively selected mixture of densities. In cases where a single denisity provided by regular Variational Inference doesn’t adequately approximate a target density, boosting VI thus offers a simple way of getting more complex approximations. We show how this can be implemented as a relatively straightforward extension of Pyro’s SVI."

repository: lorenzkuhn/academic-kickstart

repo_name: lorenzkuhn/academic-kickstart


text:
---
title: "Day 9"
---
import Layout from "../components/layout"

<Layout>

Today I continued learning and practicing with iterators. The Codecademy lesson was notably pretty cool since the last exercise was just finding the right iterators for the result they wanted. Neat-o.

The .findIndex() method will return *the index* of the first occurrence of the element, and if the element doesn't exist it will return -1.

```JS
var favoriteHikes = ["Sky Pond", "Isabelle Glacier", "Chasm Lake", "Crystal Lakes", "Frozen Lake", "Greyrock"];

var startsWithF = favoriteHikes.findIndex(hike => {
  return hike.charAt(0) === "F";
})
console.log(startsWithF);

//output 4

var findShortNamesHikes = favoriteHikes.findIndex(hike => {
  return hike.length < 9;
})
console.log(findShortNamesHikes);

//output 0
```

The .reduce() method is used to reduce the array to a single value. It executes from left-to-right through each value in the array and returns a single value. It will iterate through each element in the array as a for loop.

```JS
var numbersToAdd = [7, 21, 32];

var sumOfNumbersToAdd = numbersToAdd.reduce((accumulator, currentValue) => {
  return accumulator + currentValue
})
console.log(sumOfNumbersToAdd);
//output = 60
```
If we wanted to add the numbers in the array above together and then add 100 to that number it would look like this -
```JS
var sumOfNumbersToAdd = numbersToAdd.reduce((accumulator, currentValue) => {
  return accumulator + currentValue
}, 100)
console.log(sumOfNumbersToAdd);
//output 160
```
The .some() method tests if some of the elements in the array pass a condition. It will return a boolean.

```JS
var favoriteHikes = ["Sky Pond", "Isabelle Glacier", "Chasm Lake", "Crystal Lakes", "Frozen Lake", "Greyrock"];

console.log(favoriteHikes.some((hike) => {
  return hike.length < 9;
}));
//output true
```
Ok! Tomorrow we are going to do the Objects lesson, which is kindof exciting!

While I was learning and coding I listened to Dave Brubeck and this really great podcast about Covid-19 vaccines called *ologies* with Alie Ward.

</Layout>


text:
# Meta
[meta]: #meta
- Name: Create Repo Issues
- Start Date: 2020-08-06
- Author(s): [@dfreilich][https://github.com/dfreilich]
- Status: Superseded
- RFC Pull Request: [rfcs#106](https://github.com/buildpacks/rfcs/pull/106)
- CNB Pull Request: (leave blank)
- CNB Issue: (leave blank)
- Supersedes: [#04](https://github.com/buildpacks/rfcs/blob/main/text/0004-rfc-process.md) (which was [rfc#7](https://github.com/buildpacks/rfcs/pull/7))

# Summary
[summary]: #summary
Once an RFC has been accepted, prior to it being merged in to the [RFC repo](http://github.com/buildpacks/rfcs), the appropriate sub-team maintainers should create issues in the relevant Buildpacks repositories, linking them to the RFC pull request (using [Github references](https://docs.github.com/en/github/writing-on-github/autolinked-references-and-urls#issues-and-pull-requests))

# Definitions
[definitions]: #definitions

* RFC → Request For Comments. It is the process followed by the Cloud Native Buildpacks project, as well as many other OSS ones, to provide a consistent and controlled path for new features to enter the spec, libraries, or tools, so that all stakeholders can be confident about the direction Cloud Native Buildpacks is evolving in.
* FCP → Final Comment Period. This is step taken on a particular RFC when enough discussion of the tradeoffs have taken place and the team is in a position to make a decision. Before entering FCP, super majority of the team must sign off.
* PR → (Github) Pull Request.

# Motivation
[motivation]: #motivation

As the number of RFCs increase, it has become increasingly hard to ensure that a given RFC has been implemented, or will be implemented. This RFC proposes an amendment to the [RFC process](https://github.com/buildpacks/rfcs#rfc-process).

The current RFC process [defines](https://github.com/buildpacks/rfcs#rfc-process) that:
> the team member who merges the pull request should do the following ... Create a corresponding issue in the appropriate repo.

In practice, that adds extra work for the team member who merges in the PR, and it may slip through the cracks occasionally. Additionally, the sub-team maintainers are often the best people to create the issue, given their insight into how it should be implemented.

As an additional consideration, it is often hard to track work from the RFC proposal to the implementation, and difficult to ensure that it was completed. If we use [Github references](https://docs.github.com/en/github/writing-on-github/autolinked-references-and-urls#issues-and-pull-requests) to link the RFC PR to the issue on the appropriate repository, we can better track the work, and be notified when it is fully implemented.

# What it is
[what-it-is]: #what-it-is
This defines a process for sub-team maintainers to open issues on the relevant repositories, after FCP for the RFC concludes, before it is merged in.

# How it Works
[how-it-works]: #how-it-works
When a PR has been accepted (after FCP has concluded), the sub-team maintainers make issues (tagging the RFC PR) in the relevant buildpack repos, and labels the PR `issues-created/<sub-team>` for their respective sub-team. Once all sub-team `issues-created/<sub-team>` labels are set, the RFC PR may be merged in, with references to the CNB issues added to the RFC [metadata](https://github.com/buildpacks/rfcs/blob/main/0000-template.md#meta).

Given an RFC PR #002, which discusses a change relevant to the `pack CLI` to add in a `pack my-bags` command. After discussion in Working Group meetings and votes from the Core Team, the RFC is placed in FCP for 7 days. At the end of those, the platform maintainers should open an issue (issue #005) in the `pack CLI`, which tags the RFC PR. For example,

```
### Description

To enable easier traveling, we would like to add a `pack my-bags` command

### Proposed solution
This issue is a request to implement the proposed solution as detailed in #buildpacks/rfcs#002

### Additional context
- This feature should be documented as part of standard pack CLI commands documentation.
```

After creating the issue, the maintainers of the sub-team should add the label `issues-created/<sub-team>`  to the PR. Alternatively, if a PR isn't relevant to a specific sub-team (for instance, a lifecycle PR that isn't relevant to the platform sub-team), the maintainers of that sub-team should just trivially add the `issues-created/<sub-team>` label upon concluding FCP.

Upon seeing those labels attached to the PR, a member of the core team will merge it in, adding references to the RFC metadata, like so:
```
# Meta
[meta]: #meta
- Name: Pack My Bags
...
- CNB Issue: [buildpacks/pack#005](https://github.com/buildpacks/pack/pull/5)
```

# Drawbacks
[drawbacks]: #drawbacks
N/A

# Alternatives
[alternatives]: #alternatives

- What other designs have been considered?
    * Core member makes the issue(s) → This adds extra responsibility when merging issues
    * Author of the RFC → That was my initial suggestion, but there was a concern that it could make the RFC process less approachable for new contributors, and as a community-driver process, we should take steps to make our process friendly.
    * Anarchy

# Prior Art
[prior-art]: #prior-art

- [LSST DM RFC Process](https://developer.lsst.io/v/DM-5063/processes/decision_process.html#adopting-an-rfc) → `When consensus is established the Assignee should create a set of tickets that specify the implementation work, and then mark the RFC as Adopted in JIRA.`
- [Rust RFC Process](https://github.com/rust-lang/rfcs#implementing-an-rfc) → `Every accepted RFC has an associated issue tracking its implementation in the Rust repository; thus that associated issue can be assigned a priority via the triage process that the team uses for all issues in the Rust repository.`
- [EmberJS RFC Process](https://github.com/emberjs/rfcs#the-rfc-life-cycle) → `Once an RFC becomes active the relevant teams will plan the feature and create issues in the relevant repositories.`

A number of other RFC processes don't define who creates the issues, though they do emphasize that while the author of an RFC is not obligated to implement it, a given RFC having been accepted implies nothing about what priority is assigned to its implementation, nor whether anybody is currently working on it.
Some of those include:
* [GatsbyJS](https://github.com/gatsbyjs/gatsby/tree/master/rfcs#the-rfc-life-cycle)
* [NixOS](https://github.com/NixOS/rfcs#the-rfc-life-cycle)
* [Yarn](https://github.com/yarnpkg/rfcs#the-rfc-life-cycle)
* [React](https://github.com/reactjs/rfcs/blob/master/README.md#the-rfc-life-cycle)

[Swift](https://github.com/apple/swift-evolution/blob/master/process.md#preparing-an-implementation) requires that an RFC be coupled with a PR for its implementation.

# Unresolved Questions
[unresolved-questions]: #unresolved-questions

# Spec. Changes (OPTIONAL)
[spec-changes]: #spec-changes

No. However, this RFC would entail a proposed change to the RFC process, as defined in the https://github.com/buildpacks/rfcs/blob/main/README.md. It would now read:

Once an RFC has been accepted, (a) maintainer(s) from the relevant sub-team(s) should create (an) issue(s) in the relevant repositories to implement the RFC, [referencing](https://docs.github.com/en/github/writing-on-github/autolinked-references-and-urls#issues-and-pull-requests) the RFC PR. At that point, they should add the label `issues-created` to the RFC.

Upon seeing the issue(s) created, the team member who merges the pull request should do the following:
* Assign an id based off the pull request number.
* Rename the file based off the id inside text/.
* Create a corresponding issue in the appropriate repo.
* Fill in the remaining metadata at the top.
* Commit everything.

repository: buildpacks/rfcs

gha_language: Shell

repo_name: buildpacks/rfcs


text:
# Thoughts on what to do next

1. Consider working on Bluetooth detection

   Specifically, the ble_scan.py currently prints the devices detected after a set amount of time right in the terminal.
   Possible considerations include:

   a) writing a loop to scan for devices over a more prolonged period of time

   b) representing the information in a graphical format (will likely be # of devices w.r.t. time)

2. Figure out the graphing scale of the wifi_plot.py file -- Current graph max is at 1 and min at 0

   Should probably add labels to the axes, not sure what the y-label will be but the x-label is time.

   This shouldn't be difficult because the plots are done using matplotlib: command is xlabel('...')


text:
---
title:  "Compare lstsq performance in Python"
date:   2019-04-28 20:00:00
description: Comparing the performance of the least-squares solvers in NumPy, CuPy, and TensorFlow.
keywords: [ Python least squares, tensorflow, benchmarks, svd, cholesky decomposition ]
---

**Edit 2019-05-09: The benchmark has been updated to include the latest CuPy syntax for cupy.linalg.lstsq.**

[CuPy](https://cupy.chainer.org) is a GPU accelerated version of NumPy that is very easy to use. I just submited a [PR](https://github.com/cupy/cupy/pull/2165) which adds ```cupy.linalg.lstsq```, and naturally I wanted to compare the least squares performance to ```numpy.linalg.lstsq```. I also compared ```tensorflow.linalg.lstsq``` as a reasonable alternative. Hopefully this will provide some insight into when it will pay off to solve least squares problems with CuPy instead of NumPy.

**I only have one computer that I was able to run this on so far. I'll update the post if I can run this benchmark on different hardware.**

# Least squares solvers
NumPy and CuPy use singular value decomposition (SVD) to solve least squares problems. NumPy defaults to the *gelsd* [lapack](http://www.netlib.org/lapack/lug/node27.html) routine which is a divide-and-conquer SVD strategy. TensorFlow's *lstsq* defaults to using a [Cholesky decomposition](https://www.tensorflow.org/api_docs/python/tf/linalg/lstsq) which *should be* faster than SVD.

# Benchmark

I have a small benchmark problem which performs piecewise linear least squares fits to a sine wave. The benchmark performs fits with known breakpoint locations for 6 and 20 line segments (which translates to solving least squares problem for 6 or 20 unknown parameters). The number of data points was varied from 100 to 6,309,573. This is an odd number, because I couldn't solve 10**7 data points in the 12 Gb of my GPU's memory. The code to run the benchmark is available [here](https://github.com/cjekel/pwlf_scipy_tf_benchmarks/tree/master/cupy), and the process to run the code was

```shell
python3 sine_benchmark_fixed_six_break_points.py
python3 sine_benchmark_fixed_six_break_points_TFnoGPU.py
python3 sine_benchmark_fixed_twenty_break_points.py
python3 sine_benchmark_fixed_twenty_break_points_TFnoGPU.py
python3 plot_results.py
```

This code basically runs the following:
```python
import tensorflow as tf
import cupy as cp
import numpy as np
import pwlf
from time import time
import os

n_data = 10**6  # number of data points
np.random.seed(256)
# generate sin wave data
x = np.linspace(0, 10, num=n_data)
y = np.sin(x * np.pi / 2)
# add noise to the data
y = np.random.normal(0, 0.05, size=n_data) + y
my_pwlf = pwlf.PiecewiseLinFit(x, y)
A = my_pwlf.assemble_regression_matrix(breaks, my_pwlf.x_data)
Acp = cp.asarray(A)
ycp = cp.asarray(y)

# numpy.linalg.lstsq
t0 = time()
beta_np, _, _, _ = np.linalg.lstsq(A, y, rcond=1e-15)
t1 = time()

# cupy.linalg.lstsq
t2 = time()
beta_cp = cp.linalg.lstsq(Acp, ycp)
t3 = time()
Atf = tf.convert_to_tensor(A)
ytf = tf.convert_to_tensor(y.reshape(-1, 1))
beta_tf_fast = tf.linalg.lstsq(Atf, ytf, fast=True)
beta_tf_not_fast = tf.linalg.lstsq(Atf, ytf, fast=False)

with tf.Session():
    # tf.linalg.lstsq fast=True
    t4 = time()
    beta_tf = beta_tf_fast.eval()
    t5 = time()
```

I've ran the benchmark on the following computers:

| CPU   | GPU     | OS           | TF & NumPy built from source  |
| ------------- | ------------- |:-------------:|:-----:|
| AMD FX-8350  | NVIDIA TITAN Xp    | Linux | Yes |

# Results

The results below compare the run time of the fits against the number of data points. The vertical error bars denote the 10th and 90th percentile, considering a Normal distribution with 90% confidence (from the 10 replicate runs).

![AMD FX 6 line segments]({{ "/" | relative_url  }}assets/2019-04-28/fx_six_breaks.png)
![AMD FX 20 line segments]({{ "/" | relative_url  }}assets/2019-04-28/fx_twenty_breaks.png)

| CPU/GPU        |  lstsq parameters  | Data points      | CuPy x faster NumPy|
| ------------- |:-------------:|:-------------:|:-----:|
| AMD FX-8350/NVIDIA TITAN Xp      | 6 | 6,309,573 | 4.84 |
| AMD FX-8350/NVIDIA TITAN Xp      | 20 | 6,309,573 | 6.54 |

# Disucssion

It appears that the CuPy least squares solver wasn't faster than NumPy until there was at least 100,000 data points. With 6,309,573 data points `cupy.linalg.lstsq` was about 6 times faster than `numpy.linalg.lstsq`.

I should really run this benchmark on a computer with Intel CPU + NVIDIA GPU. Especially since a [previous post](https://jekel.me/2019/Adding-tensorflow-to-pwlf/) hinted that TensorFlow performs significantly better on an Intel CPU, and a Cholesky decomposition should be faster than SVD.

NumPy was built from source using Intel MKL on the AMD FX-8350 which isn't the fastest, however it is the best supported...

# Acknowledgements

The TITAN Xp used for this work was donated by the NVIDIA Corporation.


text:
---
title: "R/Medicine Conference"
author: 'blog.rstudio.com'
date: '2018-08-13'
slug: rmedicine-conference
link: https://blog.rstudio.com/2018/08/13/r-medicine-conference/
categories:
- bloglink
tags:
  - rstats
  - blogrstudiocom
---

The keynote speakers will be: Conference talks will address the use of R in medical applications from Phase I clinical trial design through the analysis of the efficacy of medical therapies in public[... <i class="fas fa-external-link-alt"></i>](https://blog.rstudio.com/2018/08/13/r-medicine-conference/)

repository: mkearney/data-scribers

repo_name: mkearney/data-scribers


text:
---
title: Latest coding...
date: '2005-03-17 00:04:57'
tags:
- photography
---

So I had recently got the shits with part of my site. Nothing much really, just my photographs. When on the site, I want them clean and without borders, BUT, I want them to have a border when not being displayed as part of the website. How to do this without duplicity in images?

Along comes our trusty .htaccess (apache mod_rewrite). Basically, the gist of this is that it changes your url query at the back end (with or without showing you what it changed).

So this is how I did it. I want all jpeg's not called from THIS site to have an additional 15px (default) border. So I go and write a handy little function that will add a 15px white border to an image it is given. All good and well, but how do we get the image to go there when called by a user (such as when I post images on websites for critic). This is where mod_rewrite comes in:

RewriteEngine on
RewriteCond %{HTTP_REFERER} !^http://(www.)?your_domain.blah/ [NC]
RewriteRule (.*)?.(jpe?g)$ your-image-manipulator.php?your_reference=$1.$2 [R]

and you're away... easy eh...

license: Unlicense

extension: markdown

gha_language: CoffeeScript

gha_license_id: Unlicense


text:
```
  _________________________________
< CRON jobs in a cloud native world >
  ---------------------------------
         \   ^__^
          \  (oo)\_______
             (__)\       )\/\
                 ||----w |
                 ||     ||

```

# serverless-python-rds-cron

![Build status](https://github.com/caulagi/serverless-python-rds-cron/workflows/Project%20build/badge.svg?branch=master)

A serverless python example that periodically updates entries in RDS.
For instance, you might want to mark users as inactive if they have not
verified their email after 30 days.

In other words, this project shows how cron jobs can be scheduled as lambda functions.

**Features**

- [x] Error reporting (sentry)
- [x] Logging (via structlog, to stdout)
- [ ] Monitoring (TODO: probably send slack notification/emails)

```bash
$ python3.7 -m venv .venv
$ source ./venv/bin/activate
$ pip install -r requirements-dev.txt

$ export DATABASE_URL='mysql+pymysql://apa:apa@localhost/customer?charset=utf8mb4'
$ python src/task.py

$ python -m pytest -v
```

## Deploying

This script is meant to be deployed as a [Lambda Cron](https://docs.aws.amazon.com/lambda/latest/dg/tutorial-scheduled-events-schedule-expressions.html)
using [serverless](https://serverless.com/).  You also need [yarn](https://yarnpkg.com/lang/en/)

```bash
$ yarn global add serverless
$ cp .env.yml.example .env.yml

# We can deploy to different stages (environments)
$ serverless deploy -v

# See what we have
$ serverless info

# tail logs for the cronjob function
$ serverless logs -f cleanupCron -t

# invoke the function manually (if a pm pings you or because you can)
$ serverless invoke -f cleanupCron
```

## Fineprint/Don't forget

The tricky/hard part is to make your lambda talk to resources like RDS **and**
outside world. Follow the tutorial [here](https://aws.amazon.com/premiumsupport/knowledge-center/internet-access-lambda-function/)

## Bonus point

Put the database url in secrets manager and get it from there

## LICENSE

Licensed under [MIT](./LICENSE).

repository: caulagi/serverless-python-rds-cron

repo_name: caulagi/serverless-python-rds-cron


text:
---
title: Things to be aware online
layout: post
author: kishan.thayalarajah
permalink: /things-to-be-aware-online/
source-id: 1vOZmQ2JC9_nTOq8tJIYdqTulXcwS3OGeY6VNVBdIVUE
published: true
---
**Things to be aware online**

As we already know there are many things on the internet which could make you happy or make life feel like Hell.However, many people are unaware of this and think that illegal are actually normal because all their peers are doing it.

But,that isn't true most of the victims are peer pressured by others.Also,sexting isn't the only horrible thing there is also revenge porn.Revenge porn, is when you get naked pictures of yourself put on the internet without your permission.

Here are some news article websites on sexting and revenge porn

Revenge porn

[https://www.theguardian.com/commentisfree/2013/nov/19/revenge-porn-victim-maryland-law-change](https://www.theguardian.com/commentisfree/2013/nov/19/revenge-porn-victim-maryland-law-change)

Sexting

[https://www.theguardian.com/society/2015/nov/10/sexting-becoming-the-norm-for-teens-warn-child-protection-experts](https://www.theguardian.com/society/2015/nov/10/sexting-becoming-the-norm-for-teens-warn-child-protection-experts)

That's all From Awesome-Kid.

Sexting and Revengeporn is all part of the

![image alt text]({{ site.url }}/images/wYwcgTPpOvJ4sCpN0KTQ_img_0.png)


text:
---
title: "Adding a New Secret to CI"
description: How to self-service manage secret data provided to jobs during execution.
---

Jobs execute as `Pod`s; those that need access to sensitive information will have access to it through mounted Kubernetes
[`Secrets`](https://kubernetes.io/docs/concepts/configuration/secret/). Secret data is managed self-service by the owners
of the data. While there are many OpenShift clusters in the [CI build farm](/docs/getting-started/useful-links/#clusters),
owners of secret data simply need to add their `Secret` to the `api.ci` cluster and automation will sync the data out to
all environments where jobs execute.

## Add A New Secret

In order to commit secret data to our system, the data will need to be added to the `api.ci` cluster.

All users who wish to interact with the system must [log in](/docs/how-tos/use-registries-in-build-farm/#how-do-i-log-in-to-pull-images-that-require-authentication)
to the `api.ci` cluster.

### Creating the manifests

To manage secrets, some manifests have to be created and committed to our Git-ops
[repository](https://github.com/openshift/release) to ensure that the correct configuration is persisted and that users
can cooperate on changing it.

Choose your namespace name and group of administrators, then create a Pull request adding a YAML file with the contents
to a sub-directory of the `core-services/secrets` directory:

```yaml
# this is the Namespace in which your Secret will live
apiVersion: v1
kind: Namespace
metadata:
  annotations:
    openshift.io/description: Automation Secrets for MyProject
    openshift.io/display-name: MyProject CI
  name: my-project
---
# the Group of people who should be able to manage this Secret
kind: Group
apiVersion: v1
metadata:
  name: my-project-admins
users:
  # these names are GitHub usernames
  - bob
  - tracy
  - jim
  - emily
---
# this adds the admins to the project.
kind: RoleBinding
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  name: my-project-viewer-binding
  namespace: my-project
roleRef:
  kind: ClusterRole
  apiGroup: rbac.authorization.k8s.io
  name: view
subjects:
  - kind: Group
    apiGroup: rbac.authorization.k8s.io
    name: my-project-admins
    namespace: my-project
---
# this grants the right to view and update the Secret
kind: RoleBinding
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  name: my-project-admins-binding
  namespace: my-project
roleRef:
  kind: ClusterRole
  apiGroup: rbac.authorization.k8s.io
  name: secret-namespace-manager
subjects:
  - kind: Group
    apiGroup: rbac.authorization.k8s.io
    name: my-project-admins
    namespace: my-project
```

{{< alert title="Info" color="info" >}}
The above YAML does _not_ contain your secret data. You will still need to create it with a manual invocation
of the `oc` CLI. The `openshift/release` repository is public and not an appropriate place to store sensitive information.
{{< /alert >}}

If your desired namespace exists already, ask the owners of the namespace if it can be shared. After the pull request is
merged, the manifests in the folder will be applied automatically to the `api.ci` cluster and you will be ready to use
the `oc` CLI to persist your secret data:

```shell
$ oc --namespace my-project create secret generic my-secret --from-literal password=hard-to-remember
```

### Propagating Secret Data

In order to propagate your secret data to all environments in which jobs execute, an entry must be added to the mirroring
[configuration](https://github.com/openshift/release/tree/master/core-services/secret-mirroring/_mapping.yaml). The secret
and any modification on it afterwards will be populated to the targeting namespace(s) on [all clusters](/docs/getting-started/useful-links/#clusters)
in the build farm.

```yaml
- from:
    namespace: "my-project"
    name: "my-secret"
  to:
    namespace: "test-credentials" # the namespace holding all secrets used in a step
    name: "my-secret"             # a unique identifier for your secret
```

{{< alert title="Info" color="info" >}}
We are in the process of turning down the `api.ci` cluster which currently hosts the source content for the
secret mirroring process. A new solution for secret management will be in place before `api.ci` is fully removed.
{{< /alert >}}

## Use A Secret In A Job Step

The most common case is to use secrets in a [step](/docs/architecture/step-registry/#step) of a job. In this case, we
**require** the user to mirror secrets to `test-credentials` namespace. The pod which runs the step can access the secrets
defined in `credentials` stanza of the step definition. See [the documentation](https://docs.ci.openshift.org/docs/architecture/step-registry/#injecting-custom-credentials)
for details.

## Use A Secret In Non-Step jobs

{{< alert title="Warning" color="warning" >}}
This section is used only for the jobs that had existed before [Test Step Registry](/docs/architecture/step-registry/)
was introduced and have not yet been converted to multistage tests with steps. It is strongly suggested to use steps for
any new jobs.
{{< /alert >}}

For non-step jobs, we have to use `ci` as the targeting namespace in the secret mirroring configuration.

* For a job which is generated from `ci-operator` configuration and does not use steps, we can mount the secrets via
  `secrets` stanza in the `ci-operator` configuration, e.g.,

```yaml
tests:
- as: "vet"                      # names this test "vet"
  commands: "go vet ./..."       # declares which commands to run
  container:
    from: "src"                  # runs the commands in "pipeline:src"
  secrets:
  - mount_path: "/secret"        # mount path of the extracted files from the secret
    name: "secret-name-in-ci"    # the secret name in the ci namespace
```

* For a job which does not even use `ci-operator` at all, i.e. [handcrafted jobs](/docs/how-tos/contributing-openshift-release/#handcrafted-jobs),
  the following example shows how to use secrets in a job definition. As stated there, **creating handcrafted jobs is discouraged**.

```yaml
postsubmits:
  org/repo:
  - name: bar-job
    branches:
    - ^master$
    spec:                       # Valid Kubernetes PodSpec.
      containers:
      - image: docker.io/hello-world
        name: ""
        volumeMounts:
        - mountPath: "/secret"               # mount path of the extracted files from the secret
          name: "volume-name"
      volumes:
      - name: "volume-name"
        secret:
          secretName: "secret-name-in-ci"    # the secret name in the ci namespace
```


text:
Toad
====

Toad is a static site generator written in Racket.

Read the [design document](http://themattchan.com/blog/2015/06/toad-design.html).

Uses Racket's Scribble DSL as the internal representation for posts etc, some custom s-expr structs for other stuff.

### Toad?

An uglier [Frog](https://github.com/greghendershott/frog)

repository: themattchan/toad

repo_name: themattchan/toad


text:
```
________                 __  .__   ___.          .__  .__
\______ \   ____ _____ _/  |_|  |__\_ |__ _____  |  | |  |
 |    |  \_/ __ \\__  \\   __\  |  \| __ \\__  \ |  | |  |
 |    `   \  ___/ / __ \|  | |   Y  \ \_\ \/ __ \|  |_|  |__
/_______  /\___  >____  /__| |___|  /___  (____  /____/____/
        \/     \/     \/          \/    \/     \/
```

[![Deathball - PSX Game (Global Game Jam Barcelona 2017)](http://img.youtube.com/vi/tPisBxHv-cI/0.jpg)](http://www.youtube.com/watch?v=tPisBxHv-cI "Deathball - PSX Game (Global Game Jam Barcelona 2017")

Installation requirements:
* ePSXe emulator
* Game BIN/CUE: Go into "Bin" subfolder.

What is about the game:
The Death ball game is about two volleyballs fighting each other in a beach until one of them is dead.
To win a game you must push the opponent’s volleyball through the spikes of the cactus located in each border of the level before the countdown finishes.

There are only two actions to make the opponent’s ball move in the direction of the spikes.  The first of one is pushing him with your ball.
The second one is using the wind to make him moving there.

Keys used in the game:
control pad to move the ball, X button to bounce, R1 to make wind to the right direction, L1 to make wind to the left direction.

Installation guide:
* Download the ePSXe emulator.
* Configurate the emulator.
* Load the game image to the emulator.
* Play it and enjoy it.

gha_language: C


text:
## lValanceRelaxation.py

* Source:

  [click here](https://github.com/leucinw/ComputTools/tree/master/src/lValanceRelaxation.py)

* Usage:

  ```shell
  python lValanceRelaxation.py xyz
  ```

* Intro:

  This program is used to optimize any molecule by using AMOEBA bond parameters. It is very suitable for a molecule that is stiched together with several fragments, where the covalent bonds between the fragments are not close enough. Canonical xyz file is used as the input.

repository: leucinw/ComputTools

repo_name: leucinw/ComputTools


text:
# Contributing
You are free to work on any bug fix or feature from the issues tab. If you intend to do so, please create a new issue if it doesn't yet exist, and assign yourself to the issue so that we know someone is actively working on it.

# Developing
Below is a small guide for getting your environment set up and running/testing the tool. We use [poetry](https://python-poetry.org/docs/) to manage dependencies.

## Getting started and getting the latest dependencies
```bash
poetry install
```

## Running tests manually
We have a Travis CI setup that will run the test suite, perfrom python linting, and verify the code has full testing coverage for every commit you push. It will perform these checks for every python version that we support, and your code will need to pass all these checks in order to get merged in. You can also running these checks manually before you push your code out as well:
```bash
# Run the test suite manually using your system's default python version:
poetry run pytest --cov-report term --cov=capgains

# Run the linter against the project's default python version
poetry run flake8

# Run the test suite against all the supported python versions
# and the linter in an isolated environment. You will need to
# have the supported python versions installed otherwise you
# will get a `InterpreterNotFoundError`
poetry run tox
```

## Running the tool manually
```
poetry run capgains ...
```

## Creating a release
Once you have all the changes you desire for a release, do the following. Note that
we follow [semantic versioning](https://semver.org/) for our projects.

1. Create a new branch
2. Bump up the release numbers in `pyproject.toml` and `capgains/__init__.py`
3. Push + create PR. Once PR is ready, merge it into the master branch.
4. Create a new release using the Github release tools. This will create a new tag and
kick off a CI build. The ensuing CI build will notice that this is a tagged commit and
will package the project and push it to PyPI.

repository: mohanraj-r/cad-capital-gains

repo_name: mohanraj-r/cad-capital-gains


text:
# Racing Setup Garage

**App built using the MERN Stack**

*Currently WIP, the final application will allow you to filter down
racing games from multiple platforms, cars and specific tracks
in order to find/upload the car setups you need.*

### Homepage

![image](https://github.com/Craig-97/Racing-Setup-Garage/assets/41014229/00522eb5-dee6-40f1-9a08-5b5cf9f64bd7)

### Management Screen

![image](https://github.com/Craig-97/Money-Manager/assets/41014229/1f19d45a-d525-43c8-abd7-daa16eb5fd08)

How to run:
  - cd server
  - yarn run dev
  - visit localhost:8000

This will run the API and webpack dev server

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


text:
# Album Collection

Album Collection is an app that can keep track of many albums and the songs that each album contains.  Songs can be added and removed from each album.

## Installation

Run the app solution file in Microsoft Visual Studio 2017 / 2019.  Uses ASP.net C# with Entity Framework and SQL Server.

## Usage

Microsoft Visual Studio 2017 / 2019

## Contributing
Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.

Please make sure to update tests as appropriate.

## License
 - [MIT](https://choosealicense.com/licenses/mit/)
 - Ask Joe Scheiman

repository: JoeScheiman/AlbumCollectionMastery

repo_name: JoeScheiman/AlbumCollectionMastery


text:
# Documentation of SuluAutomationBundle

This documentation covers basic-topics to install and use this bundle. For detailed information see also the
bundle-documentation in [docs.sulu.io](http://docs.sulu.io/en/1.6/bundles/automation/index.html).

## List of contents

* [Installation](installation.md)

repository: sulu/SuluAutomationBundle

gha_language: PHP

repo_name: sulu/SuluAutomationBundle


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

The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

## [Unreleased]

## [3.0.1] - 2020-06-29
### Fixed
- Always cast tokens read from session to a string

## [3.0.0] - 2020-06-25
### Change
- Only supports Rails 6+, use 2.0.0 for Rails <IP_ADDRESS>

## [2.0.0] - 2020-06-16
### Changed
- Use Rails' <IP_ADDRESS> CSRF token algorithm

repository: rainforestapp/omniauth-protect

repo_name: rainforestapp/omniauth-protect


text:
# Repository Model

### Highlights

- **Hybrid mix of monorepo and multi-repo.**
- Each project lives in it's own repo.
- Checkout all relevant source code into a mono-repo root, say "quixon" directory.
- Local builds follow monorepo paradigm.
- Internal repo paths are always relative.
- [Versioning](versioning.md)

### Detailed

- Cognitively, a high-level mono repo.
- **Dependency projects** are resolved from the **mono-repo root** (usually the parent dir).
- But **each project, own repo**, under the mono-repo root.(Currently, the gitlab/github organization root)
- This provides the ease of the mono-repository, while having things split into small, focused multi-repositories.
- Permissions can be controlled individually, unlike pure monorepos.
- Secure dependencies can be mocked easily with mock repositories, while the CI systems access real repos.
- Can move in either direction as we scale - A mono-repo system like Google, Facebook with extensive test coverage and build infra or a multi-repo system like Amazon, with extensive arbitration infra.
- This price of this simplicity is an external CI runner that builds all repos as a mono repo with intelligent caches on each commit.

repository: quixon-labs/tech-docs

repo_name: quixon-labs/tech-docs


text:
# `android-ndk`: Rust bindings of the Android NDK

[![Build Status](https://travis-ci.org/mb64/android-ndk-rs.svg?branch=master)](https://travis-ci.org/mb64/android-ndk-rs)
[![Crates.io Status](https://meritbadge.herokuapp.com/android-ndk-sys)](https://crates.io/crates/android-ndk-sys)
[![Docs.rs Status](https://docs.rs/android-ndk-sys/badge.svg)](https://docs.rs/android-ndk-sys)
[![Crates.io Status](https://meritbadge.herokuapp.com/android-ndk)](https://crates.io/crates/android-ndk)
[![Docs.rs Status](https://docs.rs/android-ndk/badge.svg)](https://docs.rs/android-ndk)

This is a work in progress at the moment.

`android-ndk-sys` contains the raw FFI bindings, pre-generated from NDK r20, and `android-ndk`
provides a safe API over it.

Other helpful crates for Android:

 * [`jni`](https://crates.io/crates/jni), JNI bindings for Rust
 * [`android_logger`](https://crates.io/crates/android_logger) and [`ndk-logger`](https://crates.io/crates/ndk-logger),
   Android backends for the `log` crate

repository: katyo/android-ndk-rs

repo_name: katyo/android-ndk-rs


text:
# logger

This library is made for logging TCP/IP received data to file on Java8.

## To log received TCP/IP data like TELNET connecting.

- Simple logging, see "[/scripts/simple-tcpip.sh](/scripts/simple-tcpip.sh)".
- Creating Timestamp log file, see "[/scripts/timestamp-tcpip.sh](/scripts/timestamp-tcpip.sh)".
- Creating Numbering log file, see "[/scripts/numbering-tcpip.sh](/scripts/numbering-tcpip.sh)".

## To log JsonCommunicator received JSON.

What's "JsonCommunicator", see [this repository](https://github.com/kenta-shimizu/jsoncommunicator4java8) please.

- Simple logging, see "[/scripts/simple-json-communicator.sh](/scripts/simple-json-communicator.sh)", One JSON-Object is one pretty-printing file.

repository: kenta-shimizu/logger

repo_name: kenta-shimizu/logger