text:
ProxImaL
=====================
![Build Status](https://github.com/comp-imaging/ProxImaL/actions/workflows/python-package.yml/badge.svg)

ProxImaL is a Python-embedded modeling language for image optimization problems.
It allows you to express your problem in a natural way that follows the math,
and automatically determines an efficient method for solving the problem.
ProxImaL makes it easy to experiment with many different priors and other problem reformulations,
without worrying about the details of how the problem is solved.

For example, the following code denoises an image using simple sparse gradient and nonnegativity priors:

```python
from proximal import *
import numpy as np
import scipy.misc
import matplotlib.pyplot as plt

# Generate data.
I = scipy.misc.ascent()
np.random.seed(1)
b = I + 10*np.random.randn(*I.shape)

# Construct and solve problem.
x = Variable(I.shape)
prob = Problem(sum_squares(x - b/255) + .1 * norm1(grad(x)) + nonneg(x))
prob.solve()

# Plot the original, noisy, and denoised images.
plt.figure(figsize=(15, 8))
plt.subplot(131)
plt.gray()
plt.imshow(I)
plt.title('Original image')

plt.subplot(132)
plt.gray()
plt.imshow(b)
plt.title('Noisy image')

plt.subplot(133)
plt.gray()
plt.imshow(x.value * 255)  # x.value is the optimal value of x.
plt.title('Denoising results')
plt.show()
```
![Optimization results](https://gist.githubusercontent.com/SteveDiamond/592094bdbd7d9d3f8606383d84db3de5/raw/47ef609f995ee92ab7d9af1d4ad47c60a9764b65/results.png)

The example above uses simple, well-known priors. Much better results can be obtained using the more sophisticated priors provided in ProxImaL.

ProxImaL was designed and implemented by Felix Heide and Steven Diamond.
See [the accompanying paper](https://stevendiamond.me/pdf/proximal.pdf) for a full discussion of ProxImaL's design and examples of state-of-the-art results obtained with ProxImaL.

A tutorial and other documentation can be found at [proximal-lang.org](http://www.proximal-lang.org/).

This git repository holds the latest development version of ProxImaL. For installation instructions,
see the [install guide](http://www.proximal-lang.org/en/latest/install/index.html) at [proximal-lang.org](http://www.proximal-lang.org/).

repository: comp-imaging/ProxImaL

repo_name: comp-imaging/ProxImaL


text:
# OMG token allocation & airdrop

{% hint style="warning" %}
_Please note: the OMG Network is still in development, and some details cannot yet be included. This knowledge base will be revised regularly to include updates and additional details._
{% endhint %}

## OMG token allocation & airdrop

**Total supply created = 140,245,398.245132780789239631**
[_https://etherscan.io/token/OmiseGO_](https://etherscan.io/token/OmiseGO)\_\_

During the crowdsale period \(“OMG token creation period”\), up to a total of USD $25 million \(Maximal Launch Quantity\) equivalent of OMG were to be created by the smart contract, all equal value and functionality, but divided by the smart contract into different pools, for both public and private distribution:

**Public:**

1. Sale \[65.1% of OMG issued\]
2. Airdrop \[5% of OMG issued\] 5% of the total amount of OMG tokens created were designated for an Airdrop, both to encourage wider adoption of decentralized network operation and as a thank you to the Ethereum community to raise awareness and keep community incentives aligned. In September 2017, these OMG tokens were automatically distributed to addresses which held more than 0.1 ETH as of block 3988888 on 7th July. Over 450,000 addresses received OMG tokens \(approximately 0.075 OMG per 1 ETH\). There are no more airdrops planned \(do not believe scams that advertise a future OMG airdrop and require the recipient to take action\).

**Private:**

1. OmiseGO reserve \[20% of OMG issued\] Directly released by the smart contract to OmiseGO for future costs and uses including use for network validation as part of the development and execution of the project. These OMG are locked through a smart contract function and may not be transacted by OmiseGO for a period of 1 year, starting from the end of the creation period.
2. Team \[9.9% of OMG issued\] Reserved for team members and key contributors who worked to develop the ideas, supporting structures, and actual implementations of the OMG Project. Locked for 1 year.

license: MIT

repository: buildOMG/kb

branch_name: refs/heads/master

extension: md

gha_language: Python

gha_license_id: MIT

license_type: permissive

repo_name: buildOMG/kb


text:
---
title: "Breathing Physiology and Guided Breathing Exercise: A Primer"
collection: publications
permalink: /publication/2019-01-01-Breathing-Physiology-and-Guided-Breathing-Exercise-A-Primer
date: 2019-01-01
venue: 'https://www.cs.unb.ca/tech-reports/documents/TR19-241.pdf'
citation: ' Aaron Tabor,  Scott Bateman,  Erik Scheme, "Breathing Physiology and Guided Breathing Exercise: A Primer." https://www.cs.unb.ca/tech-reports/documents/TR19-241.pdf, 2019.'
---
Use [Google Scholar](https://scholar.google.com/scholar?q=Breathing+Physiology+and+Guided+Breathing+Exercise:+A+Primer){:target="_blank"} for full citation

gha_language: JavaScript


text:
# sanctuary-type-identifiers

A type is a set of values. Boolean, for example, is the type comprising
`true` and `false`. A value may be a member of multiple types (`42` is a
member of Number, PositiveNumber, Integer, and many other types).

In certain situations it is useful to divide JavaScript values into
non-overlapping types. The language provides two constructs for this
purpose: the [`typeof`][1] operator and [`Object.prototype.toString`][2].
Each has pros and cons, but neither supports user-defined types.

This package specifies an [algorithm][3] for deriving a _type identifier_
from any JavaScript value, and exports an implementation of the algorithm.
Authors of algebraic data types may follow this specification in order to
make their data types compatible with the algorithm.

### Algorithm

1.  Take any JavaScript value `x`.

2.  If `x` is `null` or `undefined`, go to step 6.

3.  If `x.constructor` evaluates to `null` or `undefined`, go to step 6.

4.  If `x.constructor.prototype === x`, go to step 6. This check prevents a
    prototype object from being considered a member of its associated type.

5.  If `typeof x.constructor['@@type']` evaluates to `'string'`, return
    the value of `x.constructor['@@type']`.

6.  Return the [`Object.prototype.toString`][2] representation of `x`
    without the leading `'[object '` and trailing `']'`.

### Compatibility

For an algebraic data type to be compatible with the [algorithm][3]:

  - every member of the type must have a `constructor` property pointing
    to an object known as the _type representative_;

  - the type representative must have a `@@type` property; and

  - the type representative's `@@type` property (the _type identifier_)
    must be a string primitive, ideally `'<npm-package-name>/<type-name>'`.

For example:

```javascript
//  Identity :: a -> Identity a
function Identity(x) {
  if (!(this instanceof Identity)) return new Identity(x);
  this.value = x;
}

Identity['@@type'] = 'my-package/Identity';
```

Note that by using a constructor function the `constructor` property is set
implicitly for each value created. Constructor functions are convenient for
this reason, but are not required. This definition is also valid:

```javascript
//  IdentityTypeRep :: TypeRep Identity
var IdentityTypeRep = {
  '@@type': 'my-package/Identity'
};

//  Identity :: a -> Identity a
function Identity(x) {
  return {constructor: IdentityTypeRep, value: x};
}
```

### Usage

```javascript
var Identity = require('my-package').Identity;
var type = require('sanctuary-type-identifiers');

type(null);         // => 'Null'
type(true);         // => 'Boolean'
type([1, 2, 3]);    // => 'Array'
type(Identity);     // => 'Function'
type(Identity(0));  // => 'my-package/Identity'
```

[1]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/typeof
[2]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/toString
[3]: #algorithm

repository: ileathan/Mubot

gha_language: HTML

repo_name: ileathan/Mubot


text:
# Android Search Interface

[ ![Download](https://api.bintray.com/packages/edsilfer/maven/user-onboarding/images/download.svg) ](https://bintray.com/edsilfer/maven/user-onboarding/_latestVersion) - **MIN API VERSION: 16**

## Summary
1. [Introduction](#introduction)
2. [How does it work?](#howdoesitwork)
   * [Step 01](#step1)
   * [Step 02](#step2)
   * [Step 03](#step3)
3. [Special Thanks](#special-thanks)
4. [License](#license)

## Introduction
> User onboarding is the process of improving a person's success with a product or service. This term is often used in reference to software products, and it can be done in a manual or automated way.

*Source: https://en.wikipedia.org/wiki/User_onboarding*

### SHOWCASE

  Figure 01: Android User OnBoarding library on action

## How does it work?
Android List Manager was developed using [Kotlin language](https://kotlinlang.org/). Kotlin is free to use and owned by [Jet Brains](https://www.jetbrains.com/). It adds a lot of cool features, boosting your productiveness while keeping everythying **100% compatible with Java.**

_For details about technical implementation of this library please refer to the source code._

#### Step 01: import the module

```gradle
compile 'br.com.edsilfer.android:user-onboarding:1.0.0'
```

#### Step 02: Fill in a OnBoardingTheme Object:

```kotlin
class OnBoardingTheme : Serializable {
    var bottomPanelColors = BottomPanelColors()
    var pages = listOf<Page>()
}

data class Page(
        var background: Int,
        var header: Int,
        var headerStyle: Text,
        var image: Int,
        var subHeader1: Int,
        var subHeader1Style: Text,
        var subHeader2: Int,
        var subHeader2Style: Text,
        var customLayoutResource: Int // Optional parameter. Do not forget to use same view ids if you set your own layout.
) : Serializable {}

class BottomPanelColors(
        var indicatorActiveColor: Int = Color.parseColor("#FFFFFF"),
        var indicatorInactiveColor: Int = Color.parseColor("#FFFFFF"),
        var skipColor: Int = Color.parseColor("#FFFFFF"),
        var nextColor: Int = Color.parseColor("#FFFFFF"),
        var finishColor: Int = Color.parseColor("#FFFFFF"),
        var dividerColor: Int = Color.parseColor("#FFFFFF")
) : Serializable {}
```

*Each page added on pages represents a Page to be place as part of the ViewPager*

*You can use different colors for bottom panel via BottomPanelColor class*

#### Step 03: Launch ActivityUserOnBoarding:

```kotlin
val pages = arrayListOf<Page>()
pages.add(getPage1())
pages.add(getPage2())
pages.add(getPage3())
pages.add(getPage4())

val theme = OnBoardingTheme()
theme.pages = pages
theme.panelColor = getBottomPanelColors()
theme.bottomPanelLayoutResource = R.layout.custom_bottom_panel // You can set your own layout for bottom panel

val intent = Intent(this, ActivityUserOnBoarding::class.java)
intent.putExtra(ActivityUserOnBoarding.ARG_ONBOARDING_THEME, theme)
startActivity(intent)
```

#### Step 04: Check sample app for more details!

## Special Thanks
 - This library was built based on [this](http://blog.grafixartist.com/onboarding-android-viewpager-google-way/) nice tutorial posted by Suleiman on Grafix Artist.
 - User [Josef Hruška](https://github.com/JosefHruska) for improving the versatility of the lib;

## License
Copyright 2016 Edgar da Silva Fernandes

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: DivakarN/android-user-onboarding-master

repo_name: DivakarN/android-user-onboarding-master


text:
###Postmortem

#####Coding
Many hours were wasted on code that had already been written a thousand times by other people.
Searching for solutions is most often a quicker and more efficient approach when solving trivial problems.

This was also one of the reasons for chosing Java over Scala.
Even with no experience in Java it was easier to get running prototypes with the help of the internet.

#####Time Management

This was our first project as a team. Therefore we didnt know exactly who could do which tasks.
The smart thing to do would have been talking about skills before starting.
It worked out fine in the end because we are awesome.

#####Bugs and Testing

We didnt waste a lot of time on finding bugs. User Input is not checked for sanity,
so we dont really know what happens if your name has 999 characters.

#####Usability

Our prototype was very functional with no intentions of beeing userfriendly.
Towards the end we decided to use some colours and fancy buttons,
which promptly crashed the app.
Next time we should think about design first and/or get someone who likes colours and buttons.

repository: SKogelnik/resifo-android

repo_name: SKogelnik/resifo-android


text:
![Screenshot](ar-00.jpg)

# AS-ApolloRunners2D
A racing game for my university

This project use the following Unity Version (2019.3.0f6)

# About the Game
"Apollo Runners" is a racing game with spaceships, with the space as main theme and is developed with Pixel Art.

# About the Development
This game was make for my university, as a project for a Arcade device, so all the mecanics was made for adapt for that device.

# Controls
The controls for the Arcade you can see in the "Tutorial Menu", in the game.
To play on computer you can use the following commands:

## **For player one:**

**D** - For acelerate the ship

**W and S** - Up and Down

**Left Shift** - Reset the spaceship rotation

**Left Control** - Use Perk

## **For player two:**

**Left Arrow** - For acelerate the ship

**Up and Down Arrow** - Up and Down

**Right Shift** - Reset the spaceship rotation

**Right Control** - Use Perk

Is important to remember that you can only reset the ship rotation if you are not acelerating your spaceship.

# Additional Informations

You can find this game on Itch.io, [here](https://ksaa.itch.io/apollo-runners-2d).


text:
# habs_portal

HABS Data Portal

## Installation

### Python Virtualenv

1. Grab your favorite virtualenv tool or you can install to root but don't call
   me when things break.

   [Check out virtualenv Burrito](https://github.com/brainsik/virtualenv-burrito)

2. Make a virtual environment for this project

   ```
   mkvirtualenv habs
   ```

3. Install Numpy

   At the project root run
   ```
   workon habs
   pip install numpy==1.9.2
   ```

4. (Developer Only) Install the Developer dependencies

   ```
   workon habs
   pip install -r requirements/dev.txt
   ```

5. (Install Only) Install the python dependencies

   ```
   workon habs
   pip install -r requirements/requirements.txt
   ```

6. Grab node.js and Node Package Manager

   Either use your favorate package manager ([homebrew](http://brew.sh), yum,
   or apt-get) to get the nodejs and node-package-manager or download the
   source and compile yourself.

   ```
   cd /usr/local/src
   wget 'http://nodejs.org/dist/v0.12.0/node-v0.12.0.tar.gz'
   tar -zxvf node-v0.12.0.tar.gz
   cd node-v0.12.0
   ./configure --prefix=/usr/local
   make
   sudo make install
   cd ..
   ```
7. Install the Node package dependencies

   At the project root run:
   ```
   npm install
   ```

8. Install the Bower dependencies

   You may need to install the bower command line tool first. If you installed
   nodejs to your system, you'll need to run this command with **sudo** privileges.
   ```
   npm install bower -g
   ```

   At the project root run:
   ```
   bower install
   ```

   You should see all of the depdencies being downloaded and put into the lib directory.

9. Install Grunt and the Grunt Command Line Tool

   You may need to install the grunt and grunt command line tool globally. If
   you install nodejs to your system level, you'll need to run this command
   with **sudo** privileges.

   ```
   npm install grunt-cli -g
   ```

10. Run Grunt

    At the project root run:
    ```
    grunt
    ```

    And you should see something similar to:
    ```
    Running "jst:compile" (jst) task
    File habs_portal/static/js/partials/compiled/test.js created.

    Running "concat:js" (concat) task
    File habs_portal/static/js/compiled/test.js created.

    Running "concat:css" (concat) task
    File habs_portal/static/css/compiled/test.css created.

    Done, without errors.
    ```

## Running the Application

To run the application in a development environment, just launch run app.py.

At the project root:

```
python app.py
```

To verify that it works you can curl the test API and/or go to the `/test/` URL.

## Development

### HTML Pages

HTML pages should be defined in `habs_portal/templates`. Each HTML file should
use the JINJA template structure extending from base.html. This allows us to
define the standard HTML metadata accross all pages unifromly in one place. The
other reason to use JINJA templates is so that we can get direct access to
session variables through the jinja template structure. Access to session
variables is useful for forms and CSRF Protection.

Routes to HTML pages should be defined in `habs_portal/controller.py`. Any
application logic to support the pages should also be defined in there as well,
so things like session variables, cookies etc.

### API

Most of the API here will be request proxies to other services: THREDDS, ASA
Services Bundle, etc. The Proxy endpoints should be prefixed with 'api' and
should handle errors. Any errors passed will be briefly parsed and passed
directly to the UI.

## Backbone Philosophy

### Models

Each model should be analogous to one document or tuple of data. Nested
structure are discouraged, instead they should link to other models. Collections
represent a collection of models. The API should return a collection as a
dictionary (to be JSON compliant) but with an intuitive key, whose value is the
list of models. Optionally, length and error keys can be returned in the
dictionary structure to assist the UI.

Example
```json
{
  "stations": [
    {
      "id": "on223",
      "station_name" : "Ontario Temperature Station 223",
      "location": {
        "lat": 43.42,
        "lon": -77.91,
        "depth" : 10
      }
    },
    {
      "id" : "on224",
      "station_name" : "Onatrio Bottom Turbidity Station 224",
      "location" : {
        "lat": 43.42,
        "lon": -77.91,
        "depth" : 33
      }
    }
  ],
  "length" : 2,
  "error": "" // Generally only used when status code != 200
}
```

### Views

Views should be very minimal in their extent. Keep them very simple and
intuitive. A map can be a view and should have basic capabilities desired out of
the map:

 - Redraw
 - Draw Station
 - Center
 - Zoom
 - Pan

Views should almost always have partials. Partials go into
`habs_portal/static/js/partials/`. If a view relies on asynchronous data, and
most do, it should have an initial render that is called after initialzation
that acts as a placeholder until the data is completely fetched and the full
component can be rendered. This initial render can be something like a
spin-wheel or something indicated to the user that something is in progress.

For views that represent lists or tables of models, like a table view or a list
view, subviews can be used. If a subview is used, I will take it as a huge
kindness if you bind it to the parent under the `views` attribute, to keep
things consistent.

Consider the following:

```javascript
var GenericTableView = Backbone.View.extend({
  views: [], // Because we're using subviews
  add: function(model) {
    var view = new TableItemView({
      model: model
    });
    view.render();
    this.$el.find('tbody').append(view.el);
    this.views.push(view);
  },
  initialize: function() {
    // Make a spin wheel
    this.$el.html("<div id='spinwheel'></div>");
  },
  template: JST['table.html'],
  render: function() {
    var self = this;
    this.$el.html(this.template());
    this.collection.each(function(model) {
      self.add(model);
    });
  }
});

var TableItemView({
  tagName: 'tr'
  ...
});
```

### Event Management

Every page should have a root application object which is responsible for
initializing views, rendering views, fetching collections, fetching models, and
dispatching events in the page. It should be defined like:

```javascript

var App = function() {
}

_.extend(App.prototype, Backbone.Events, {
  collections: {},
  models: {},
  views: {},
  start: function() {
    // Collection initializations
    // Model Initializations
    // View initializations and initial renders
    // Event Listeners
    // Collection and Model Fetchers
  }
});

app = new App();

$(document).ready(function() {
  app.start();
});

```

### Compiling Using Grunt

Page Javascript and CSS dependencies should mostly be handled by grunt. You can
use `grunt watch` on the command line to listen for changes and automatically
recompile.

Every page should have a section in the grunt configuration under `jst` (for
partials), `js` and `css`. Comments are encoraged in the gruntfile to help
explain why their needed.

Example for the partials, I include every partial that this page will need here.
Note how the compiled script is a javascript file (.js).

```
jst: {
  compile: {
    files: {
      "habs_portal/static/js/partials/compiled/test.js" : [
        "habs_portal/static/js/partials/TestTable.html"
      ]
    }
  }
}
```

Example for the JS dependencies:
```
js: {
  files: {
    // The compile destination
    'habs_portal/static/js/compiled/test.js' : [
      // Libs
      // Here are all of my library dependencies
      'habs_portal/static/lib/jquery/dist/jquery.js',
      'habs_portal/static/lib/jquery-ui/jquery-ui.js',
      'habs_portal/static/lib/bootstrap/dist/bootstrap.js',
      'habs_portal/static/lib/underscore/underscore.js',
      'habs_portal/static/lib/backbone/backbone.js',
      // Models
      // Here are all the models I need to run this page
      'habs_portal/static/js/models/TestModel.js',
      // Views
      // All the views I need to run the page
      'habs_portal/static/js/views/TestTableView.js'
    ],
  }
}
```

It's almost identical for CSS.

## Project Layout

#### `habs_portal/static/css/`

All of the CSS files.

#### `habs_portal/static/css/compiled/`

This folder is where the compiled CSS files go, generated by grunt. This should
remain unused during development.

#### `habs_protal/static/img/`

Any image files. Subdirectories can be used.

#### `habs_portal/static/js/compiled/`

This is where the compiled Javascript files go, that are compiled by Grunt.

#### `habs_portal/static/js/models/`

All backbone Model Definitions. Naming convention is capital camel case for both
the class name and the filename.

#### `habs_portal/static/js/partials/`

HTML Partials that are used by the views.

#### `habs_portal/static/js/partials/compiled/`

Grunt compiles the partials into this directory.

#### `habs_portal/static/js/views/`

Backbone View definitions.

#### `habs_portal/static/json/`

Repository for static JSON files (great for testing)


text:
# 🤖 Setup GitHub Actions for Deployment

Follow these steps for setting up automatic deployment to Heroku using GitHub Actions CI which will be triggered on every push on master (main) branch.

## 🔐 Set Secrets on GitHub

You can take a look on [this](https://github.com/PatilShreyas/NotyKT/blob/master/noty-api/GHActionsSecrets.txt) file for exmaple.

- Retrieve Heroku API Auth token

    ```bash
    heroku auth:token
    ```

- Create a secret `HEROKU_AUTH` using following syntax

    ```netrc
    machine api.heroku.com
    login<EMAIL_ADDRESS>    password AUTH_TOKEN
    machine git.heroku.com
    login<EMAIL_ADDRESS>    password AUTH_TOKEN
    ```

- Create a secret `HEROKU_USER_EMAIL` and put your email (which is used for Git/Heroku).

After creating secret, it would look like below image.

![GitHub Secrets](../../media/noty-api/gh-secrets.png)

## 👨💻 Set up Workflow

You can take a look at [this](https://github.com/PatilShreyas/NotyKT/blob/master/.github/workflows/deploy_api.yml) workflow file.

- Create a workflow on GitHub by a name let's say `deploy_api.yml`. Add basic structure for it.

```yaml
name: Deploy (API)

on:
  push:
    branches:
      - master

    paths:
      - 'noty-api/**'

jobs:
  deploy_api:
    name: Deploy to Heroku
    runs-on: ubuntu-latest
```

?> You can configure it as per your case. (In NotyKT, we created workflow which will deploy API on every push on master branch if changes happens in `noty-api/` directory).

- Add steps for deployment

```yaml
    steps:
      - uses: actions/checkout@v1

      - name: Install Heroku CLI
        run: curl https://cli-assets.heroku.com/install-ubuntu.sh | sh

      - name: Deploy to Heroku
        run: |
          git config --global user.name ${{ github.actor }}
          git config --global user.email ${{ secrets.HEROKU_USER_EMAIL }}
          echo "$HEROKU_AUTH" > ~/.netrc
          heroku git:remote --app noty-api
          git subtree push --prefix noty-api heroku master
        env:
          HEROKU_AUTH: ${{ secrets.HEROKU_AUTH }}
```

That's all! Now just make changes, push and chill. GitHub Actions will do work of deployment.

repository: PatilShreyas/NotyKT

gha_language: Kotlin

repo_name: PatilShreyas/NotyKT


text:
---
title: Favorites
date: 2019-12-23T22:26:53.222Z
category: Navigation
subcategory: Content
tags:
  - Favorites
  - Content
  - Navigation
caption: Favorites
problem: User wants to pick items for later consumption.
solution: |-
  Users can add their own list of personalized items from the content.

  Users can identify Favorite content from normal content.

  Content can be toggled between Favorite state.
usage: >-
  * Use to enable users to differentiate between large amounts of content items.

  * Do not use favorites to pick out multiple categories – use tags or
  categories instead.
accessibility: 'http://web-accessibility.carnegiemuseums.org/code/svg/'
assets:
  - asset:
      image: /assets/favorite.png
references:
  - reference:
      url: 'http://ui-patterns.com/patterns/favorites'
---

repository: cross-team/pattern-lib

repo_name: cross-team/pattern-lib


text:
# Tesla API

### How is this site organized?

This site is broken into sections for differneet API information:

* Authencation - API commands to generate an `{access_token}` to communciate with your vehicle.
* Vehicles - API commands to communiate between your vehicle and your client.
* Codes - Localized Tesla vehicle option codes for the [Model S](codes/model-s-options.md) and [Model X](codes/model-x-options.md)

### What Tesla products are supported?

* Tesla Model S
* Tesla Model X
* Tesla Model 3

### What is teslaapi.io?

This is a community of develoeprs who are reverse engineering Tesla's API.

### What are the client\_id and client\_secret values?

Authentication to the Tesla API is done through OAath. These values were retreived froms somebody's OAuth sesson and are now being used for API access.

### Is this API offiical?

Absolutley not. These endpoints are a result of reverse engineering Tesla's mobile appliations and vehcile software.


text:
# Roles & who does what

* Employer/Operator : human offering/managing offers
* SchoolManagement : human managing students, have a custom role (for now, only school_manager requires an ac-xxx.fr email address)
* Student : 14/15yo student looking for a weekly offers
* Statistician : human managing the process on their location
* Visitor : kind of null model when an user is here but not logged in

repository: betagouv/monstage

branch_name: refs/heads/staging

gha_language: Ruby

repo_name: betagouv/monstage


text:
---
title: Quick Start
menuOrder: 1
autotoc: true
---

# Quick Start

**Enlight'me** is a very simple static site generator that can help you to
build your application / library documentation easily. This document will show
you the basics to generate your first Enlight'me site in **only 5 minutes**.

## Installing Enlight'me

First of all, install Enlight'me on your computer (we assume you have already
installed Node.js and NPM):

    npm install -g enlightme

That's it for the installation.

## Creating Your First Enlight'me Site

Creating your Enlight'me-generated documentation website requires only 3 (short
and easy) steps described bellow.

### 1. Write Some Markdown Files

First of all, you have to write your documentation in the [Markdown][gfm] format:

* Create a `doc/` folder at the root of your project,
* Write some Markdown files in it,
* and you're done!

**Example:**

    MyProject/
        |
        +-- doc/
        |   |
        |   o-- index.md
        |   |
        |   o-- quick-start.md
        |
        o-- package.json

### 2. Generate The site

To generate the HTML version of your site, just type the following command:

    enlightme

The generated content is created in the `doc.generated/` folder, located at
the root of your project.

__TIP:__ you can add this folder to your `.gitignore` file to avoid committing
it accidentally.

### 3. Publish to Github Pages

Publishing the site on your [Github Pages][gh-pages] can be done with the following command:

    enlightme publish

Your site is now online. Wow, way too easy isn't it?

[gfm]: https://guides.github.com/features/mastering-markdown/
[gh-pages]: https://pages.github.com/

repository: wanadev/enlightme

gha_language: Less

gha_license_id: NOASSERTION

repo_name: wanadev/enlightme


text:
#BBUncrustifyPlugin-Xcode

Xcode plugin to [uncrustify](http://uncrustify.sourceforge.net) the source code opened in the editor.

## Requirements

Tested with Xcode 4.6+ on OS X 10.7 or higher.

## Installation

* Build the Xcode project. The plug-in will automatically be installed in `~/Library/Application Support/Developer/Shared/Xcode/Plug-ins`.

* Relaunch Xcode.

To uninstall, just remove the plugin from `~/Library/Application Support/Developer/Shared/Xcode/Plug-ins` and restart Xcode.

## How does it work?

* Use the menu `Edit > Uncrustify` to uncrustify the source code actually opened in the editor.

* Use the menu `Edit > Uncrustify Selected Files` to uncrustify the selected items in the project navigator.

PS: Modifications are recorded in the undo. So undo reverts the modifications.

## How to customize the uncrustify configuration?

I recommend to use [UncrustifyX](https://github.com/ryanmaxwell/UncrustifyX). Overwite the file `uncrustify.cfg` with your own configuration and rebuild the plugin (and restart Xcode).

## Creator

[Benoît Bourdon](https://github.com/benoitsan) ([@benoitsan](https://twitter.com/benoitsan)).

## License

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

repository: IvanUshakov/BBUncrustifyPlugin-Xcode

repo_name: IvanUshakov/BBUncrustifyPlugin-Xcode


text:
# `PostgreSQL multimaster`

`multimaster` is a PostgreSQL extension with a set of patches that turns PostgreSQL into a synchronous shared-nothing cluster to provide Online Transaction Processing (OLTP) scalability and high availability with automatic disaster recovery. As compared to a standard PostgreSQL master-slave cluster, a cluster configured with the `multimaster` extension offers the following benefits:

* Cluster-wide transaction isolation
* Synchronous logical replication
* DDL replication
* Working with temporary tables on each cluster node
* Fault tolerance and automatic node recovery
* PostgreSQL online upgrades

## Overview

The `multimaster` extension replicates the same database to all nodes of the cluster and allows write transactions on each node. To ensure data consistency in the case of concurrent updates, `multimaster` enforces transaction isolation cluster-wide, using multiversion concurrency control (MVCC) at the repeatable read isolation level. Any write transaction is synchronously replicated to all nodes, which increases commit latency for the time required for synchronization. Read-only transactions and queries are executed locally, without any measurable overhead.

To ensure high availability and fault tolerance of the cluster, `multimaster` uses three-phase commit protocol and heartbeats for failure discovery. A multi-master cluster of N nodes can continue working while the majority of the nodes are alive and reachable by other nodes. When the node is reconnected to the cluster, `multimaster` can automatically fast-forward the node to the actual state based on the transactions log (WAL). If WAL is no longer available for the time when the node was excluded from the cluster, you can restore the node using `pg_basebackup`.

For details on the `multimaster` internals, see the [Architecture](/contrib/mmts/doc/architecture.md) page.

## Documentation

1. [Administration](doc/administration.md)
    1. [Installation](doc/administration.md#installation)
    1. [Setting up a Multi-Master Cluster](doc/administration.md#setting-up-a-multi-master-cluster)
    1. [Tuning configuration params](doc/administration.md#tuning-configuration-parameters)
    1. [Monitoring Cluster Status](doc/administration.md#monitoring-cluster-status)
    1. [Adding New Nodes to the Cluster](doc/administration.md#adding-new-nodes-to-the-cluster)
    1. [Excluding Nodes from the Cluster](doc/administration.md#excluding-nodes-from-the-cluster)
1. [Architecture](doc/architecture.md)
1. [Configuration Variables](doc/configuration.md)
1. [Built-in Functions and Views](doc/functions.md)

## Tests

### Fault tolerance

(Link to test/failure matrix)

### Performance

(Show TPC-C here on 3 nodes)

## Limitations

* `multimaster` can only replicate one database per cluster.

* The replicated tables must have primary keys or replica identity. Otherwise, `multimaster` cannot perform logical replication. Unlogged tables are not replicated, as in the standard PostgreSQL.

* Sequence generation.
To avoid conflicts between unique identifiers on different nodes, `multimaster` modifies the default behavior of sequence generators. For each node, ID generation is started with the node number and is incremented by the number of nodes in each iteration. For example, in a three-node cluster, 1, 4, and 7 IDs are allocated to the objects written onto the first node, while 2, 5, and 8 IDs are reserved for the second node.

* DDL replication.
While `multimaster` replicates data on the logical level, DDL is replicated on the statement level, which causes distributed commits of the same statement on different nodes. As a result, complex DDL scenarios, such as stored procedures and temporary tables, may work differently as compared to the standard PostgreSQL.

* Commit latency.
The current implementation of logical replication sends data to subscriber nodes only after the local commit. In case of a heavy-write transaction, you have to wait for transaction processing twice: on the local node and on all the other nodes (simultaneously).

* Isolation level.
The `multimaster` extenstion currently supports only the _repeatable_ _read_ isolation level. This is stricter than the default _read_ _commited_ level, but also increases probability of serialization failure during commit. _Serializable_ level is not supported yet.

## Compatibility
The `multimaster` extension currently passes 162 of 166 postgres regression tests. We are working right now on proving full compatibility with the standard PostgreSQL.

## Authors

Postgres Professional, Moscow, Russia.

### Credits
The replication mechanism is based on logical decoding and an earlier version of the `pglogical` extension provided for community by the 2ndQuadrant team.

license: PostgreSQL


text:
# Build (CMake - Windows)

### Raekor - Static Library
* Any Windows 10 SDK (configure using the Visual Studio Installer).

### Editor - OpenGL Application
* Requires Raekor.
* Graphics card with OpenGL 4.6 support.
* Vulkan SDK accessible from PATH.

### VK - Vulkan Application
* Requires Raekor.
* Up-to-date graphics drivers.
* Graphics card with RTX support.
* Vulkan SDK [1.3.204](https://sdk.lunarg.com/sdk/download/<IP_ADDRESS>/windows/VulkanSDK-<IP_ADDRESS>-Installer.exe) or higher.

### DX - DirectX 12 Application
* Requires Raekor.
* Up-to-date graphics drivers.
* Graphics card with RTX and Shader Model 6_6 support.
* Windows 10 version with Agility SDK support (see Microsoft's [blog post](https://devblogs.microsoft.com/directx/gettingstarted-dx12agility/#OS)).
* Windows SDK 10.0.20348 or higher (configure using the Visual Studio Installer).

## Instructions

Clone this repository using
 ```git clone --recursive https://github.com/nicovanbentum/Raekor.git```
 >**_NOTE:_** If the path to the repository contains any whitespace the shaders will fail to compile.

* Run ``` cmake . ``` from the root of the repository. This can take a while as it builds everything, there are no pre-built binaries.

* Build using the generated ```Solution.sln``` visual studio solution.

# Projects

### Raekor
This project requires C++ 17.

* Simple Job system
* Simple ConVar system
* Jolt Physics Integration
* Hotloadable C++ Scripts (WIP)
* Custom Scene Format
    - DCC import (Assimp)
    - Serialisation (Cereal)
    - Entity component system (EnTT)
    - S3TC DXT5 texture compression

### Editor
This project requires OpenGL 4.6 for direct state access functions and shader include directives.

* Compute based Skinning & Animation
* Deferred PBR Renderer
    - Bloom
    - ACES Tonemapping
    - Cook-Torrance BRDF
    - Temporal Anti-Aliasing
    - Cascaded Shadow Mapping
    - Voxel Cone Traced Ambient Occlusion
    - Voxel Cone Traced Specular Reflections
    - Voxel Cone Traced Global Illumination (single bounce diffuse)
    - Ray Traced Hard Shadows using Vulkan interop (only availabe in the [Scatter](https://github.com/nicovanbentum/Scatter)-integration branch, very outdated using the vk_nv_ray_tracing extension).
* Scenes
    - Simulate basic physics shapes.
    - Import models from GLTF, FBX and OBJ file formats.
    - Edit, add, delete, duplicate, and transform entities/components.

![image](https://i.imgur.com/m8HLdED.png)

### VK
Requires Vulkan 1.2 with support for descriptor indexing, device buffer address, and hardware ray tracing.
* Uni-Directional GPU Path Tracer using the vk_khr_ray_tracing extensions.
   - Progressive real-time rendering
   - Importance sampled diffuse and specular BRDF

Older versions of this project contained rasterized experiments with parallel command buffer recording, dynamic uniform buffers, and bindless textures.

![image](https://i.imgur.com/S4l11hb.jpg)
*Path tracer WIP - 8 bounces. Converges in real time when stationary.*

### DX12
*Currently In-Progress*

Nothing fancy yet, so far its mostly a basic Render Graph (automatically creates resource views and handles resource transitions) on top of DirectX 12. Heavily relies on shader model 6_6 bindless. DirectStorage 1.0 integration. The graph currently describes:

- Geometry Buffer
- WIP Procedural Grass (from Ghost of Tsushima)
- WIP Ray Traced Shadows
- WIP Ray Traced Ambient Occlusion
- WIP Ray Traced Reflections
- WIP Dynamic Diffuse Global Illumination
- Deferred Shading
- AMD FidelityFX Super Resolution 2.1

### DX11
Raekor started out 4 years ago as an experiment on switching between graphics APIs at runtime (I had no idea what I was doing lol), which is why you will find a bunch of unfinished DirectX 11. Source only.

### Ray Tracing in One Weekend
![image](https://i.imgur.com/7haNfzV.png)
Single school assignment, implements Ray Tracing in One Weekend by Peter Shirley in a GLSL Compute shader. Source only.

repository: nicovanbentum/Raekor

repo_name: nicovanbentum/Raekor


text:
---
layout: post
title: "OsIQD14"
description: ""
category: genes
tags: [grain, yield]
---

* **Information**
    + Symbol: OsIQD14
    + MSU: [LOC_Os08g02250](http://rice.uga.edu/cgi-bin/ORF_infopage.cgi?orf=LOC_Os08g02250)
    + RAPdb: [Os08g0115200](https://rapdb.dna.affrc.go.jp/locus/?name=Os08g0115200)

* **Publication**
    + [Rice microtubule-associated protein IQ67-DOMAIN14 regulates rice grain shape by modulating microtubule cytoskeleton dynamics.](http://www.ncbi.nlm.nih.gov/pubmed?term=Rice microtubule-associated protein IQ67-DOMAIN14 regulates rice grain shape by modulating microtubule cytoskeleton dynamics.%5BTitle%5D), 2019, Plant Biotechnol J.

* **Genbank accession number**

* **Key message**
    + Our results indicate that OsIQD14 acts as a key factor in regulating MT rearrangements in rice hull cells and hence the grain shape, and allows effective local cell shape manipulation to improve the rice yield trait

* **Connection**

[//]: # * **Key figures**


text:
# Greenhub

## Description

Make your Github contribution graph green by adding dump commits and changing committing dates.

## Demo

A demo account is [wsenh](https://github.com/wsenh?tab=overview&from=2017-12-01&to=2017-12-31).

## How to use

1. Download the scripts

```bash
$ git clone https://github.com/senhungwong/greenhub.git
```

2. Put the downloaded files into your repository

3. Run command (see more [Commands](#commands))

## Commands

### Everyday

Commit everyday from a given date til now

```bash
$ python3 green everyday
```

```
Params:

--start_date               (str) : the start date of the commit, default 380 days ago
--commit_times_lower_bound (int) : the everyday commit times lower bound, default 1
--commit_times_upper_bound (int) : the everyday commit times upper bound, default 1
--change_commit_date       (bool): update all the commit date to author date
--push                     (bool): push the commits at the end
--force                    (bool): do a force push if is pushing
```

If you set a lower bound or upper bound, on each date, it will generate a random number between the bounds and commit
that number of times.


text:
# commit-message-validator

[![shields badge](https://img.shields.io/npm/dw/commit-message-validator.svg)](https://npmjs.com/package/commit-message-validator)

Git commit-msg validator

This package provides you a binary that you can use as a git hook to validate the commit message, with your custom regex pattern.

This package can be used with githook packages such as [husky](https://www.npmjs.com/package/husky).

If you are looking for a *standard* commit message validator which supports [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/) out of the box, give [Commitlint](https://github.com/conventional-changelog/commitlint) a try.

## Installation

This module is distributed via npm which is bundled with node and should be installed as one of your project's devDependencies:

```bash
    npm install -D commit-message-validator
```

## Usage

1. Install this package as one of your project's devDependencies
2. Install githook [husky](https://www.npmjs.com/package/husky)
3. Config commit-msg hook to run commit-message-validator.

**husky v7**

```bash
npm set-script prepare "husky install"
npx husky add .husky/commit-msg "npx commit-message-validator"
```

**husky v4**

setup husky in `package.json`.

```json
{
  "husky": {
    "hooks": {
      "commit-msg": "commit-message-validator"
    }
  }
}
```

4. Custom commit-message regex pattern in package.json

```json
{
  "config": {
    "commit-message-validator": {
      "_comment": "pattern can be Regex string or array of Regex string",
      "pattern": "your regex pattern here",
      "errorMessage": "your error message"
    }
  }
}
```

repository: banyudu/commit-message-validator

repo_name: banyudu/commit-message-validator


text:
# PSGumshoe

PSGumshoe is a Windows PowerShell module for the collection of OS and domain artifacts for the purposes of performing live response, hunt, and forensics.

The module focuses on being as forensically sound as possible using existing Windows APIs to achieve the collection of information from the target host.

For information on how to contribute and use the module please refer to the documentation in the [Wiki](https://github.com/PSGumshoe/PSGumshoe/wiki)

repository: SimplyRyan/PSGumshoe

repo_name: SimplyRyan/PSGumshoe


text:
# ivy-codemirror

[![Build Status](https://travis-ci.org/IvyApp/ivy-codemirror.svg?branch=master)](https://travis-ci.org/IvyApp/ivy-codemirror)
[![Dependabot Status](https://api.dependabot.com/badges/status?host=github&repo=IvyApp/ivy-codemirror)](https://dependabot.com)
[![Ember Observer Score](http://emberobserver.com/badges/ivy-codemirror.svg)](http://emberobserver.com/addons/ivy-codemirror)

An [Ember](http://emberjs.com) component for the excellent [CodeMirror](http://codemirror.net) editor.

## Installation

```sh
ember install ivy-codemirror # install:addon for Ember CLI < 0.2.3
```

If you are using a version of Ember prior to 2.3, you will also need to install the `ember-hash-helper-polyfill` addon:

```sh
ember install ember-hash-helper-polyfill
```

## Usage

This addon provides an `ivy-codemirror` component which wraps a CodeMirror editor. You can set its `value` property to the code that you want to be displayed:

```handlebars
{{ivy-codemirror value=myCode}}
```

### Data Down, Actions Up

In the spirit of [Data Down, Actions Up](https://dockyard.com/blog/2015/10/14/best-practices-data-down-actions-up), the `value` **will not be modified directly**. Instead, when a CodeMirror `change` event occurs, a `valueUpdated` action will be sent, and will be given the new value as an argument. You might implement this action handler like so:

```handlebars
<!-- app/templates/index.hbs -->
{{ivy-codemirror value=myCode valueUpdated=(action "updateMyCode")}}
```

```javascript
// app/controllers/index.js
import Ember from 'ember';

export default Ember.Controller.extend({
  actions: {
    updateMyCode(newCode) {
      this.set('myCode', newCode);
    }
  }
});
```

However, for this simple use case, Ember provides the built-in `mut` helper. You could use this helper in your template instead of writing the action handler yourself, like so:

```handlebars
<!-- app/templates/index.hbs -->
{{ivy-codemirror value=myCode valueUpdated=(action (mut myCode))}}
```

### Options

`ivy-codemirror` also allows passing [options](http://codemirror.net/doc/manual.html#config) to CodeMirror via the `options` property. The easiest way to do this is via Ember's built-in `hash` helper, like so:

```handlebars
{{ivy-codemirror options=(hash lineNumbers=true mode="javascript")}}
```

### Themes

By default, only CodeMirror's default theme (found in `codemirror.css`) is included. Additional themes can be included by specifying them in your `ember-cli-build.js` file:

```js
var app = new EmberApp({
  codemirror: {
    themes: ['solarized', 'twilight']
  }
});
```

The example above would include `themes/solarized.css` and `themes/twilight.css` into `vendor.css`.

### Modes & Key Maps

In addition to themes, you can also include language modes and key maps via the `modes` and `keyMaps` options, respectively:

```js
var app = new EmberApp({
  codemirror: {
    modes: ['javascript'],
    keyMaps: ['vim']
  }
});
```

The example above would include `mode/javascript/javascript.js` and `keymap/vim.js` into `vendor.js`.

### Addons

In addition to the above, you can also include any CodeMirror addon files like so:

```js
var app = new EmberApp({
  codemirror: {
    addonFiles: ['lint/lint.css', 'lint/lint.js']
  }
});
```

The above example would add `lint/lint.css` to `vendor.css` and `lint/lint.js` to `vendor.js`.

## Contributing

Fork this repo, make a new branch, and send a pull request. Make sure your change is tested or it won't be merged.

To run tests:

```sh
git clone # <this repo>
yarn install
yarn test
```

Or, to start a test server that continually runs (for development):

```sh
ember test --server
```

repository: rancher/ivy-codemirror

repo_name: rancher/ivy-codemirror


text:
# Kubernetes scalability and performance SLIs/SLOs

## What Kubernetes guarantees?

One of the important aspects of Kubernetes is its scalability and performance
characteristic. As Kubernetes user or operator/administrator of a cluster
you would expect to have some guarantees in those areas.

The goal of this doc is to organize the guarantees that Kubernetes provides
in these areas.

## How we define scalability?

Our scalability definition is built on two concepts:
- [Service Level Indicators]
- [Service Level Objectives]

We require our SLIs/SLOs to have the following properties:
-  They are precise and well-defined

  It's extremely important to ensure that both users and us have exactly the
  same understanding of what we guarantee.
-  They are consistent with each other

  This is mostly about using the same terminology, same concepts, etc.
-  They are user-oriented

  First, the SLOs we provide need to be things users really care about.
  Second, they need to be understandable for people not familiar with the system
  internals (e.g. their formulation can't depend on some arcane knowledge or
  implementation details of the system).
-  They are testable

  Ideally, SLIs/SLOs should be measurable in all running clusters, but if measuring
  some metrics isn't possible or would be extremely expensive (e.g. in terms
  of resource overhead for the system), benchmarks sometimes may be enough.
  That means that not every SLO may be translatable to SLA ([Service Level
  Agreement]).

While SLIs are generic (they just define what and how we measure), SLOs provide
specific guarantees and satisfying them may depend on meeting some specific
requirements. Specific examples that may visibly affect ability to satisfy them
are:
- cluster configuration
- user of Kubernetes extensibility features
- load on the cluster.

As a result, we define Kubernetes scalability using "you promise, we promise"
framework, as following:

 If you promise to:
- correctly configure your cluster
- use extensibility features "reasonably"
- keep the load in the cluster within recommended limits

then we promise that your cluster scales, i.e.:
- all the SLOs are satisfied.

We are in the process of extending coverage of the system with SLIs and SLOs
to better reflect user expectations.

Note that may also introduce internal (for developers only) SLIs, that may be
useful for understanding performance characteristic of the system, but for which
we will not provide any guarantees for users.

[Service Level Indicators]: https://en.wikipedia.org/wiki/Service_level_indicator
[Service Level Objectives]: https://en.wikipedia.org/wiki/Service_level_objective
[Service Level Agreement]: https://en.wikipedia.org/wiki/Service-level_agreement

### Environment (cluster configuration)

In order to meet SLOs, system must run in the environment satisfying
the following criteria:
- Runs a single or more appropriately sized master machines
- Events are stored in a separate etcd instance (or cluster)
- All etcd instances are running on master machine(s)
- Kubernetes version is at least X.Y.Z
- ...

__TODO: Document other necessary configuration.__

### Scalability thresholds

To make the cluster eligible for SLO, users also can't have too many objects in
their clusters. More concretely, the number of different objects in the cluster
MUST satisfy thresholds defined in [thresholds file][].

[thresholds file]: https://github.com/kubernetes/community/blob/master/sig-scalability/configs-and-limits/thresholds.md

### Kubernetes extensibility

In order to meet SLOs, you have to use extensibility features "wisely".
The more precise formulation is to-be-defined, but this includes things like:
- webhooks have to provide high availability and low latency
- CRDs and CRs have to be kept within thresholds
- ...

## Kubernetes SLIs/SLOs

The currently existing SLIs/SLOs are enough to guarantee that cluster isn't
completely dead. However, they are not meeting user expectations in many areas of
the system and we are actively working on extending their coverage.

We are also introducing two more prerequisites which have to be met to ensure that
SLOs can be satisfied:

```
Prerequisites:
   1. Kubernetes cluster is available and serving.
   2. Cluster churn is <= 20, where churn is defined as:
     churn = #(Pod spec creations/updates/deletions) + #(user originated requests) in a given second
```

__TODO: Cluster churn should be moved to scalability thresholds.__

### Steady state SLIs/SLOs

| Status | SLI | SLO | User stories, test scenarios, ... |
| --- | --- | --- | --- |
| __Official__ | Latency of processing mutating API calls for single objects for every (resource, verb) pair, measured as 99th percentile over last 5 minutes | In default Kubernetes installation, for every (resource, verb) pair, excluding virtual and aggregated resources and Custom Resource Definitions, 99th percentile per cluster-day[1](#footnote1) <= 1s | [Details](./api_call_latency.md) |
| __Official__ | Latency of processing non-streaming read-only API calls for every (resource, scope) pair, measured as 99th percentile over last 5 minutes | In default Kubernetes installation, for every (resource, scope) pair, excluding virtual and aggregated resources and Custom Resource Definitions, 99th percentile per cluster-day[1](#footnote1) (a) <= 1s if `scope=resource` (b) <= 30s otherwise (if `scope=namespace` or `scope=cluster`) | [Details](./api_call_latency.md) |
| __Official__ | Startup latency of schedulable stateless pods, excluding time to pull images and run init containers, measured from pod creation timestamp to when all its containers are reported as started and observed via watch, measured as 99th percentile over last 5 minutes | In default Kubernetes installation, 99th percentile per cluster-day[1](#footnote1) <= 5s | [Details](./pod_startup_latency.md) |
| __WIP__ | Startup latency of schedulable stateful pods, excluding time to pull images, run init containers, provision volumes (in delayed binding mode) and unmount/detach volumes (from previous pod if needed), measured from pod creation timestamp to when all its containers are reported as started and observed via watch, measured as 99th percentile over last 5 minutes | In default Kubernetes installation, 99th percentile per cluster-day[1](#footnote1) <= X where X depends on storage provider | [Details](./pod_startup_latency.md) |
| __WIP__ | Latency of programming in-cluster load balancing mechanism (e.g. iptables), measured from when service spec or list of its `Ready` pods change to when it is reflected in load balancing mechanism, measured as 99th percentile over last 5 minutes aggregated across all programmers | In default Kubernetes installation, 99th percentile per cluster-day[1](#footnote1) <= X | [Details](./network_programming_latency.md) |
| __WIP__ | Latency of programming dns instance, measured from when service spec or list of its `Ready` pods change to when it is reflected in that dns instance, measured as 99th percentile over last 5 minutes aggregated across all dns instances | In default Kubernetes installation, 99th percentile per cluster-day[1](#footnote1) <= X | [Details](./dns_programming_latency.md) |
| __WIP__ | In-cluster network latency from a single prober pod, measured as latency of per second ping from that pod to "null service", measured as 99th percentile over last 5 minutes. | In default Kubernetes installataion with RTT between nodes <= Y, 99th percentile of (99th percentile over all prober pods) per cluster-day[1](#footnote1) <= X | [Details](./network_latency.md) |
| __WIP__ | In-cluster dns latency from a single prober pod, measured as latency of per second DNS lookup for "null service" from that pod, measured as 99th percentile over last 5 minutes. | In default Kubernetes installataion with RTT between nodes <= Y, 99th percentile of (99th percentile over all prober pods) per cluster-day[1](#footnote1) <= X | [Details](./dns_latency.md) |

\[1\] For the purpose of visualization it will be a
sliding window. However, for the purpose of SLO itself, it basically means
"fraction of good minutes per day" being within threshold.

### Other SLIs

| Status | SLI | User stories, ... |
| --- | --- | --- |
| WIP | Watch latency for every resource, (from the moment when object is stored in database to when it's ready to be sent to all watchers), measured as 99th percentile over last 5 minutes | [Details](./watch_latency.md) |
| WIP | Admission latency for each admission plugin type, measured as 99th percentile over last 5 minutes | [Details](./api_extensions_latency.md) |
| WIP | Webhook call latency for each webhook type, measured as 99th percentile over last 5 minutes | [Details](./api_extensions_latency.md) |

repository: kubernetes/community

gha_language: Jupyter Notebook

repo_name: kubernetes/community


text:
# THE TELLIGENT COMMUNITY MOBILE SDK IS NO LONGER SUPPORTED.

## Telligent Community Mobile SDK
###What is the Telligent Community Mobile SDK?
The Telligent Community Mobile SDK includes both a production ready iOS app and Android app for accessing Telligent Community 8.0+ communities. The Telligent Community Mobile SDK is built using [Apache Cordova](https://cordova.apache.org/) and includes full source code.

####Where is the documentation?
The developer documentation is [published in our community](http://community.telligent.com/developers/w/mobilesdk8). The documentation will eventually be moved to the wiki section of this repository.

####How do I report a bug?
You can use the [issues section](https://github.com/Telligent/Social-Sitecore-SDK/issues/) of this repository to report any issues.

####Where can I ask questions?
Please visit our [developer community](http://community.telligent.com/community/f/1945) to ask questions, get answers, collaborate and connect with other developers. Plus, give us feedback there so we can continue to improve these tools for you.

####Can I contribute?
Yes, we will have more details soon on how you can contribute

repository: Telligent/Mobile-SDK

repo_name: Telligent/Mobile-SDK


text:
Pattern: Empty `then` clause

Issue: -

## Description

Shells do not allow empty `then` clauses. They need at least one command (and comments are not commands).

If you want a `then` clause that does nothing, use a dummy command like `true`.

Example of **incorrect** code:

```sh
if [ -e foo ]
then
  # TODO: handle this
fi
```
Example of **correct** code:
```sh
if [ -e foo ]
then
  # TODO: handle this
  true
fi

# Or use the no-op colon operator ":"
if [ -e foo ]
then
  # TODO: handle this
  :
fi
```

## Further Reading

* [ShellCheck - SC1048](https://github.com/koalaman/shellcheck/wiki/SC1048)

repository: Adroiti/docs-for-code-review-tools

repo_name: Adroiti/docs-for-code-review-tools


text:
---
title: "CRLF Injection"
alertid: 40003
alertindex: 4000300
alerttype: "Active"
alertcount: 1
status: release
type: alert
risk: Medium
solution: "Type check the submitted parameter carefully.  Do not allow CRLF to be injected by filtering CRLF."
references:
   - http://www.watchfire.com/resources/HTTPResponseSplitting.pdf
   - http://webappfirewall.com/lib/crlf-injection.txtnull
   - http://www.securityfocus.com/bid/9804
other: ""
cwe: 113
wasc: 25
alerttags:
  - OWASP_2017_A01
  - OWASP_2021_A03
  - WSTG-v42-INPV-15
code: https://github.com/zaproxy/zap-extensions/blob/main/addOns/ascanrules/src/main/java/org/zaproxy/zap/extension/ascanrules/CrlfInjectionScanRule.java
linktext: "org/zaproxy/zap/extension/ascanrules/CrlfInjectionScanRule.java"
---
Cookie can be set via CRLF injection.  It may also be possible to set arbitrary HTTP response headers. In addition, by carefully crafting the injected response using cross-site script, cache poisoning vulnerability may also exist.

repository: zaproxy/zaproxy-website

repo_name: zaproxy/zaproxy-website


text:
# About

Rubycon is a CLI for managing Source dedicated game servers (TF2, CS:S...). Think of it as a [HSLW](http://www.hlsw.org) clone, but terminal-based.

![Screenshot](http://i.imgur.com/k8q3zXO.png)

Features:

* RCON session with auto completion :exclamation:
* Overview of all your servers
* Bulk execution of rcon commands :boom:
* Start game client and join servers from the command line

Follow this gem on [Twitter](https://twitter.com/rubycon_cli).

# Installation

Make sure you're on Ruby 2.0 or later (`ruby --version`).

You'll also need readline:

* RHEL based:   `yum install readline-devel`
* Debian based: `apt-get install libreadline-dev`

Install rubycon with the following command:

`$ gem install rubycon`

# Usage

First of all, add a game server to rubycon:

```
$ rubycon add my_server \
    --address=<IP_ADDRESS> \
    --rcon=foobar
```

Time to check out how your server is doing:

```
$ rubycon list
Server                   Map     Players      Ping
my_server          ctf_2fort        4/25        42
```

Hop into a rcon session:

```
$ rubycon console my_server
Use CTRL+D to exit.
> sta
star_memory  startdemos   startmovie   startupmenu  stats        status
> status
hostname: MyServer
version : 1797820/24 5331 secure
udp/ip  : <IP_ADDRESS>:27015  (public ip: <IP_ADDRESS>)
account : not logged in  (No account specified)
map     : ctf_2fort at: 0 x, 0 y, 0 z
sourcetv:  port 27020, delay 90.0s
players : 0 (25 max)

# userid name                uniqueid            connected ping loss state  adr
>
```

Need stats from all your servers? Yes sir:

```
$ rubycon execute --command=stats --all
my_server:
CPU    In (KB/s)  Out (KB/s)  Uptime  Map changes  FPS      Players  Connects
0.00   0.00       0.00        5093    7            62.44    0        1
---------------------------------
```

Need further help?
`$ rubycon help`
`$ rubycon help execute`
`$ rubycon help rm`
...

# Contributing

* Fork it
* Create your feature branch (`git checkout -b my-new-feature`)
* Commit your changes (`git commit -am 'Add some feature'`)
* Push to the branch (`git push origin my-new-feature`)
* Create new Pull Request

# Code Status

* [![Gem Version](https://badge.fury.io/rb/rubycon.png)](http://badge.fury.io/rb/rubycon)
* [![Build Status](https://travis-ci.org/nTraum/rubycon.png?branch=master)](https://travis-ci.org/nTraum/rubycon)
* [![Dependency Status](https://gemnasium.com/nTraum/rubycon.png)](https://gemnasium.com/nTraum/rubycon)
* [![Code Climate](https://codeclimate.com/github/nTraum/rubycon.png)](https://codeclimate.com/github/nTraum/rubycon)

# License

rubycon is released under the [MIT](http://opensource.org/licenses/MIT) License.

repository: nTraum/rubycon

repo_name: nTraum/rubycon


text:
#Your servant has found favor in your sight

To be pleased with someone is spoken as if "favor" were an object that is found. Also, "sight" is a metonym that stands for a person's thoughts or opinions. AT: "You have been pleased with me" (UDB) (See: [[:en:ta:vol1:translate:figs_metaphor]] and [[:en:ta:vol2:translate:figs_metonymy]])

#Your servant has

Lot was showing respect by referring to himself as "your servant." AT: "I, your servant, have" (See: [[:en:ta:vol2:translate:figs_123person]])

#you have shown me great kindness in saving my life

The abstract noun "kindness" can be stated as "kind." AT: "you have been very kind to me by saving my life" (See: [[:en:ta:vol2:translate:figs_abstractnouns]])

#I cannot escape to the mountains, because the disaster will overtake me, and I will die

Being unable to get far enough away from Sodom when God destroys the city is spoken of as if "disaster" is a person that will chase and catch up with Lot. AT: "My family and I will certainly die when God destroys the people of Sodom, because the mountains are too far away for us to get there safely" (See: [[:en:ta:vol2:translate:figs_personification]])

#my life ...  AT: "our lives ... we cannot escape ... overtake us, and we will die" (See: [[:en:ta:vol1:translate:figs_explicit]])

#let me escape there (is it not a little one?), and my life will be saved

Lot used this rhetorical question to get the angels to notice that the city really is a small one. AT: "let me escape there. You can see how small it is.  AT: "instead of destroying that city, let me escape there" (See: [[:en:ta:vol1:translate:figs_explicit]])

#my life will be saved

It is implied that the lives Lot's family will be saved along with his. This can also be stated in active form. AT: "we will live if you let " (See: [[:en:ta:vol1:translate:figs_explicit]] and [[:en:ta:vol2:translate:figs_activepassive]])


text:
HA Keycloak
=========

This role should be applied after `geerlingguy.java` and `andrewrothstein.keycloak` to alter the default install of Keycloak to:

1. Create a `keycloak` user and group
2. Create an admin user/password based on the `keycloak_admin_user` and `keycloak_admin_password` role variables
3. Create the necessary folder structure for postgres
4. Download the jdbc driver
5. Make the necessary xml changes to enable postgres as the backend database
6. Create a `launch.sh` script, launcher config file, and systemd service
7. Start/enable the keycloak service

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

* Currently, this only has been tested on Keycloak version 10.0.2 - your mileage will vary with other versions (probably poorly as I'm doing a wholesale replacement of the standalone xml files.
* See the sample playbook for specific settings that have been tested for the java/keycloak
* **This role should have `become` set to `yes`.**

Role Variables
--------------

Multiple variables are leveraged for this role

* `keycloak_version`: Used to derive the `keycloak_root` and subsequent `keycloak_standalone_config` / `postgres_module_path` (see `defaults/main.yml`)
* `keycloak_admin` and `keycloak_admin_password`: Used for first admin account creation
* `postgres_jar`: Used to specify which version of PostgreSQL Keycloak will use (used to derive the `postgres_module_path`).
* `postgres_server`: Indicates the address for the postgres instance
* `postgres_db`: Indicates the database to use for postgres (note this should have UTF-8 encoding)
* `postgres_username` / `postgres_password`: Connection account/details

Dependencies
------------

* **`geerlingguy.java`**

```
java_packages:
  - openjdk-8-jdk
```

* **`andrewrothstein.keycloak`**

```yaml
keycloak_ver: '10.0.2'
keycloak_checksums:
   '10.0.2': sha1:2b90bdefd3c837b2f3cc3d44263b6503cd6fbf62
```

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

    - hosts: servers
      roles:
         - { role: range.hakeycloak, become: yes }

License
-------

BSD

repository: pezhore/ansible-role-hakeycloak

repo_name: pezhore/ansible-role-hakeycloak


text:
# simon - SImple MONItoring

simon is a simple monitoring tool.
All it does is sending HTTP GET request to definied URLs and logging the status code and request time.

## Configure

The configuration is done in a XML file. i.e.

``` xml
<hosts name="My Monitor">
    <group name="Production">
        <host name="simas GmbH" url="https://www.simas.ch" />
        <host name="Google" url="https://www.google.com" />
    </group>
</hosts>
```
## Download

[http://repo1.maven.org/maven2/ch/simas/monitor/simon/2.0.1/simon-2.0.1.jar](http://repo1.maven.org/maven2/ch/simas/monitor/simon/2.0.1/simon-2.0.1.jar)

## Run

simon uses Spring Boot. To configure the runtime simple create a application.properties.
The application.properties file must be in the same folder as the jar file.
```
server.port=7272
simon.config.hosts=myhosts.xml
```

Then start it with

```
java -jar simon-2.0.0.jar
```

## See

The result is either JSON or XML depending on the content type when on [http://localhost:7272/check](http://localhost:7272/check) or a simple web page on [http://localhost:4567/check](http://localhost:4567/check)

# License

simon is open source and free software under Apache License, Version 2:

[http://www.apache.org/licenses/LICENSE-2.0.html](http://www.apache.org/licenses/LICENSE-2.0.html)

repository: simasch/simon

repo_name: simasch/simon


text:
# Algos

[![Travis status][travis-shield]][travis-link]
[![Gitter](https://img.shields.io/gitter/room/Algos/Algos.svg?style=for-the-badge)](https://gitter.im/Algos-f)

Implementing well-known (and some rare) **algorithms and data structures**, while following **good software engineering practices** such as writing well-documented code, adhering to code guidelines, writing unit tests, reviewing each other's code, and ultimately learning to be better software developers.

## Goals

1. Guide potential contributors on version control, unit testing, and algorithms.
1. Add at least one algorithm every week.

## How to get involved

There are a few ways to get involved.

#### Want to contribute to open-source and get involved with the project?

1. **Read** the [contribution guidelines][contrib-guide]
1. **Fork** the repo
1. **Create an issue** describing what you'd like to add, or **claim an issue** that's [up for grabs][up-for-grabs]
1. Create a **branch** and **add your code**
1. Submit a **pull request** and reference the issue it closes

You can find more details regarding the steps above in the [contribution
guidelines][contrib-guide], so be sure to check them out.

#### Just want to suggest a new algorithm or report a bug?

[Create a new issue](https://github.com/faheel/Algos/issues/new) and we'll
handle it from there. :smile:

## Maintainers

This repo is actively maintained by [@alxmjo](https://github.com/alxmjo), and inactively by [@faheel](https://github.com/faheel).

## License

This project is licensed under the terms of the [MIT license](LICENSE.md).

[travis-shield]: https://img.shields.io/travis/faheel/Algos.svg?style=for-the-badge
[travis-link]: https://travis-ci.org/faheel/Algos
[contrib-guide]: .github/CONTRIBUTING.md
[up-for-grabs]: https://github.com/faheel/Algos/labels/Up%20for%20grabs


text:
Apache Streams (incubating)
Licensed under Apache License 2.0 - http://www.apache.org/licenses/LICENSE-2.0
--------------------------------------------------------------------------------

gmail-export-standalone
==============================

Requirements:
-------------
 - A GMail account

Description:
------------
Pulls down a stream of emails for a given GMail account

Specification:
-----------------

[FacebookUserstreamElasticsearch.dot](src/main/resources/FacebookUserstreamElasticsearch.dot "ElasticsearchReserialize.dot" )

Diagram:
-----------------

![FacebookUserstreamElasticsearch.png](./FacebookUserstreamElasticsearch.png?raw=true)

Example Configuration:
----------------------

    include "reference"
    gmail {
        username = ""
        password = ""
    }

You will need to include the username and password for the GMail account you would like to connect to

Running:
--------

    java -cp target/gmail-export-standalone-0.1-SNAPSHOT.jar -Dconfig.file=src/main/resources/application.conf org.apache.streams.gmail.example.GMailExportStandalone

Verification:
-------------
You should see your latest emails streaming into the console


text:
### [CVE-2017-1297](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2017-1297)
![](https://img.shields.io/static/v1?label=Product&message=DB2%20for%20Linux%2C%20UNIX%20and%20Windows&color=blue)
![](https://img.shields.io/static/v1?label=Version&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Vulnerability&message=Gain%20Privileges&color=brighgreen)

### Description

IBM DB2 for Linux, UNIX and Windows 9.2, 10.1, 10.5, and 11.1 (includes DB2 Connect Server) is vulnerable to a stack-based buffer overflow, caused by improper bounds checking which could allow a local attacker to execute arbitrary code. IBM X-Force ID: 125159.

### POC

#### Reference
- https://www.exploit-db.com/exploits/42260/

#### Github
No PoCs found on GitHub currently.

repository: trickest/cve

branch_name: refs/heads/main

repo_name: trickest/cve


text:
Not in compliance with OWASP Mobile Top 10 for M8 - Side Channel Data
Leakage A general Pasteboard implementation looks like the following

    // setup: let's put some stuff in the UIPasteboard

    let pasteboard = UIPasteboard.general()
    pasteboard.string = "andy"
    pasteboard.url = URL(string: "http://cleanswifter.com")
    pasteboard.image = UIImage()
    pasteboard.color = UIColor.red()

    // understanding the UIPasteboard contents

    if pasteboard.hasStrings {
        print("The pasteboard has Strings!")
    }
    if pasteboard.hasURLs {
        print("The pasteboard has URLs!")
    }
    if pasteboard.hasImages {
        print("The pasteboard has images!")
    }
    if pasteboard.hasColors {
        print("The pasteboard has colors!")
    }

repository: appknox/vulnerabilities

repo_name: appknox/vulnerabilities


text:
---
subcategory: "Deployment"
---

# databricks_aws_assume_role_policy Data Source

This data source constructs necessary AWS STS assume role policy for you.

## Example Usage

End-to-end example of provisioning Cross-account IAM role with [databricks_mws_credentials](../resources/mws_credentials.md) and [aws_iam_role](https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/iam_role):

```hcl
variable "databricks_account_id" {
  description = "Account Id that could be found in the bottom left corner of https://accounts.cloud.databricks.com/"
}

data "databricks_aws_crossaccount_policy" "this" {}

resource "aws_iam_policy" "cross_account_policy" {
  name   = "${var.prefix}-crossaccount-iam-policy"
  policy = data.databricks_aws_crossaccount_policy.this.json
}

data "databricks_aws_assume_role_policy" "this" {
  external_id = var.databricks_account_id
}

resource "aws_iam_role" "cross_account" {
  name               = "${var.prefix}-crossaccount-iam-role"
  assume_role_policy = data.databricks_aws_assume_role_policy.this.json
  description        = "Grants Databricks full access to VPC resources"
}

resource "aws_iam_role_policy_attachment" "cross_account" {
  policy_arn = aws_iam_policy.cross_account_policy.arn
  role       = aws_iam_role.cross_account.name
}

// required only in case of multi-workspace setup
resource "databricks_mws_credentials" "this" {
  provider         = databricks.mws
  account_id       = var.databricks_account_id
  credentials_name = "${var.prefix}-creds"
  role_arn         = aws_iam_role.cross_account.arn
}
```

## Argument Reference

* `external_id` (Required) Account Id that could be found in the bottom left corner of [Accounts Console](https://accounts.cloud.databricks.com/).
* `for_log_delivery` (Optional) Either or not this assume role policy should be created for usage log delivery. Defaults to false.

## Attribute Reference

In addition to all arguments above, the following attributes are exported:

* `json` - AWS IAM Policy JSON document

## Related Resources

The following resources are used in the same context:

* [Provisioning AWS Databricks E2 with a Hub & Spoke firewall for data exfiltration protection](../guides/aws-e2-firewall-hub-and-spoke.md) guide
* [databricks_aws_bucket_policy](aws_bucket_policy.md) data to configure a simple access policy for AWS S3 buckets, so that Databricks can access data in it.
* [databricks_aws_crossaccount_policy](aws_crossaccount_policy.md) data to construct the necessary AWS cross-account policy for you, which is based on [official documentation](https://docs.databricks.com/administration-guide/account-api/iam-role.html#language-Your%C2%A0VPC,%C2%A0default).

repository: jxbell/terraform-provider-databricks

repo_name: jxbell/terraform-provider-databricks


text:
# TaskManagerMaster
一个Android的任务管理器（Task Manager Master, TMM）。将一项任务分成待完成、已完成、正在做、未完成四个类别，方便日程生活中的管理

# 截图
![pic1](screen/main.png)

![pic2](screen/add.png)

![pic3](screen/new.png)

![pic4](screen/swipe.png)

![pic5](screen/another_swipe.png)

![pic6](screen/notify1.jpg)

![pic7](screen/notify2.jpg)

![pic8](screen/anim.jpg)

你可以在这里下载安装程序 [download](https://raw.githubusercontent.com/csulennon/TaskManagerMaster/master/bin/taskmanagermaster.apk)

License
-------
 Copyright 2015 csulennon

    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.


text:
# Change Log

All notable changes to this project will be documented in this file.
See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.

# [0.5.0](https://github.com/Himenon/code-dependency/packages/cli/compare/v0.4.1...v0.5.0) (2020-02-10)

### Features

- update dependnecy-cruiser@v7 and add libcheck ([fff7800](https://github.com/Himenon/code-dependency/packages/cli/commit/fff7800))

## [0.4.1](https://github.com/Himenon/code-dependency/packages/cli/compare/v0.4.0...v0.4.1) (2020-02-07)

### Bug Fixes

- cli initialize error ([70668cc](https://github.com/Himenon/code-dependency/packages/cli/commit/70668cc))

### Performance Improvements

- **static-page:** not access full.render.js ([e05b86a](https://github.com/Himenon/code-dependency/packages/cli/commit/e05b86a))

# [0.4.0](https://github.com/Himenon/code-dependency/packages/cli/compare/v0.3.9...v0.4.0) (2020-02-07)

### Documentation

- **cli:** update arguments ([4671ae0](https://github.com/Himenon/code-dependency/packages/cli/commit/4671ae0))
- **cli:** update export static docs ([ebde7a8](https://github.com/Himenon/code-dependency/packages/cli/commit/ebde7a8))
- update README ([b75167f](https://github.com/Himenon/code-dependency/packages/cli/commit/b75167f))

### Features

- **view:** add client and server renderer ([6775e3d](https://github.com/Himenon/code-dependency/packages/cli/commit/6775e3d))
- add cli exception ([a3e8426](https://github.com/Himenon/code-dependency/packages/cli/commit/a3e8426))
- add error template ([144bf70](https://github.com/Himenon/code-dependency/packages/cli/commit/144bf70))
- add native dot engine ([4369d7d](https://github.com/Himenon/code-dependency/packages/cli/commit/4369d7d))
- add redirect settings ([e48fb94](https://github.com/Himenon/code-dependency/packages/cli/commit/e48fb94))
- add rendererType ([ec1c4a8](https://github.com/Himenon/code-dependency/packages/cli/commit/ec1c4a8))
- create svg element api ([07d3fd7](https://github.com/Himenon/code-dependency/packages/cli/commit/07d3fd7))
- enabled render over 300kb dot source ([35bd148](https://github.com/Himenon/code-dependency/packages/cli/commit/35bd148))
- update svg-element api ([fd9d37d](https://github.com/Himenon/code-dependency/packages/cli/commit/fd9d37d))

## [0.3.9](https://github.com/Himenon/code-dependency/packages/cli/compare/v0.3.8...v0.3.9) (2020-02-06)

### Chores

- **deps:** update dependencies ([4834458](https://github.com/Himenon/code-dependency/packages/cli/commit/4834458))

## 0.3.8 (2020-02-06)

**Note:** Version bump only for package @code-dependency/cli

## 0.3.7 (2020-02-05)

**Note:** Version bump only for package @code-dependency/cli

## 0.3.6 (2020-01-15)

**Note:** Version bump only for package @code-dependency/cli

## 0.3.5 (2020-01-15)

**Note:** Version bump only for package @code-dependency/cli

## 0.3.4 (2020-01-08)

**Note:** Version bump only for package @code-dependency/cli

## 0.3.3 (2020-01-07)

**Note:** Version bump only for package @code-dependency/cli

## 0.3.2 (2020-01-07)

**Note:** Version bump only for package @code-dependency/cli

## [0.3.1](https://github.com/Himenon/code-dependency/packages/cli/compare/v0.3.0...v0.3.1) (2020-01-06)

### Bug Fixes

- no-non-package-json resolve-pkg ([758bbaa](https://github.com/Himenon/code-dependency/packages/cli/commit/758bbaa))

# [0.3.0](https://github.com/Himenon/code-dependency/packages/cli/compare/v0.2.0...v0.3.0) (2020-01-06)

### Bug Fixes

- Invalid Hook Call Warning ([9e07e6a](https://github.com/Himenon/code-dependency/packages/cli/commit/9e07e6a))

### Features

- add memory leak comment ([3f678f5](https://github.com/Himenon/code-dependency/packages/cli/commit/3f678f5))
- add tsconfig option & update cli absolute path ([0b5f54f](https://github.com/Himenon/code-dependency/packages/cli/commit/0b5f54f))
- cli server change csr from ssr ([0c20627](https://github.com/Himenon/code-dependency/packages/cli/commit/0c20627))
- remove [@elastic](https://github.com/elastic)/eui ([d1ffe09](https://github.com/Himenon/code-dependency/packages/cli/commit/d1ffe09))
- revive ssr ([bfda64f](https://github.com/Himenon/code-dependency/packages/cli/commit/bfda64f))
- update bin script ([7c64a8d](https://github.com/Himenon/code-dependency/packages/cli/commit/7c64a8d))
- update cli path arguments validator ([4117803](https://github.com/Himenon/code-dependency/packages/cli/commit/4117803))

# [0.2.0](https://github.com/Himenon/code-dependency/packages/cli/compare/v0.0.1-alpha.7...v0.2.0) (2020-01-03)

### Bug Fixes

- release dependency ([f6c5040](https://github.com/Himenon/code-dependency/packages/cli/commit/f6c5040))
- search base path ([53e4847](https://github.com/Himenon/code-dependency/packages/cli/commit/53e4847))
- vizjs error ([2b47488](https://github.com/Himenon/code-dependency/packages/cli/commit/2b47488))

### Documentation

- update readme ([5d5ba95](https://github.com/Himenon/code-dependency/packages/cli/commit/5d5ba95))

### Features

- add api ([a83ce40](https://github.com/Himenon/code-dependency/packages/cli/commit/a83ce40))
- add cli tool ([be81210](https://github.com/Himenon/code-dependency/packages/cli/commit/be81210))
- add dependency-cruiser ([eb51621](https://github.com/Himenon/code-dependency/packages/cli/commit/eb51621))
- add ssr props ([080569e](https://github.com/Himenon/code-dependency/packages/cli/commit/080569e))
- add webpack build for cli & fix hooks error ([7917d4b](https://github.com/Himenon/code-dependency/packages/cli/commit/7917d4b))
- add webpack settings ([09b2a6b](https://github.com/Himenon/code-dependency/packages/cli/commit/09b2a6b))
- can show graphviz ([4ba4c08](https://github.com/Himenon/code-dependency/packages/cli/commit/4ba4c08))
- remove files ([2f67328](https://github.com/Himenon/code-dependency/packages/cli/commit/2f67328))
- server side rendering settings ([0af1607](https://github.com/Himenon/code-dependency/packages/cli/commit/0af1607))
- update [@elastic](https://github.com/elastic)/eui settings ([be2a038](https://github.com/Himenon/code-dependency/packages/cli/commit/be2a038))
- update build settings ([995546e](https://github.com/Himenon/code-dependency/packages/cli/commit/995546e))
- update cli architecture ([cf0ec85](https://github.com/Himenon/code-dependency/packages/cli/commit/cf0ec85))
- update client side props ([07ca26a](https://github.com/Himenon/code-dependency/packages/cli/commit/07ca26a))
- update dependencies version ([62363a3](https://github.com/Himenon/code-dependency/packages/cli/commit/62363a3))
- update develop settings ([#17](https://github.com/Himenon/code-dependency/packages/cli/issues/17)) ([d7f96f8](https://github.com/Himenon/code-dependency/packages/cli/commit/d7f96f8))
- update eui settings ([fae1491](https://github.com/Himenon/code-dependency/packages/cli/commit/fae1491))
- update package.json settings ([021e4d0](https://github.com/Himenon/code-dependency/packages/cli/commit/021e4d0))
- update tsconfig ([b168868](https://github.com/Himenon/code-dependency/packages/cli/commit/b168868))
- update version ([ec7e958](https://github.com/Himenon/code-dependency/packages/cli/commit/ec7e958))
- update yarn.lock ([5f5f994](https://github.com/Himenon/code-dependency/packages/cli/commit/5f5f994))

### Performance Improvements

- update performance ([c981e88](https://github.com/Himenon/code-dependency/packages/cli/commit/c981e88))

repository: n-hidaka/code-dependency

repo_name: n-hidaka/code-dependency


text:
# Sample project

This is a sample project to show how to use the `react-native-fontawesome` package. The version of React Native used in this project is 0.59.9. The version of Font Awesome used in this project is 5.9.0 Free.

### - Running on Android

* First `npm i` or `yarn` to install de dependencies
* Then `react-native run-android` to build and run the application

### - Running on IOS

* First `npm i` or `yarn` to install de dependencies
* Then, open a terminal in the `sample/ios/` folder then execute `Pod install` to install Pods
* Then `react-native run-ios` to build and run the application in the emulator
* If you want to run in a device, just open the `sample/ios/sample.xcworkspace` in `XCode` and click the `Run` button with the device plugged and selected.

repository: entria/react-native-fontawesome

repo_name: entria/react-native-fontawesome


text:
# Legolas
The only smart-elf slack bot you need to fight them annoying ads.

## Introduction
Hi, this is Legolas, son of Thranduil, the King of the Elves of Northern Mirkwood. am here to help you read urls without any annoying popups or ads which I feel is Sauron's plot to drive us crazy.

Whenever you need my help, just say _do <url>_ and I will be at your services!

## But why?
I am a crazy reddit user (should probably uninstall that app) and I have noticed sometimes I would open a link and the website will block me out because I use adblocker extension, which is super annoying TBH.

 Pretty impressive!

So, here at Shuttl, we have a pretty active slack group where a lot of urls are shared in a simillar fashion. I was getting bugged with the same problem here and couldn't find any alternative for the same so decided to get my hands dirty and create one myself. :)

## Cool story bro, how does it work?
Well, you first have to deploy this to get it to work in your channel (I might clean up code, add some features and post it in slack public library soon).

I will be writing down the deployment process soon (need to sleep for now).

Example: **@Legolas do http://lotr.wikia.com/wiki/Legolas**

and....

### VOILA!!

![Legolas](https://i.imgur.com/xqB1CmO.png)
_Ad-free, distraction-free inline reading without the need to even open the url._

## Deployment Instructions
TODO

## Contribution Guidelines
TODO

repository: jatinkrmalik/Legolas

repo_name: jatinkrmalik/Legolas


text:
# IO Builders challenge

This is a sample project about Ports and Adapters, CQRS and DDD.

To keep it as simple as possible there is no external DB or Message Broker so all the commands and events are synchronous.

### Requisites

You'll only need [docker](https://www.docker.com/get-started) to run this project.

## Project structure

The project is composed by one application, the one attached to the framework, and two contexts.

### Challenge App (apps)

This is the framework application, in this case Symfony.

### Challenge Context (src)

This context has the core domain and business logic for the User and the Account. It also manages the account operations
like: buy, sell and transfer.

### Ethereum Context (src)

This context is the adapter to the Ethereum server. Due lack of libraries in PHP that can interact with Ethereum is a mock.

## Test and Initialization

You can interact with the project with following commands of the makefile:

```
make test               # run unit tests
make behat              # run integration tests
make composer-install   # install dependencies
make dockerize          # create an image of the project, install dependecies
make start              # create the image and run the project
```

There is a postman collection in the project to try all the endpoints.

repository: luismariaperez/iopoc

repo_name: luismariaperez/iopoc


text:
Integrating Text Matching and Product Substitutability
======================================================

Data collection
----

We use the [Amazon product data](http://jmcauley.ucsd.edu/data/amazon) published by McAuley et al. at SIGIR 2015. You can obtain the data by following the [provided instructions](http://jmcauley.ucsd.edu/data/amazon/amazon_readme.txt).

We make use of the `Pet_Supplies`, `Sports_and_Outdoors`, `Toys_and_Games` and `Electronics` reviews and metadata data files (full, not the 5-core). For more information, see the [CIKM 2016 paper](https://arxiv.org/pdf/1608.07253.pdf) where the evaluation sets were first introduced.

|      | Pet Supplies | Sports & Outdoors | Toys & Games | Electronics |
| ---- | ------------------ | ---------------------------- | -------------- | --------------------- |
| Product lists | [product_list](resources/product-substitutability/pet_supplies/product_list) | [product_list](resources/product-substitutability/sports_and_outdoors/product_list) | [product_list](resources/product-substitutability/toys_and_games/product_list) | [product_list](resources/product-substitutability/electronics/product_list) |
| Product substitute relations | [substitutes](resources/product-substitutability/pet_supplies/substitutes) | [substitutes](resources/product-substitutability/sports_and_outdoors/substitutes) | [substitutes](resources/product-substitutability/toys_and_games/substitutes) | [substitutes](resources/product-substitutability/electronics/substitutes) |
| Topics | [topics](resources/product-substitutability/pet_supplies/topics) | [topics](resources/product-substitutability/sports_and_outdoors/topics) | [topics](resources/product-substitutability/toys_and_games/topics) | [topics](resources/product-substitutability/electronics/topics) |
| Relevance | [qrel_test](resources/product-substitutability/pet_supplies/qrel_test) [qrel_validation](resources/product-substitutability/pet_supplies/qrel_validation) | [qrel_test](resources/product-substitutability/sports_and_outdoors/qrel_test) [qrel_validation](resources/product-substitutability/sports_and_outdoors/qrel_validation) | [qrel_test](resources/product-substitutability/toys_and_games/qrel_test) [qrel_validation](resources/product-substitutability/toys_and_games/qrel_validation) | [qrel_test](resources/product-substitutability/electronics/qrel_test) [qrel_validation](resources/product-substitutability/electronics/qrel_validation) |

Usage
-----

To replicate the experiments of the paper on **integrating text matching and product substitutability**, build an Indri index where every product is represented by the union of its description and its reviews as described in the experimental setup section of the [CIKM 2018 paper](https://staff.fnwi.uva.nl/m.derijke/wp-content/papercite-data/pdf/van-gysel-mix-n-match-2018.pdf). Secondly, follow the tutorial for the [2018 TOIS paper](https://arxiv.org/abs/1708.02702) on neural vector spaces that can be found [here](TUTORIAL.md).

The substitution relations (or, in fact, any document/document similarity relations) can be passed to [`cuNVSMTrainModel`](https://github.com/cvangysel/cuNVSM/blob/master/cpp/main.cu#L657) as a second positional argument that follows the path to the Indri index. The [`--entity_similarity_weight`](https://github.com/cvangysel/cuNVSM/blob/master/cpp/main.cu#L73) flag controls the mixture weight between text and substitutability signals.

Citation
--------

If you use cuNVSM to produce results for your scientific publication, please refer to our [TOIS](https://arxiv.org/abs/1708.02702) and [CIKM 2018](https://staff.fnwi.uva.nl/m.derijke/wp-content/papercite-data/pdf/van-gysel-mix-n-match-2018.pdf) papers:

```
@article{VanGysel2018nvsm,
  title={Neural Vector Spaces for Unsupervised Information Retrieval},
  author={Van Gysel, Christophe and de Rijke, Maarten and Kanoulas, Evangelos},
  publisher={ACM},
  journal={TOIS},
  year={2018},
}

@inproceedings{VanGysel2018substitutability,
  title={Mix ’n Match: Integrating Text Matching and Product Substitutability within Product Search},
  author={Van Gysel, Christophe and de Rijke, Maarten and Kanoulas, Evangelos},
  booktitle={CIKM},
  volume={2018},
  year={2018},
  organization={ACM}
}
```

repository: Bernhard-Steindl/cuNVSM

repo_name: Bernhard-Steindl/cuNVSM