text:
---
layout: post
title:      "Learning how to learn how to code"
date:       2018-05-08 02:22:33 +0000
permalink:  learning_how_to_learn_how_to_code
---

My time here at Flatiron School has been incredible. It's been challenging, frustrating, rewarding and fun !

As I approach the end of this program I can't help but look back at where I started. The amount of concepts and code I have learned is dizzying but more importantly my understanding of what coding is and it's process has completely evolved.

It's taken me a while, but I'm learning to slow down when things go wrong. Do some research, read some documentation and sniff around on google. I'm less afraid to try things out, throw some different ideas at the problem and see what sticks. Experimentation with different approaches doesn't seem to feel completely overwhelming these days.

Things can still be frustrating, super confusing and challenging. (trying to get my rails app to work on Heroku for the first time is a good example).

This leads me to the biggest lesson I've learned : I will never stop learning.
This is what makes coding one of the most interesting and challenging occupations out there. It just never stops evolving - so I can't stop evolving.  It's an aspect of this I love.

The more I learn the more I realize how little I really know. There are endless trick and approaches to problems. There are more advanced concepts I haven't even started wrapping my head around.  There are more languages to learn, platforms to experiment with and libraries to play with.

I love building things. Coding is the endless toolbox to make things limited only by knowledge and imagination.

I am excited for the future - I want to learn more and to build more. I feel like Flatiron School has given me the foundation I needed to build on. For that I'm very grateful !


text:
## NBC-Blockchain

Semester project for _**Distributed Systems**_ @ ECE NTUA

The purpose was to create a bitcoin-like blockchain (without merkle proofs etc) called NoobCoin (NBC)

The code is included in Scaffold_Code folder

This is a collaborate effort of the following contibutors:

| Name       | Surname | Semester |
| ----- | ------- | ------- |
| Panagiotis | Tzortzis | 9 |
| Dafne | Papaefthimiou | 9 |
| Danae | Xezonaki | 11 |

**DISCLAIMER**

Although this is a fully functional blockchain, it faces some problems due to its architecture. It has practical synchronization problems because of multiple threads accessing the same memory (see FLASK documentation for details). We made some efforts to counter these problems, but since the goal of this course was an introduction to Distributed Systems and not multi-thread programming, you may encounter some bugs if you stress the system with a lot of transactions.

license: MIT

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
# Information-theoretically (IT)-Secure ODSE using Shamir-Secret-Sharing (SSS)-based PIR and Write-Only ORAM

Basic implementation of the ODSE scheme using SSS-based PIR and Write-Only ORAM on SSS-based searchable index. The scheme is described under name ODSE^{WO}_{IT} in the full paper available on ePrint (https://eprint.iacr.org/2017/1158). This project is built on CodeLite IDE (link: http://codelite.org). It is recommended to install CodeLite to load the full ODSE workspace.

# Required Libraries
1. ZeroMQ (download link: http://zeromq.org/intro:get-the-software)
2. Libtomcrypt (download link: https://github.com/libtom/libtomcrypt)
3. Google sparsehash (download link: https://github.com/sparsehash/sparsehash)
4. NTL library v9.10.0  (download link: http://www.shoup.net/ntl/download.html)

# Configuration
The configuration for ODSE scheme is located at ``ODSE_WO_IT/config.h``.

## Important Parameters
```
static const unsigned long P =<PHONE_NUMBER>19774627;        -> prime field (should be ~ 60 bits to use NTL optimized instructions)
#define NP_BITS 59                                       -> the ceiling number of bits of P
#define FF_SIZE 64                                        -> define the size of finite field size (by bit and should be multiplication of 8 and larger than log2(P))

#define MAX_NUM_OF_FILES 12544                  -> define the maximum number of files in the DB (should be multiple of (FF_SIZE * 8)
#define MAX_NUM_KEYWORDS MAX_NUM_OF_FILES       -> define the maximum number of keywords (should be multiple of 8)
#define WRITE_ORAM_LAMBDA 30                    -> define the number of columns/blocks to be downloaded/uploaded in Write-Only ORAM

#define NUM_SERVERS 3                           -> define the number of servers in the system (should be at least 3)
#define PRIVACY_LEVEL 1                         -> definve the privacy parameter t in SSS (should be (NUM_SERVER - 1)/2)
const int SERVER_ID[NUM_SERVERS] ={1,2,3};      -> define ID of servers (should be from 1....P-1)

const std::string SERVER_ADDR[NUM_SERVERS] = {"tcp://localhost:", "tcp://localhost:"};  -> define IP address of servers
const std::string SERVER_PORT[NUM_SERVERS] = {"5555","5556"};                           -> define port of servers

const long long int vandermonde[NUM_SERVERS] = {3,-3+P,1};  ->define the first row of inverse of Vandermonde matrix (corresponding to defined SERVER_IDs)

```

### Notes

The folder ``ODSE_WO_IT/data`` as well as its subfolders are required to store generated encrypted index and client state. The database input is located in ``ODSE_WO_IT/data/DB``. All these locations can be changed in the `config.h` file. The implementation recognize DB as a set of document files so that you can copy your DB files to this location. The current DB contains a very small subset of enron DB (link: https://www.cs.cmu.edu/~./enron/).

# Build & Compile
Goto folder ``ODSE_WO_IT/`` and execute
```
make
```

, which produces the binary executable file named ```ODSE_WO_IT``` in ``ODSE_WO_IT/Debug/``.

# Usage

Run the binary executable file ```ODSE_WO_IT```, which will ask for either Client or Server mode. The scheme can be tested using either **single** machine or **multiple** machines with network:

## Local Testing:
1. Set ``SERVER_ADDR`` in ``IM-DSSE/config.h`` to be ``localhost``.
2. Compile the code with ``make`` in the ``ODSE_WO_IT/`` folder.
4. Go to ``ODSE_WO_IT/Debug`` and run the compiled ``ODSE_WO_IT`` file with two different Terminals, each playing the client/server role.

Note that when running the binary file and selecting the <b>option 1</b> to initalize the encrypted index, press 'n' to avoid transmitting whole encrypted index to the server.

## Real Network Testing:
1. Set ``SERVER_ADDR`` and  ``SERVER_PORT`` in ``ODSE_WO_IT/config.h`` with the corresponding servers' IP address  and port number.
2. Run ``make`` in ``ODSE_WO_IT/`` to compile and generate executable file ``ODSE_WO_IT`` in ``ODSE_WO_IT/Debug`` folder.
3. Copy the file ``ODSE_WO_IT`` in ``ODSE_WO_IT/Debug`` to the servers
4. Execute the file and follow the instruction on the screen.

# Further Information
For any inquiries, bugs, and assistance on building and running the code, please feel free to contact Thang Hoang (hoangmin@oregonstate.edu).

repository: osu-crypto/ODSE

repo_name: osu-crypto/ODSE


text:
# drsteam
A side-project built in React & Node.js. Dr. Steam lets you examine your Steam account and inventory.

## Dependencies
The project relies on API calls for 3rd parties websites, which means you are gonna have to claim 2 API keys:
1. Steam Web API key (https://steamcommunity.com/dev)
2. Steam APIs account (https://steamapis.com/)

## Installation
1. Clone this repository:
`git clone https://github.com/ranmedina/drsteam.git`

2. Modify environment variables (.env - on both server and client side):
### Server
    SECRET_KEY=SECRETKEY
    PORT=3001
    STEAM_APIKEY=STEAMWEB_API_KEY_GOES_HERE
    STEAMAPIS_KEY=STEAMAPIS_KEY_GOES_HERE
    BACKEND_URL=BACKEND_URL_GOES_HERE
    BACKEND_PORT=3001
    PROD_MYSQL_URL=BACKEND_MYSQL_URL_GOES_HERE
    PROD_MYSQL_USERNAME=BACKEND_MYSQL_USERNAME_GOES_HERE
    PROD_MYSQL_PASSWORD=BACKEND_MYSQL_PASSWORD_GOES_HERE
    STEAMID_ADMIN=ADMIN_STEAMID_GOES_HERE

### Client
``REACT_APP_BACKEND_URL=BACKEND_URL_GOES_HERE``

## Build & Deployment
### Development
#### Client
``npm start``
#### Server
``nodemon server.js``

### Production
You are going to need to build the files on client side. The project uses Webpack & Babel for that.
``npm run build``

Build folder "dist" created! Now we can run our server with a production environment variable by running the start.sh file (Linux):
``./start.sh``

repository: ranmedina/drsteam

repo_name: ranmedina/drsteam


text:
### Remove line breaks

Finding a way to remove all new line breaks from a text file, I finally reached the following [solution](https://stackoverflow.com/questions/1251999/how-can-i-replace-a-newline-n-using-sed) using `tr`:

```bash
tr -d '\n' < input.txt > output.txt
```

repository: hlfernandez/til

repo_name: hlfernandez/til


text:
# Sixth-project-news-feed-app
News Feed app which gives a user regularly-updated news from the Internet related to a particular topic, person, or location.
The presentation of the information as well as the topic is up to you.

## Getting Started
This is the News Feed app from the sixth project of Udacity Android Basics Nanodegree: Networking

## Built With
* Connecting to an API
* Parsing the JSON response
* Updating information regularly
* AsyncTask
* Network operations independent of the Activity lifecycle
* Uri.Builder class to add query parameters to the URL

## Authors
Maged Noshy fakhary See also the list of contributors who participated in this project.

## License
This project is licensed under the apache license - see the LICENSE.txt file for details


text:
# Design Notes

Alerts plus aims to completely replace the default alerts system in Factorio. With more features and improved usability, this mod will blow it out of the water! Hopefully.

## Features

- Alerts history
    - Ability to scroll through past alerts and view their details, and re-summon them to the map
- Persistent alerts
    - A different section of the GUI, perhaps?

repository: raiguard/Factorio-AlertsPlus

branch_name: refs/heads/main

repo_name: raiguard/Factorio-AlertsPlus


text:
---
id: country
title: Country vDraft
sidebar_label: Country
---

An object with standardized names would allow for the use of several IDs to define the country - including all well-known data-sets and open symbology reference data as well as custom inhouse IDs if needed.

### Code Examples

* [FDC3 Country](https://github.com/FDC3/ContextData/blob/master/src/examples/Country.ts)

---

## Properties

###  Id: `dictionary`

This is an optional item that should contain at least one reference id, preferably but not limited to the below defined options.

* ISOALPHA2: `string`
* ISOALPHA3: `string`

###  Name: `string`

This is an optional item that can be provided for better understanding of the Object when viewed without a reference database available – eg in a chat window or when linking.

---

repository: donbasuno/finos-fo

gha_language: JavaScript

repo_name: donbasuno/finos-fo


text:
## Custom Tile Map

This example provides supporting files for the blog post [Operational Analytics at ElasticON 2017 - Part 2](https://elastic.co/blog/operational-analytics-at-elasticon-2017-part-2).  This blog post describes the steps for creating a custom tile map for rendering in Kibana e.g. A server room.

### Contents

The files including in this folder include:

* [elastic{ON}_simplified.svg](https://github.com/elastic/examples/blob/master/custom_tile_maps/elastic%7BON%7D_simplified.svg) - A simplified svg for the Elastic{ON} floor plan. This svg is used in the blog post.
* [styles](https://github.com/elastic/examples/tree/master/custom_tile_maps/styles) - A folder of styles for the sample layers created in the blog post.
* [shape_files](https://github.com/elastic/examples/tree/master/custom_tile_maps/shape_files) - A folder of shape files representing the layers created in the blog post. Allows the reader to skip step 1.
* [generate_random_data.py](https://github.com/elastic/examples/blob/master/custom_tile_maps/generate_random_data.py) - A script to generate random data for the floor plan. See below for further details.
* [elastic{ON}_full_floor_plan.pdf](https://github.com/elastic/examples/blob/master/custom_tile_maps/elastic%7BON%7D_full_floor_plan.pdf) - A full pdf of the Elastic{ON} floor plan. This can be used to reproduce the demo at Elastic{ON}. This includes a style tablet.

### Data Generator

The script [generate_random_data.py](https://github.com/elastic/examples/blob/master/custom_tile_maps/generate_random_data.py) allows random data to be generated for the floor plan. By creating document clusters, with a random number of documents, the script aims to produce a range of data clusters for the tile map. Improvements welcome.

#### Version Requirements

The example has been tested in the following versions (earlier versions may work but have not been tested):

- Elasticsearch 5.3.0 or greater
- Python 3.5.x

#### Python dependencies

See [requirements.txt](https://github.com/elastic/examples/blob/master/custom_tile_maps/requirements.txt). Install via pip e.g. `pip install -r requirements.txt`

#### Script options

This script accepts the following **optional** parameters:

* `es_host` - Elasticsearch host and port. Defaults to `localhost:9200`
* `es_user` - Elasticsearch user if X-Pack is installed with basic auth (https not supported). Defaults to `elastic`.
* `es_password` - Elasticsearch password if X-Pack is installed with basic auth (https not supported). Defaults to `changeme`.
* `num_centroids` - Number of clusters/centroids to generate on the floor plan i.e. sources of datapoints. Defaults to `10`.
* `min_per_centroid` - Minimum docs per centroid. Defaults to 10.
* `max_per_centroid` - Maximum docs per centroid. Defaults to 5000.

#### Example

`python generate_random_data.py --es_host localhost:9200 --es_user elastic --es_password changeme --num_centroids 20 -- 0 --max_per_centroid 10000`

repository: vyomshm/examples

repo_name: vyomshm/examples


text:
:::intro
Icons are used to provide additional meaning or in places where text label doesn’t fit. They communicate messages at a glance and draw attention to important information.
:::

Each icon ships in SVG format.

## Usage

The recommended way to use the project icons is to reference them from the sprite:

```svg
<svg viewBox="0 0 1 1" class="c-icon [additional-classes]">
  <use xlink:href="[icon-name]"></use>
</svg>
```

## Styling

You can easily style the icons using CSS:

```css
.c-icon {
  width: 2rem;
  height: 2rem;
  color: $brand-primary;
}
```

repository: dennisreimann/uiengine

gha_license_id: MIT

repo_name: dennisreimann/uiengine


text:
---
date: 2016-11-06T11:04:20-05:00
title: traceability
---

#

For microservices architecture, it is very important to trace request from one servcie to
another in the entire call tree in order to have big picture if something happens or have
an audit log that is aggregated by database or Splunk.

In the framework, we have two Ids to serve this purpose.

## X-Traceability-Id

* Generated by client
* Unique for this client only
* Can be database sequence number or UUID
* Must be passed to the next service
* Must be returned to the caller
* Will be logged in per request audit log

## X-Correlation-Id
* Generated in the immediate service from client
* Must be UUID
* Must be passed to the next service
* Will be logged in per request audit log
* Every service/API must check if this id available and generate one if doesn't exist in request header.

# Pass Ids to the next service/API

In order to pass these ids to the next service, the call to the next service
must use Client module provided by the framework. It will put these ids to
the HttpRequest header with method calls.

Hers is an example to set JWT tokens, traceabilityId and correlationId

```

```

repository: spinscale/light-java

repo_name: spinscale/light-java


text:
# python-memcached-stats

Python class to gather stats and slab keys from memcached via the memcached telnet interface

## Usage

Basic usage:

    from memcached_stats import MemcachedStats
    mem = MemcachedStats()

By default, it connects to localhost on port 11211. If you need to specify a host and/or port:

    mem = MemcachedStats('<IP_ADDRESS>', '11211')

Retrieve a dict containing the current stats from memcached:

    >>> mem.stats()
    {'accepting_conns': '1',
     'auth_cmds': '0',
     'auth_errors': '0',
     ... }

Retrieve a list of keys currently in use:

    >>> mem.keys()
    ['key-1',
     'key-2',
     'key-3',
     ... ]

## List the keys

If you just want to list some of the keys in memcached, run this from the command line:

    python -m memcached_stats <ip> <port>

ip defaults to <IP_ADDRESS> and port defaults to 11211.

## Installation

    pip install 'git+git://github.com/dlrust/python-memcached-stats.git'

## License

python-memcached-stats is released under the [MIT license](http://creativecommons.org/licenses/MIT/).

repository: ezubillaga/python-memcached-stats

gha_language: Python

repo_name: ezubillaga/python-memcached-stats


text:
#History
----

0.1.2 (2018/11/22)
------------------
* parse_line(String) is now public. (Thanks to Satoshi "Moris" Tagomori <https://github.com/tagomoris>)
* README improved. (thanks to sasaki takeru <https://github.com/takeru>)
* Unexpected ArgumentError of LTSV.dump with the argument that contains the instance of the specific type. (thanks to Ryo Nakamura <https://github.com/r7kamura>)

0.1.0 (2013/02/12)
------------------
* parse(String) method now accepts multi-line string and returns an Array of Hash. for single line String, use the new parse_line method.

(Thanks to Masato Ikeda)

0.0.3 (2013/02/11)
------------------
* Added the specs for load() method.
* Fixed the bug when handling empty keys or values.

(Thanks to Aki Ariga <https://github.com/chezou>)

0.0.2 (2013/02/08)
------------------
Fixed a bug with :parse method for handling an IO argument. (Thanks to Naoto SINGAKI <https://github.com/naoto/>)

----

0.0.1 (2013/02/07)
------------------
Initial Release.

repository: condor/ltsv

gha_language: Ruby

repo_name: condor/ltsv


text:
# Server documentation
>This project is in hard development, expect breaking changes.

Documentation related to the server that `ypack` client uses to retrieve package info. For more details, see the next sections:

* [Package specification](package-specification.md)
* [Rest API](rest-api.md)

repository: ypack/docs

repo_name: ypack/docs


text:
---
title: Jason's work showcased at the American Diabetes Association meeting
date: 2017-03-01
---

At the American Diabetes Association (ADA) meeting this June in San Diego, both of Jason’s studies "Growth Hormone Regulation of G0S2 and FSP27: Mechanism for Growth Hormone–Mediated Lipolysis" and "Characterizing the Wilms Tumor 1 (Wt1) Adipose Subpopulation" will be showcased in Moderated Poster Discussions. Good job, Jason!

gha_language: HTML


text:
---
layout: post
title: Swarm Inspections
categories: ['bees']
tags: []
---

Today was the final beginner's beekeeping class, and time to see how the 'swarm' Poly was getting along.As expected, there was a good number of bees working the hive - made up of all the flying bees from the original hive on the new site. However, they hadn't got much drawing done, so I decided to give them a feed to encourage drawing the new frames.

1 gallon of 1:1 syrup was added, although closer to 0.5 gallons reached the bees, after I had to change feeders over having discovered a leak in one! This should give them some extra energy to draw out the new foundation, and allow them to create space for brood laying and honey storage more quickly.

_Todo_

On Wednesday, return and refill or take off the feeder. DONE

On Friday 20th May check Wood for a laying queen and find and destroy her if she's still not laying, adding in eggs for a new queen. DONE

Tues/Wed 2nd/3rd June check Heather to see if she's laying. DONE

Varroa count in Heather and Wood.

path: /_posts/2009-05-23-Swarm Inspections.md

branch_name: refs/heads/gh-pages

filename: 2009-05-23-Swarm Inspections.md


text:
# TWRP A/B Keep Addon.d v2
Add addon.d v2 script to keep twrp after a OTA update on phones with a/b partition scheme

Instructions:
1. Normal ROM install (Lineage for example)
2. Install TWRP (both a/b partitions)
3. Reboot to TWRP again
4. Flash this module
5. After any OTA update applied TWRP will be reinstalled in post-restore phase.

*Tested on Moto X4 with lineage 15.1 Official

Thanks to erfanoabdi and osm0sis (twrp-keep)

repository: filipeferraz/twrp-keep-addond

repo_name: filipeferraz/twrp-keep-addond


text:
## Python Testing

For most tests in this directory, you will need to be logged in with
appropriate credentials to create projects.  To log in from the
command line, run `dx login`.

To run a particular test case, you can do so by running the `.py` file
containing it with the argument `TestClassName.test_function_name`.
For example, the following runs the test `test_dx_project_tagging` in
`test_dxclient.py`:

```bash
$ ./test_dxclient.py TestDXClient.test_dx_project_tagging
```

Note however that in this case, the test runs your currently-installed
version of `dx`, so if you have made local changes, you should rebuild
it before running the test.

### Environment Variables

By default, only a minimal set of tests are run.  To include more
tests, the following variables can be set:

Environment Variable | Tests included
---------------------|---------------
`DXTEST_FULL`        | Run tests in all categories below
`DXTEST_CREATE_APPS` | Run tests that create apps
`DXTEST_FUSE`        | Run tests against FUSE filesystems
`DXTEST_RUN_JOBS`    | Run tests that run jobs
`DXTEST_HTTP_PROXY`  | Run tests that use squid3 to launch an HTTP proxy
`DXTEST_ENV`         | Run tests which may clobber your local environment

repository: avisheksharma/dx-toolkit

repo_name: avisheksharma/dx-toolkit


text:
## Markodwn

Crudit support Markdown by providing

- Markdown editor Form Type (`Lle\CruditBundle\Form\Type\MarkdownType`).
- Markdown interpreter for display (`Lle\CruditBundle\Field\MarkdownField`).

### MarkdownType

#### Before

If it's not done yet, install [EasyMDE](https://github.com/Ionaru/easy-markdown-editor) package:

```
npm install easymde
```

then run

````
npm run watch
````

#### Usage

Usage in form builder:

````php
$builder->add('description', MarkdownType::class);
````

The rendering in the form will be:
![](img/markdown_editor.png)

### MarkdownField

#### Before

Make sure these packages are installed

```
composer require twig/markdown-extra twig/extra-bundle league/commonmark
```

#### Usage

Usage in CrudConfig:

````php
$description = Field::new('description')->setType(MarkdownField::class);
````

The rendering in the page will be:
![](img/markdown_interpretor.png)


text:
# Victory or Betrayal? [![Build Status][travis-image]][travis-url]

> React app that helps you recognize betrayal and victory.

Actually, this is just an application which helps me to try new bleeding edge technologies. This is something like _sandbox_.

## What is _victory and betrayal_?

**Victory and Betrayal** is an Ukrainian meme. Originally it sounds like _«зрада і перемога (zrada i peremoha)»_. Sometimes people also talk about _генотьба (genotba —
shame)_.

![Fry](https://cloud.githubusercontent.com/assets/3459374/14080189/11e2ee52-f50c-11e5-9753-b4e8fd1b65be.png)

Long story short: when something goes wrong — it's a **zrada (betrayal)**, when everything goes well — it's a **peremoha (victory)**. So if you don't understand what is going on, just type ask and you'll get an asnwer.

## What is under the hood?

* [x] [React](https://facebook.github.io/react/) — A JavaScript library for building user interfaces.
* [x] [Flux](https://facebook.github.io/flux/) — Application architecture for building user interfaces.
* [x] [React Router](https://github.com/reactjs/react-router) — A complete routing solution for React.js.
* [x] [Webpack](https://webpack.github.io/) — A module bundler.
* [x] [Babel](https://babeljs.io/) — The compiler for writing next generation JavaScript.
* [x] [PostCSS](http://postcss.org/) — A tool for transforming CSS with JavaScript.
* [x] [CSS Next](http://cssnext.io/) — a plugin that transforms new CSS specs into more compatible CSS.
* [x] [CSS Modules](https://github.com/css-modules/css-modules) — A way to scope CSS to a component and escape the global namespace.
* [x] [ESLint](http://eslint.org/) — The pluggable linting utility for JavaScript and JSX.
* [ ] Tests — I'll write tests. Seriously :smiley:

## Install

```
git clone https://github.com/denysovhan/victory-or-betrayal
cd victory-or-betrayal
npm install
```

## Tasks

After installation you will have these task:

* `npm start` — run `webpack-dev-server` in development mode.
* `npm run build` — build project into `build` directory.
* `npm run deploy` — build and deploy on [GitHub Pages](https://pages.github.com/).
* `npm run lint` — lint sources.

## License

MIT © [Denys Dovhan](http://denysdovhan.com)

<!-- References -->

[travis-url]: https://travis-ci.org/denysdovhan/victory-or-betrayal
[travis-image]: https://img.shields.io/travis/denysdovhan/victory-or-betrayal.svg?style=flat-square

repository: denysdovhan/victory-or-betrayal

repo_name: denysdovhan/victory-or-betrayal


text:
# Stable Diffusion for PyTorch with GPU migration

This directory provides scripts to perform text-to-image inference on a stable diffusion model and is tested and maintained by Habana.
The model has been enabled using an experimental feature called GPU migration.
*NOTE:* You can review the [Stable diffusion model](../../../../generative_models/stable-diffusion/README.md) enabled with a more traditional approach.

For more information on training and inference of deep learning models using Gaudi, refer to [developer.habana.ai](https://developer.habana.ai/resources/).
To obtain model performance data, refer to the [Habana Model Performance Data page](https://developer.habana.ai/resources/habana-training-models/#performance).

## Table of Contents

* [Model-References](../../../../../README.md)
* [Model Overview](#model-overview)
* [Setup](#setup)
* [Model Checkpoint](#model-checkpoint)
* [Inference and Examples](#inference-and-examples)
* [Supported Configuration](#supported-configuration)
* [Known Issues](#known-issues)
* [Changelog](#changelog)
* [Enabling the Model from Scratch](#enabling-the-model-from-scratch)
* [GPU Migration Logs](#gpu-migration-logs)

## Model Overview
This implementation is based on [High-Resolution Image Synthesis with Latent Diffusion Models](https://arxiv.org/abs/2112.10752).

Enabling model functionality is made easy by GPU migration.
While some performance optimizations are usually still required, GPU migration handles several steps required.

The following is a list of the different advantages of using GPU migration when compared to [the other model](../../../../generative_models/stable-diffusion/README.md):
* Modifying the default yaml config is not required.
* habana_compat.py helper file is not required.
* Re-checking the device type in multiple places is not required.
* Passing additional 'device' parameters to scripts and objects is not required.
* Adding a custom 'lazy_mode' parameter is not required.

For further details, refer to [Enabling the Model from Scratch](#enabling-the-model-from-scratch).

### How to use
Users acknowledge and understand that the models referenced by Habana are mere examples for models that can be run on Gaudi.
Users bear sole liability and responsibility to follow and comply with any third party licenses pertaining to such models,
and Habana Labs disclaims and will bear no any warranty or liability with respect to users' use or compliance with such third party licenses.

## Setup
Please follow the instructions provided in the [Gaudi Installation Guide](https://docs.habana.ai/en/latest/Installation_Guide/index.html) to set up the environment including the `$PYTHON` environment variable.
This guide will walk you through the process of setting up your system to run the model on Gaudi.

### Clone Habana Model-References
In the docker container, clone this repository and switch to the branch that matches your SynapseAI version.
You can run the [`hl-smi`](https://docs.habana.ai/en/latest/System_Management_Tools_Guide/System_Management_Tools.html#hl-smi-utility-options) utility to determine the SynapseAI version.
```bash
git clone -b [SynapseAI version] https://github.com/HabanaAI/Model-References
```

For convenience, export a MODEL_REFERENCES_PATH environment variable:
```bash
export MODEL_REFERENCES_PATH=/path/to/Model-References
```

### Install Model Requirements
1. In the docker container, go to the model directory:
```bash
cd $MODEL_REFERENCES_PATH/PyTorch/examples/gpu_migration/generative_models/stable-diffusion
```

2. Install the required packages using pip.
```bash
pip install -r requirements.txt
```

If you are getting errors, you might want to use the following command before trying to install the requirements again:
```bash
git config --global --add safe.directory `pwd`/src/taming-transformers && git config --global --add safe.directory `pwd`/src/clip
```

### Update PYTHONPATH
```bash
export PYTHONPATH=$MODEL_REFERENCES_PATH/PyTorch/examples/gpu_migration/generative_models/stable-diffusion/src/taming-transformers:$MODEL_REFERENCES_PATH/PyTorch/examples/gpu_migration/generative_models/stable-diffusion:$MODEL_REFERENCES_PATH/PyTorch/examples/gpu_migration/generative_models/stable-diffusion/src/clip:$PYTHONPATH
```

## Model Checkpoint
### Text-to-Image

1. Create a folder for checkpoint with the following command:
```bash
mkdir -p models/ldm/text2img-large/
```

2. Go to https://ommer-lab.com/files/latent-diffusion/nitro/txt2img-f8-large/, and save
`model.ckpt` file to `models/ldm/text2img-large/` folder to download the pre-trained weights (5.7GB)

Users acknowledge and understand that by downloading the checkpoint referenced herein they will be required to comply with
third party licenses and rights pertaining to the checkpoint, and users will be solely liable and responsible for complying
with any applicable licenses. Habana Labs disclaims any warranty or liability with respect to users' use
or compliance with such third party licenses.

## Inference and Examples
Consider the following command:
```bash
$PYTHON scripts/txt2img.py --prompt "a virus monster is playing guitar, oil on canvas" --ddim_eta 0.0 --n_samples 4 --n_iter 4 --scale 5.0  --ddim_steps 50
```

This saves each sample individually as well as a grid of size `n_iter` x `n_samples` at the specified output location (default: `outputs/txt2img-samples`).
Quality, sampling speed and diversity are best controlled via the `scale`, `ddim_steps` and `ddim_eta` arguments.
As a rule of thumb, higher values of `scale` produce better samples at the cost of a reduced output diversity.
Furthermore, increasing `ddim_steps` generally also gives higher quality samples, but the returns diminish for values > 250.
Fast sampling (i.e. low values of `ddim_steps`) while retaining good quality can be achieved by using `--ddim_eta 0.0`.

For a more detailed description of parameters, please use the following command to see a help message:
```bash
$PYTHON scripts/txt2img.py -h
```

### Performance
The first two batches of images generate a performance penalty, while all subsequent batches will be generated much faster.
For example, the command from the top of the [Inference and Examples](#inference-and-examples) section generates 4 batches of 4 images.
It will take more time to generate the first two sets of 4 images than the remaining 2.

### Higher Output Resolution
The model has been trained on 256x256 images and usually provides the most semantically meaningful outputs in this native resolution.
However, the output resolution can be controlled with `-H` and `-W` parameters.
For example, this command produces four 512x512 outputs:
```bash
$PYTHON scripts/txt2img.py --prompt "a virus monster is playing guitar, oil on canvas" --ddim_eta 0.0 --n_samples 4 --n_iter 1 --scale 5.0  --ddim_steps 50 --H 512 --W 512
```

### HPU Graph API
In some scenarios, especially when working with lower batch sizes, kernel execution on HPU might be faster than Op accumulation on CPU.
In such cases, the CPU becomes a bottleneck, and the benefits of using Gaudi accelerators are limited.
To combat this, Habana offers an HPU Graph API, which allows for one-time Ops accumulation in a graph structure that is being reused over time.

For further details on running inference with HPU Graphs, refer to [Run Inference Using HPU Graphs](https://docs.habana.ai/en/latest/PyTorch/Inference_on_Gaudi/Inference_using_HPU_Graphs/Inference_using_HPU_Graphs.html) section.

## Supported Configuration
| Device  | SynapseAI Version | PyTorch Version | Mode |
|---------|-------------------|-----------------|-----------|
| Gaudi   | 1.11.0             | 2.0.1          | Inference |
| Gaudi2  | 1.11.0             | 2.0.1          | Inference |

## Known Issues
* Initial random noise generation has been moved to CPU.
Arguably, CPU-generated random noise produces better images.

## Changelog
### 1.10.0
* Removed PT_HPU_ENABLE_REFINE_DYNAMIC_SHAPES environment variable.
### 1.9.0
Major changes done to the original model from [pesser/stable-diffusion](https://github.com/pesser/stable-diffusion/commit/a166aa7fbf578f41f855efeab2e14001d6732563) repository:
* Added `import huda` and `htcore.mark_step()` to scripts/txt2img.py
* Changed README.
* Changed default config and ckpt in scripts/txt2img.py.
* Removed pytorch-lightning and torchmetrics from requirements.txt.
* Added HPU Graph support.

## Enabling the Model from Scratch
Habana provides scripts ready-to-use on Gaudi.
Listed below are the steps to enable the model from a reference source.

This section outlines the overall procedure for enabling any given model with GPU migration feature.
However, model-specific modifications will be required to enable the functionality and improve performance.

1. Clone the original GitHub repository and reset it to the commit this example is based on:
```bash
git clone https://github.com/pesser/stable-diffusion.git && cd stable-diffusion && git reset --hard a166aa7fbf578f41f855efeab2e14001d6732563
```
2. Install the requirements:
```bash
pip install -r requirements.txt
```

3. Apply a set of patches.
You can stop at any patch to see which steps have been performed to reach a particular level of functionality and performance.

The first patch adds the bare minimum to run the model on HPU. For purely functional changes (without performance optimization), run the following command:
```bash
git apply Model-References/PyTorch/examples/gpu_migration/generative_models/stable-diffusion/patches/minimal_changes.diff
```

4. To improve performance, apply the patch which adds HPU graph support:
```bash
git apply Model-References/PyTorch/examples/gpu_migration/generative_models/stable-diffusion/patches/hpu_graph.diff
```

5. As described in the [Known Issues](#known-issues) section, it is recommended to move the initial random noise generation to the CPU.
To apply this, run the following command:
```bash
git apply Model-References/PyTorch/examples/gpu_migration/generative_models/stable-diffusion/patches/randn_to_cpu.diff
```

To generate a grid of 4x4 samples with any of these patches, run the following command:
```bash
$PYTHON scripts/txt2img.py --prompt "a virus monster is playing guitar, oil on canvas" --ddim_eta 0.0 --n_samples 16 --n_rows 4 --n_iter 1 --scale 5.0  --ddim_steps 50 --ckpt /path/to/model.ckpt --config configs/latent-diffusion/txt2img-1p4B-eval.yaml
```

*NOTE:* When compared with the command presented in the [Inference and Examples](#inference-and-examples) section, this command has additional `--ckpt` and `--config` parameters.
If you followed the steps outlined in the [Model Checkpoint](#model-checkpoint) section, your `/path/to/model.ckpt` should be `Model-References/PyTorch/examples/gpu_migration/generative_models/stable-diffusion/models/ldm/text2img-large/model.ckpt`.
The default values of both --ckpt and --config parameters have been changed in the model code introduced in this directory for your convenience.
This change, though not essential for running the model, is not incorporated in any of the given patches.

## GPU Migration Logs
You can review GPU Migration logs under [gpu_migration_logs/gpu_migration_1762.log](gpu_migration_logs/gpu_migration_1762.log).
For further information, refer to [GPU Migration Toolkit documentation](https://docs.habana.ai/en/latest/PyTorch/PyTorch_Model_Porting/GPU_Migration_Toolkit/GPU_Migration_Toolkit.html#enabling-logging-feature).

repository: HabanaAI/Model-References

repo_name: HabanaAI/Model-References


text:
# Adventure Works DW 2020 - DAX Sample Model - PBIX Sources

The Adventure Works DW 2020 Power BI Desktop sample model is distributed by Microsoft for learning and training purposes. The model is available as a (binary) PBIX file here: <https://github.com/microsoft/powerbi-desktop-samples/tree/main/DAX>. The data sources defined in the file are not publicly accessible. Instead, a user would need to restore a database backup to one of their own SQL servers and adjust the connection settings in the model.

This repo changes the distribution in two ways:

1. The PBIX sources are provided instead of the binary PBIX file
2. The underlying data tables have been extracted into CSV files and made available in a publicly accessible location. The model has been changed to fetch data from that location.

A fully functioning and refreshable PBIT file can be generated from sources in this repo alone using `pbi-tools` (currently in private preview).

- Conceptual documentation for the model: <https://aka.ms/dax-docs-samples>

## Generate PBIT file from sources

    pbi-tools compile-pbix -folder ./pbix -format PBIT -outPath AdvWorksDW2020.pbit

_Tested with `pbi-tools`, 1.0.0-beta.5 release._


text:
OpenWhiteBox AES
----------------

This repository aims to collect implementations of white-box AES constructions and their cryptanalyses. All
documentation is in godocs:
- constructions/
  - [bes/](https://godoc.org/github.com/OpenWhiteBox/AES/constructions/bes) An un-obfuscated, reference BES (Big Encryption System) implementation.
  - [chow/](https://godoc.org/github.com/OpenWhiteBox/AES/constructions/chow) Chow et al.'s white-box AES construction.
  - [full/](https://godoc.org/github.com/OpenWhiteBox/AES/constructions/full) Full construction from paper.
  - [saes/](https://godoc.org/github.com/OpenWhiteBox/AES/constructions/saes) An un-obfuscated, reference AES implementation.
  - [toy/](https://godoc.org/github.com/OpenWhiteBox/AES/constructions/toy) Toy construction from paper.
  - [xiao/](https://godoc.org/github.com/OpenWhiteBox/AES/constructions/xiao) Xiao and Lai's white-box AES construction.
- cryptanalysis/
  - [chow/](https://godoc.org/github.com/OpenWhiteBox/AES/cryptanalysis/chow) Cryptanalysis of Chow et al.'s construction.
  - [toy/](https://godoc.org/github.com/OpenWhiteBox/AES/cryptanalysis/toy) Cryptanalysis of toy construction.
  - [xiao/](https://godoc.org/github.com/OpenWhiteBox/AES/cryptanalysis/xiao) Cryptanalysis of Xiao and Lai's construction.

The "full" construction is the only white-box construction which does not have a corresponding cryptanalysis implemented
(though that doesn't mean it's secure). See example/ for code and instructions on how to use the "full" construction.

repository: ddddavidee/AES

gha_language: Go

repo_name: ddddavidee/AES


text:
# LCXDemoMenu

[![CI Status](https://img.shields.io/travis/475512103<EMAIL_ADDRESS>[![Version](https://img.shields.io/cocoapods/v/LCXDemoMenu.svg?style=flat)](https://cocoapods.org/pods/LCXDemoMenu)
[![License](https://img.shields.io/cocoapods/l/LCXDemoMenu.svg?style=flat)](https://cocoapods.org/pods/LCXDemoMenu)
[![Platform](https://img.shields.io/cocoapods/p/LCXDemoMenu.svg?style=flat)](https://cocoapods.org/pods/LCXDemoMenu)

## Funtion
A demo menu for development or learning

## Example

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

## Requirements

## Installation

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

```ruby
pod 'LCXDemoMenu'
```

## Author

<EMAIL_ADDRESS><EMAIL_ADDRESS>
## License

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

repository: xcodemanlcx/LCXDemoMenu

repo_name: xcodemanlcx/LCXDemoMenu


text:
# twiki
![twiki.png]
(https://raw.githubusercontent.com/WannabeSmith/deltahacks/master/res/twiki.png)
###Inspiration and Target Users

The idea behind twiki came to us when we were trying to create a product that had potential for positive change (aligning with the DeltaHacks theme). We wanted to make a service that allowed people to grab specific information about a topic of interest without internet access.

Originally, we were going to create an SMS-based medical information service for individuals around the world who do not have the ability to talk to a doctor or access to relevant medical information, but as we began implementing the relevant code, we decided to give the users the freedom to learn about anything that interests them without the need for internet.

With the millions of people on the planet who don't have the ability to learn, twiki provides this information in an easy and accessible way.

###Key Features

- **Twilio**: We set up an account on Twilio which allows us to have a phone number to and from which all Wikipedia queries can be sent and received.
- **Wikipedia**: We used the MediaWiki API for search queries.
- **Heroku**: Our application is hosted on a Heroku server with automated Maven builds.

###Contributors
Jay Elenis - University of Guelph, Engineering

Brian McCrindle - McMaster University, Engineering

Stefan Pleava - University of Waterloo, Engineering

Ian Waudby-Smith - University of Waterloo, Mathematics


text:
# MusicPlayerQt
A Music Player with limited support of LRC Lyrics.
This is just a Qt practice.

## Specs
using Qt 5.8 Beta with Qt Quick Control 2.0.

## Functions
Play single MP3 file and load LRC lyrics.

## Know Issues
Because QMediaPlayer uses DirectShow for playback, if the PC did not install proper codecs then the player will not work.

## Screenshot
![alt tag](https://raw.githubusercontent.com/xilwen/MusicPlayerQt/master/screenshot.jpg)

repository: xilwen/MusicPlayerQt

repo_name: xilwen/MusicPlayerQt


text:
# Cursorquery

<pre>
            ___
           /  /\
          /  /  \
         /  /    \
        /  /  /\  \
       /  /  /  \  \
      /  /  /    \  \
     /  /  /  /\  \  \
    /  /  /  /\ \  \  \
   /  /  /  /  \ \  \  \
  /  /  /__/____\ \  \  \
 /  /____________\ \  \  \
/___________________\  \  /
\_______________________\/
</pre>

Create cursored queries for raipidly changing data with Active Record.
Useful for APIs making requests where a feed is constantly updating.

## Installation

Add this line to your application's Gemfile:

    gem 'cursorquery'

And then execute:

    $ bundle

Or install it yourself as:

    $ gem install cursorquery

Then run migrations

    rake db:migrate

## Usage

Call the method cursor on any ActiveRecord query, passing in params.

    Post.all.cursor(params)

Initial query returns a default amount of records (which can be overriden with
the page_size param) and a unique identifier "etag". Pass etag back to
subsequent queries along with previous and/or latest params. It will return
new and/or older records based on the previous query, along with arrays of
updated and deleted records.

## Contributing

1. Fork it ( https://github.com/[my-github-username]/cursorquery/fork )
2. Create your feature branch (`git checkout -b my-new-feature`)
3. Commit your changes (`git commit -am 'Add some feature'`)
4. Push to the branch (`git push origin my-new-feature`)
5. Create a new Pull Request


text:
# Vault Configuration

Provides values to define kubernetes deployments and statefulsets to use a Hashicorp vault to inject secrets as part of an init container.

More information on Hashicorp Vault annoations can be found [here](https://www.vaultproject.io/docs/platform/k8s/injector/annotations).

The example found in the `global:` section is:

```yaml
  vault:
    enabled: false
    hashicorp:
      role: k8s-default
      log-level: info
      preserve-secret-case: true
      secret-volume-path: /run/secrets
      pre-populate-only: true
      # secretPrefix: path/to/secrets
      # secrets:
      # - name: secret-name
      #   secret: secret-name
```

Assuming the comments were uncommented out, secrtes from the Vault at `path/to/secrets/secret-name` would be placed in the container under `/run/secrets`

Translating to applicable kubernetes manifest sections:

```yaml
      annotations:
        vault.hashicorp.com/agent-inject: "true"
        vault.hashicorp.com/agent-inject-secret-secret-name.json: path/to/secrets/secret-name
        vault.hashicorp.com/agent-inject-template-secret-name.json: |
          {{ with secret "path/to/secrets/secret-name/secret-name" -}}
          {{ .Data.data | toJSONPretty }}
          {{- end }}
        vault.hashicorp.com/agent-pre-populate-only: "true"
        vault.hashicorp.com/log-level: info
        vault.hashicorp.com/preserve-secret-case: "true"
        vault.hashicorp.com/role: k8s-default
        vault.hashicorp.com/secret-volume-path: /run/secrets
```

repository: sergioatom/helm-charts

repo_name: sergioatom/helm-charts


text:
---
description: Change the style of graph edges
---

# Graph Edge Class

[Example code](https://github.com/mware-solutions/doc-examples/blob/master/extension-graph-edge-class)

Function that can change the [Cytoscape](http://js.cytoscape.org/) style  of edges. Useful for customizing the style of edges on the graph.

![](http://localhost/extension-points/front-end/graphEdge/class.png)

## Web Plugin

Register a plugin file to register the extensions.

```java
app.registerJavaScript("/com/mware/examples/graph_edge_class/plugin.js", true);
```

[GraphEdgeClassWebAppPlugin.java \(line 16\)](https://github.com/mware-solutions/doc-examples/blob/master/extension-graph-edge-class/src/main/java/com/mware/examples/graph_edge_class/GraphEdgeClassWebAppPlugin.java#L16)

## Register Extension

Register the class extension that checks if any of the edges \(they are by default bundled together by type\) has a comment. If any of them do, add a class.

```javascript
bc.registry.registerExtension('org.bigconnect.graph.edge.class', function(edges, type, classes) {
    var hasComment = _.any(edges, function(edge) {
        var comment = _.findWhere(edge.properties, { name: ONTOLOGY_CONSTANTS.PROP_COMMENT_ENTRY })
        return comment && comment.value.indexOf('class') >= 0;
    });

    if (hasComment) {
        classes.push('hasComment')
    }
});
```

[plugin.js \(lines 3–12\)](https://github.com/mware-solutions/doc-examples/blob/master/extension-graph-edge-class/src/main/resources/com/mware/examples/graph_edge_class/plugin.js#L3-L12)

Register a style extension to test.

```javascript

bc.registry.registerExtension('org.bigconnect.graph.style', function(cytoscapeStylesheet) {
     cytoscapeStylesheet.selector('edge.hasComment')
         .style({
             color: '#ff0000',
             'line-color': '#ff0000',
             'target-arrow-color': '#ff0000',
             width: 5
         })
});
```

[plugin.js \(lines 13–22\)](https://github.com/mware-solutions/doc-examples/blob/master/extension-graph-edge-class/src/main/resources/com/mware/examples/graph_edge_class/plugin.js#L13-L22)

repository: mware-solutions/bigconnect-docs

repo_name: mware-solutions/bigconnect-docs


text:
####> This option file is used in:
####>   podman build, container clone, create, run, update
####> If file is edited, make sure the changes
####> are applicable to all of those.
#### **--cpu-quota**=*limit*

Limit the CPU Completely Fair Scheduler (CFS) quota.

Limit the container's CPU usage. By default, containers run with the full
CPU resource. The limit is a number in microseconds. If a number is provided,
the container is allowed to use that much CPU time until the CPU period
ends (controllable via **--cpu-period**).

On some systems, changing the resource limits may not be allowed for non-root
users. For more details, see
https://github.com/containers/podman/blob/main/troubleshooting.md#26-running-containers-with-resource-limits-fails-with-a-permissions-error

This option is not supported on cgroups V1 rootless systems.

repository: containers/podman

repo_name: containers/podman


text:
---
title: 1 Year of Drum Roll
---
### E.A.K. Dev Diary 2
Drum Roll is a year old today. It's been a year since I quit my job and started building a game about rescuing cat gifs full time. Realising this makes me feel weird. The last 12 months have gone so fast and been so strange.

The last big update to the E.A.K. demo was released on the 26th of September, 2014. Since then, we've only released tiny tweaks and bug fixes. But on the 28th of September, 2015, we will be releasing the beta version of E.A.K.. This is terrifying. <!--more-->

In the last ~11 months, we've completely reworked almost all of E.A.K.. We learned a huge amount from the demo, applying that to the game has been incredibly difficult. Everything has taken about 3 times as long as we anticipated. Initially, we wanted to release a finished Chapter 1 in March, 2015. HAHAHA NO. Then, we wanted to release a slightly smaller Chapter one in June. We completely missed that too.

This September, we *have* to release *something*. It will be a beta of most of Chapter 1. It will be buggy. Bit's will be missing. But if we don't release it by the end of next month, I'm not sure we ever will.

I've got three big fears at the moment:

1. We don't get enough done in time
2. People see the update as a step in the wrong direction
3. No one gives us any money

1 is fairly self explanatory. We're not going to be releasing a finished product, but I don't want what we do release to be embarrassingly incomplete. The game needs to at least be playable.

2 is a trickier. It probably won't happen. We've done a fair bit of testing with the new way of doing things in E.A.K.. I really hope it doesn't happen.

3 has the biggest implications on the future of E.A.K.. For the first time ever, we're going to be asking E.A.K. fans to support us financially. For the past 6 months, we've been running on fumes. This is an opportunity to show potential investors that people will put their money where their mouth is when it comes to E.A.K..

If no one buys E.A.K., I'm not sure what we do. I guess smother E.A.K. in shitty ads and micro-transactions. I really want to avoid that, but that's where the gaming industry is at right now - especially on phones and tablets, which is where our young target audience is.

After this release, we want to put content out there far more frequently. No more year-long silences whilst we overhaul everthing about the game. We want small incremental updates released as soon as they're ready, and new batches of content every 6-8 weeks.

We'll see how it all works out...

repository: SomeHats/old-blag

repo_name: SomeHats/old-blag


text:
# Errors

<aside class="notice">This error section is stored in a separate file in `includes/_errors.md`. Slate allows you to optionally separate out your docs into many files...just save them to the `includes` folder and add them to the top of your `index.md`'s frontmatter. Files are included in the order listed.</aside>

The Kittn API uses the following error codes:

Error Code | Meaning
---------- | -------
NOT_FOUND | Bad Request -- What you are asking for doesn't exist... move along.
401 | Authorization error -- The API call has failed authentication.

repository: drwasho/slate

repo_name: drwasho/slate


text:
# # PresignedPostFields

## Properties

Name | Type | Description | Notes
------------ | ------------- | ------------- | -------------
**policy** | **string** | A base64-encoded policy detailing what constitutes an acceptable POST upload. Composed of the conditions and expiration provided to s3.createPresignedPost |
**x_amz_signature** | **string** | A hex-encoded HMAC of the POST policy, signed with the credentials provided to the S3 client. |

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

repository: WalletInc/sdk-php

repo_name: WalletInc/sdk-php


text:
# Finite Metal

Metal spots are reclaimable, extractors exist only to help route fabbers to spots.

This mod doesn't include changes to the commander, so you do have a base income to work with.

## Trivia

- It's possible to set feature reclaim value, it's just... odd.  You can get (metal_value/max_health)/10, plus some error based on the build power used.  In the typical case, a feature is either 25/25/10 or 25/10/10 for trees, basically 1 metal if you round up generously, and the fabber error dominates.
- Features must be damageable to be reclaimable.
- If a metal spot is reclaimed, the strategic icon stays, but you can't build on it anymore (very rarely a fabber will lucky when reclaiming-to-build)  Icons do disappear if the feature is destroyed.
- Reclaim rate is limited by build rate - if build speed is being attenuated by lack of metal, reclaim rates will also be reduced, exacerbating the problem.

## Development

The generated project includes a `package.json` that lists the dependencies, but you'll need to run `npm install` to download them.

PA will upload **all files** in the mod directory, including `node_modules` and maybe even `.git` - you probably don't want to use this in `server_mods` directly, unless you really like waiting.  The template is set up run to run as a project within a peer directory of `server_mods` - I use `server_mods_dev/mod_name`.  The task `grunt copy:mod` will copy the mod files to `../../server_mods/identifier`, you can change the `modPath` in the Gruntfile if you want to run it from somewhere else.

### Available Tasks

- copy:mod - copy the mod files into server_mods
- proc - Proc: copy the base files from PA, modify, and write into mod
- jsonlint - lint all the mod json files
- json_schema - partial validation of mod json files format using schema by exterminans https://forums.uberent.com/threads/wip-units-ammo-and-tools-json-validation-schema.60451/
- default: proc, json_schema, jsonlint, default


text:
#### Integrations

##### Akamai WAF
- Added the *Client token*, *Access token* and *Client secret* integration parameters to support credentials fetching object.
- Updated the Docker image to: *demisto/akamai:<IP_ADDRESS>965*.

repository: demisto/content

repo_name: demisto/content


text:
# Mother of all BCI Benchmark

![banner](images/M.png)

## Disclaimer

**This is work in progress. API will change significantly (as well as the results of the
benchmark).**

[![Build Status](https://travis-ci.org/NeuroTechX/moabb.svg?branch=master)](https://travis-ci.org/NeuroTechX/moabb)

## Welcome!

Thank you for visiting the Mother of all BCI Benchmark documentation and associated
[GitHub repository](https://github.com/NeuroTechX/moabb).

This document (the README file) is a hub to give you some information about the project.
Jump straight to one of the sections below, or just scroll down to find out more.

- [What are we doing? (And why?)](#what-are-we-doing)
- [Who are we?](#who-are-we)
- [What do we need?](#what-do-we-need)
- [How can you get involved?](#get-involved)
- [Get in touch](#contact-us)
- [Find out more](#find-out-more)
- [Installation](#install)
- [Running](#running)
- [Supported datasets](#datasets)
- [Documentation](#docs)
- [Architecture and main concepts](#architecture)

We also have a recent [paper][link_paper] in JNE.

## What are we doing?

### The problem

- Reproducible Research in BCI has a long way to go.
- While many BCI datasets are made freely available, researchers do not publish code, and
  reproducing results required to benchmark new algorithms turns out to be more tricky
  than it should be.
- Performances can be significantly impacted by parameters of the preprocessing steps,
  toolboxes used and implementation “tricks” that are almost never reported in the
  literature.

As a results, there is no comprehensive benchmark of BCI algorithm, and newcomers are
spending a tremendous amount of time browsing literature to find out what algorithm works
best and on which dataset.

### The solution

The Mother of all BCI Benchmark will:

- Build a comprehensive benchmark of popular BCI algorithms applied on an extensive list
  of freely available EEG datasets.
- The code will be made available on github, serving as a reference point for the future
  algorithmic developments.
- Algorithms can be ranked and promoted on a website, providing a clear picture of the
  different solutions available in the field.

This project will be successful when we read in an abstract “ … the proposed method
obtained a score of 89% on the MOABB (Mother of All BCI Benchmark), outperforming the
state of the art by 5% ...”.

## Who are we?

The founder of the Mother of all BCI Benchmark is [Alexander Barachant][link_alex_b]. He
is currently working with [Vinay Jayaram][link_vinay] to update and maintain the codebase.
This project is under the umbrella of [NeuroTechX][link_neurotechx], the international
community for NeuroTech enthusiasts.

## What do we need?

**You**! In whatever way you can help.

We need expertise in programming, user experience, software sustainability, documentation
and technical writing and project management.

We'd love your feedback along the way.

Our primary goal is to build a comprehensive benchmark of popular BCI algorithms applied
on an extensive list of freely available EEG datasets, and we're excited to support the
professional development of any and all of our contributors. If you're looking to learn to
code, try out working collaboratively, or translate you skills to the digital domain,
we're here to help.

## Get involved

If you think you can help in any of the areas listed above (and we bet you can) or in any
of the many areas that we haven't yet thought of (and here we're _sure_ you can) then
please check out our [contributors' guidelines](CONTRIBUTING.md) and our
[roadmap](ROADMAP.md).

Please note that it's very important to us that we maintain a positive and supportive
environment for everyone who wants to participate. When you join us we ask that you follow
our [code of conduct](CODE_OF_CONDUCT.md) in all interactions both on and offline.

## Contact us

If you want to report a problem or suggest an enhancement we'd love for you to
[open an issue](../../issues) at this github repository because then we can get right on
it. But you can also reach us on the [NeuroTechX slack #moabb
channel][link_neurotechx_signup] where we are happy to help!

## Find out more

You might be interested in:

- [MOABB documentaion][link_moabb_docs]

And of course, you'll want to know our:

- [Contributors' guidelines](CONTRIBUTING.md)
- [Roadmap](ROADMAP.md)

## Thank you

Thank you so much (Danke schön! Merci beaucoup!) for visiting the project and we do hope
that you'll join us on this amazing journey to build a comprehensive benchmark of popular
BCI algorithms applied on an extensive list of freely available EEG datasets.

##  Installation:

**Must by running Python 3.6**

To install, fork or clone the repository and go to the downloaded directory, then run

```
pip install -r requirements.txt
python setup.py develop    # because no stable release yet
```

### Requirements we use

mne numpy scipy scikit-learn matplotlib seaborn pandas pyriemann h5py

##  Running:

### Verify Installation

To ensure it is running correctly, you can also run

```
python -m unittest moabb.tests
```

once it is installed.

### Run the Moabb

```
python -m moabb.run --verbose
```

##  Documentation:

[http://moabb.neurotechx.com/docs/](http://moabb.neurotechx.com/docs/)

##  Supported datasets:

The list of supported dataset can be found here :
http://moabb.neurotechx.com/docs/datasets.html

### Submit a new dataset

you can submit new dataset by filling this
[form](https://docs.google.com/forms/d/e/1FAIpQLScxbpqK4omKsUs4tA2XpfeHJATo_SbYvT0hpxoeKDb5k_TZvQ/viewform).
The datasets currently on our radar can be seen
[here](https://docs.google.com/spreadsheets/d/1fQNFXGu1J1yJ9jFCer9EQQatjCPJWg7O-uCGF0Z4PiM/edit).

##  Architecture and main concepts:

![architecture](images/architecture.png)

There are 4 main concepts in the MOABB: the datasets, the paradigm, the evaluation, and
the pipelines. In addition, we offer statistical and visualization utilities to simplify
the workflow.

### Datasets

A dataset handle and abstract low level access to the data. the dataset will takes data
stored locally, in the format in which they have been downloaded, and will convert them
into a MNE raw object. There are options to pool all the different recording sessions per
subject or to evaluate them separately.

### Paradigm

A paradigm defines how the raw data will be converted to trials ready to be processed by a
decoding algorithm. This is a function of the paradigm used, i.e. in motor imagery one can
have two-class, multi-class, or continuous paradigms; similarly, different preprocessing
is necessary for ERP vs ERD paradigms.

### Evaluations

An evaluation defines how we go from trials per subject and session to a generalization
statistic (AUC score, f-score, accuracy, etc) -- it can be either within-recording-session
accuracy, across-session within-subject accuracy, across-subject accuracy, or other
transfer learning settings.

### Pipelines

Pipeline defines all steps required by an algorithm to obtain predictions. Pipelines are
typically a chain of sklearn compatible transformers and end with an sklearn compatible
estimator. See
[Pipelines](http://scikit-learn.org/stable/modules/generated/sklearn.pipeline.Pipeline.html)
for more info.

### Statistics and visualization

Once an evaluation has been run, the raw results are returned as a DataFrame. This can be
further processed via the following commands to generate some basic visualization and
statistical comparisons:

```
from moabb.analysis import analyze

results = evaluation.process(pipeline_dict)
analyze(results)
```

## Generate the documentation

To generate the documentation :

```
cd docs
make html
```

[link_alex_b]: http://alexandre.barachant.org/
[link_vinay]: https://ei.is.tuebingen.mpg.de/~vjayaram
[link_neurotechx]: http://neurotechx.com/
[link_neurotechx_signup]:
  https://docs.google.com/forms/d/e/1FAIpQLSfZyzhVdOLU8_oQ4NylHL8EFoKLIVmryGXA4u7HDsZpkTryvg/viewform
[link_moabb_docs]: http://moabb.neurotechx.com/docs/index.html
[link_arxiv]: https://arxiv.org/abs/1805.06427
[link_jne]: http://iopscience.iop.org/article/10.1088/1741-2552/aadea0/meta

repository: v-goncharenko/moabb

repo_name: v-goncharenko/moabb


text:
📦 Vue, Bootstrap 4, Vuex, Vue-Router, Sass/Scss, ESLint, Axios\
⌚ Last update: 8/20/2021

![logo](https://electrotallinn.ee/wp-content/uploads/2020/08/et-logo-invert.svg)

## Getting Started

Clone project and enter in folder:

```
cd vue-bootstrap-boilerplate
```

Run npm install:

```
npm i
```

Enjoy:

```
npm run serve
```

## Built With

- [Vue CLI](https://cli.vuejs.org/) - Standard Tooling for Vue.js Development
- [Vuex](https://vuex.vuejs.org/) - Vuex is a state management pattern + library for Vue.js applications.
- [Vue-Router](https://router.vuejs.org/) - Vue Router is the official router for Vue.js.
- [Bootstrap](https://getbootstrap.com/) - Build responsive, mobile-first projects on the web with the world’s most popular front-end component library.

## Versioning

We use [SemVer](http://semver.org/) for versioning.

## License

This project is licensed under the MIT License.

repository: neuromask/et-map-top

repo_name: neuromask/et-map-top


text:
# Lexicon

As ChemDataExtractor processes documents, it adds each unique word that it encounters to the `Lexicon` as a `Lexeme`.
Each `Lexeme` stores various word features, so they don't have to be re-calculated for every occurrence of that word.

You can access the Lexeme for a token using the `lex` property.

    >>> s = Sentence('Sulphur and Oxygen.')
    >>> s.tokens[0]
    Token('Sulphur', 0, 7)
    >>> s.tokens[0].lex.normalized
    'sulfur'
    >>> s.tokens[0].lex.is_hyphenated
    False
    >>> s.tokens[0].lex.cluster
    '11011101100110'


text:
# dockerkube
A Docker image that runs minikube inside.

This image runs minikube using the 'local' VM driver. That means all the
kubernetes processes run on the host's resources, but in a container.

In order to work properly, you need to run the image with a few parameters
so that kubernetes has access to everything it needs:

$ docker run --privileged -v /lib/modules:/lib/modules ecejjar/dockerkube

Once up, you can run helm and kubectl inside the container:

$ docker exec -it my-container kubectl get all -n kube-system

Since security hasn't been patched yet, you cannot access kubernetes from
outside the container for now.

repository: ecejjar/dockerkube

repo_name: ecejjar/dockerkube


text:
# vue-email-autocomplete
A configurable & lightweight Vue wrapper component that enables "out of the box" email autocomplete/suggestions on input elements.

![Autocomplete in Action](https://github.com/jameswylie/vue-email-autocomplete/blob/main/docs/images/vue-email-autocomplete.gif?raw=true)

✅ A wrapper component so you can use alongside other form enabled libraries (such as Buefy).\
✅ Customizable.\
✅ Allow users to easily navigate the suggestions list by simply using the "up/down" keys.\
✅ Users can also auto-fill the input with the desired value by hitting the "enter" key upon selection.

## Installation

```bash

# yarn
yarn add vue-email-autocomplete

# npm
npm install vue-email-autocomplete --save

```

## Basic Usage

```vue
<template>

  <email-auto-complete ref="EmailAutoComplete" :onCompletion='(val) => emailAddress = val'>
    <input type="text" v-model='emailAddress' @keydown.native='$refs.EmailAutoComplete.check($event)' />
  </email-auto-complete>

</template>

<script>

/* Import Package and Styles */

import EmailAutoComplete from "vue-email-autocomplete";
import "vue-email-autocomplete/dist/vue-email-autocomplete.css";

export default {

  /* Import Component */

  components: {
    EmailAutoComplete
  },

  /* Prime Model as Standard */

  data() {
    return {
      emailAddress: ''
    }
  }

}
</script>
```

## Configuration Example (Custom Domain Lists)

```vue
<template>

  /* A "domains" prop is added to the component and references the array of domains within the data property below */

  <email-auto-complete ref="EmailAutoComplete" :onCompletion='(val) => emailAddress = val' :domains='customDomains'>
    <input type="text" v-model='emailAddress' @keydown.native='$refs.EmailAutoComplete.check($event)' />
  </email-auto-complete>

</template>

<script>

/* Import Package and Styles */

import EmailAutoComplete from "vue-email-autocomplete";
import "vue-email-autocomplete/dist/vue-email-autocomplete.css";

export default {

  /* Import Component */

  components: {
    EmailAutoComplete
  },

  /* Prime Model as Standard */

  data() {
    return {
      emailAddress: '',
      customDomains: [

        "domain1.com",
        "domain2.com",
        "domain3.com",
        "domain4.com"

      ]
    }
  }

}
</script>
```

## Configuration Example (On Submit Callbacks)

```vue
<template>

  /* An "onSubmit" prop is added to the component and references a method below */

  <email-auto-complete ref="EmailAutoComplete" :onCompletion='(val) => emailAddress = val' :onSubmit='() => validateForm()'>
    <input type="text" v-model='emailAddress' @keydown.native='$refs.EmailAutoComplete.check($event)' />
  </email-auto-complete>

</template>

<script>

/* Import Package and Styles */

import EmailAutoComplete from "vue-email-autocomplete";
import "vue-email-autocomplete/dist/vue-email-autocomplete.css";

export default {

  /* Import Component */

  components: {
    EmailAutoComplete
  },

  /* Prime Model as Standard */

  data() {
    return {
      emailAddress: ''
    }
  }

  /* Methods */

  methods: {

    validateForm() {

      /* This is called when a user hits enter when focused on the wrapped input element */

    }

  }

}
</script>
```

## Configuration Example (Custom Inline Styles)

```vue
<template>

  /* A "css" prop is added to the component and references a computed property below */

  <email-auto-complete ref="EmailAutoComplete" :onCompletion='(val) => emailAddress = val' :css='styleOverrides'>
    <input type="text" v-model='emailAddress' @keydown.native='$refs.EmailAutoComplete.check($event)' />
  </email-auto-complete>

</template>

<script>

/* Import Package and Styles */

import EmailAutoComplete from "vue-email-autocomplete";
import "vue-email-autocomplete/dist/vue-email-autocomplete.css";

export default {

  /* Import Component */

  components: {
    EmailAutoComplete
  },

  /* Prime Model as Standard */

  data() {
    return {
      emailAddress: ''
    }
  }

  /* Computed Properties */

  computed: {

    styleOverrides() {

      return {

        /* Edit style for the suggestions "outer" container */

        container: {
          position: 'fixed',
          top: '40px',
          left: '40px'
        },

        /* Edit style for the suggestions overlay */

        overlay: {
          backgroundColor: #FFF
        },

        /* Edit style for the suggestions text */

        text: {

          /* Main text */

          suggestion: {
            color: purple
          },

          /* Highlighted/matched text */

          highlight: {
            color: blue
          }

        }

      }

    }

  }

}
</script>
```

## Configuration Example (CSS stylesheet overriddes)

```bash

Coming Soon!

```

# Props

        Prop
        Type
        Optional
        Default
        Description

        domains
        Array
        No
        A selection of the most statistically popular email domain extensions.
        A customized list of email domain extensions.

        onCompletion
        Function
        Yes
        N/A
        A function that you'd like the component to invoke after the user has selected a suggested completion (e.g. update the value/model of the input element).

        onSubmit
        Function
        No
        N/A
        A function that you'd like the component to invoke once the user hits the "enter" key when the nested input is in focus (e.g. carry out validations or submit the form).

        css
        Object
        No
        N/A
        CSS style overrides for specific elements of the suggestions component (See above examples).

# :racing_car: Roadmap

- Add extra CSS override mappings.
- Add ability to override CSS with a stylesheet (enables usage with media queries).
- Autocomplete default suggestions list to be based on browser language detection, which will make the suggestions more regionally relevant.
- Vue 3 refactoring/versioning.

# :beer: Buy me a Beer Cider

Donations are welcome and very much appreciated!

**ETH:** 0xb53dF77A7B18948f8f8FafF5DeF7bCc4E7Dbb30A\
**BTC (Native Segwit):** bc1qval55py30qt0jtrvuaa3zdfsft2weurnkn0kcj\
**BTC (Segwit):** 3BiTzQLcqwyCiMa8ydCu6dpdZzo8XgSzvU

# Contributions

If you'd like to contribute and add functionality to this project, feel free to fork this repo, create a new feature branch and then submit a pull request.

repository: jameswylie/vue-email-autocomplete

gha_language: Vue

repo_name: jameswylie/vue-email-autocomplete


text:
## Release 0.10.0

Notes:
- Due to the Scope UI now being able to start/stop/restart Docker
  containers, it is not wise to have it accessible to untrusted
  parties.

New features:
- Add lifecycle controls (start/stop/restart) for Docker containers
  [#598](https://github.com/weaveworks/scope/pull/598)
  [#642](https://github.com/weaveworks/scope/pull/642)
- Add sparklines to the UI for some metrics
  [#622](https://github.com/weaveworks/scope/pull/622)
- Show a message when the selected topology is empty
  [#505](https://github.com/weaveworks/scope/pull/505)

Bug fixes:
- Change node layout incrementally to reduce re-layouts
  [#593](https://github.com/weaveworks/scope/pull/593)
- Improve responsiveness of UI updates to container state changes
  [#628](https://github.com/weaveworks/scope/pull/628)
  [#640](https://github.com/weaveworks/scope/pull/640)
- Handle DNS Resolution to a set of names
  [#639](https://github.com/weaveworks/scope/pull/639)
- Correctly show node counts for sub-topologies
  [#621](https://github.com/weaveworks/scope/issues/621)
- Allow scope to start after being upgraded
  [#617](https://github.com/weaveworks/scope/pull/617)
- Prevent a stranded pseudo-nodes from appearing in the container view
  [#627](https://github.com/weaveworks/scope/pull/627)
  [#674](https://github.com/weaveworks/scope/pull/674)
- Parallelise and improve the testing infrastructure
  [#614](https://github.com/weaveworks/scope/pull/614)
  [#618](https://github.com/weaveworks/scope/pull/618)
  [#644](https://github.com/weaveworks/scope/pull/644)

## Release 0.9.0

New features:
- Add basic Kubernetes views for pods and services
  [#441](https://github.com/weaveworks/scope/pull/441)
- Support for Weave 1.2
  [#574](https://github.com/weaveworks/scope/pull/574)
- Add containers-by-hostname view
  [#545](https://github.com/weaveworks/scope/pull/545)
- Build using Go 1.5, with vendored dependencies
  [#584](https://github.com/weaveworks/scope/pull/584)
- Make `scope launch` work from remote hosts, with an appropriately defined DOCKER_HOST
  [#524](https://github.com/weaveworks/scope/pull/524)
- Increase DNS poll frequency such that Scope clusters more quickly
  [#524](https://github.com/weaveworks/scope/pull/524)
- Add `scope command` for printing the Docker commands used to run Scope
  [#553](https://github.com/weaveworks/scope/pull/553)
- Include some basic documentation on how to run Scope
  [#572](https://github.com/weaveworks/scope/pull/572)
- Warn if the user tries to run Scope on Docker versions <1.5.0
  [#557](https://github.com/weaveworks/scope/pull/557)
- Add support for loading the Scope UI from https endpoints
  [#572](https://github.com/weaveworks/scope/pull/572)
- Add support for probe sending reports to https endpoints
  [#575](https://github.com/weaveworks/scope/pull/575)

Bug fixes:
- Correctly track short-lived connections from the internet
  [#493](https://github.com/weaveworks/scope/pull/493)
- Fix a corner case where short-lived connections between containers are incorrectly attributed
  [#577](https://github.com/weaveworks/scope/pull/577)
- Ensure service credentials are sent when doing initial probe<->app handshake
  [#564](https://github.com/weaveworks/scope/pull/564)
- Sort reverse-DNS-resolved names to mitigate some UI fluttering
  [#562](https://github.com/weaveworks/scope/pull/562)
- Don't leak goroutines in the probe
  [#531](https://github.com/weaveworks/scope/issue/531)
- Rerun background conntrack processes if they fail
  [#581](https://github.com/weaveworks/scope/issue/581)
- Build and test using Go 1.5 and vendor all dependencies
  [#584](https://github.com/weaveworks/scope/pull/584)
- Fix "close on nil channel" error on shutdown
  [#599](https://github.com/weaveworks/scope/issues/599)

## Release 0.8.0

New features:
- Show message in the UI when topologies exceed size limits.
  [#474](https://github.com/weaveworks/scope/issues/474)
- Provide container image information in detail pane for containers.
  [#398](https://github.com/weaveworks/scope/issues/398)
- When filtering out system containers, also filter out pseudo nodes, if they were only connected to system containers.
  [#483](https://github.com/weaveworks/scope/issues/483)
- Show number of filtered nodes in status pane.
  [#509](https://github.com/weaveworks/scope/issues/509)

Bug fixes:
- Prevent detail pane from hiding nodes on click-to-focus.
  [#495](https://github.com/weaveworks/scope/issues/495)
- Stop radial view from bouncing in some circumstances.
  [#496](https://github.com/weaveworks/scope/issues/496)
- Make NAT tracking component more resilient to failure.
  [#506](https://github.com/weaveworks/scope/issues/506)
- Prevent duplicate reports from reaching the same app.
  [#463](https://github.com/weaveworks/scope/issues/463)
- Improve consistency of edge directionality in some use-cases.
  [#373](https://github.com/weaveworks/scope/issues/373)
- Ensure probe, app, and container shut down cleanly.
  [#424](https://github.com/weaveworks/scope/issues/424)
  [#478](https://github.com/weaveworks/scope/issues/478)

## Release 0.7.0

New features:
- Show short-lived connections in the containers view.
  [#356](https://github.com/weaveworks/scope/issues/356)
  [#447](https://github.com/weaveworks/scope/issues/447)
- Details pane:
  1. Add more information:
    - Docker labels.
      [#400](https://github.com/weaveworks/scope/pull/400)
    - Weave IPs/hostnames/MACs and Docker IPs.
      [#394](https://github.com/weaveworks/scope/pull/394)
      [#396](https://github.com/weaveworks/scope/pull/396)
    - Host/container context when ambiguous.
      [#387](https://github.com/weaveworks/scope/pull/387)
  2. Present it in a more intuitive way:
    - Show hostnames instead of IPs when possible.
      [#404](https://github.com/weaveworks/scope/pull/404)
      [#451](https://github.com/weaveworks/scope/pull/451)
    - Merge all the connection-related information into a single table.
      [#322](https://github.com/weaveworks/scope/issues/322)
    - Include relevant information in the table titles.
      [#387](https://github.com/weaveworks/scope/pull/387)
    - Stop including empty fields.
      [#370](https://github.com/weaveworks/scope/issues/370)
- Allow filtering out system containers (e.g. Weave and Scope containers) and
  unconnected containers. System containers are filtered out by default.
  [#420](https://github.com/weaveworks/scope/pull/420)
  [#337](https://github.com/weaveworks/scope/issues/337)
  [#454](https://github.com/weaveworks/scope/issues/454)
  [#457](https://github.com/weaveworks/scope/issues/457)
- Improve rendering by making edges' directions flow from client to server.
  [#355](https://github.com/weaveworks/scope/pull/355)
- Highlight selected node
  [#473](https://github.com/weaveworks/scope/pull/473)
- Animate Edges during UI transtions
  [#445](https://github.com/weaveworks/scope/pull/445)
- New status bar on the bottom left of the UI
  [#487](https://github.com/weaveworks/scope/pull/487)
- Show more information for pseudo nodes where possible - such as processes for uncontained, and connected to/from the internet.
  [#249](https://github.com/weaveworks/scope/issues/249)
  [#401](https://github.com/weaveworks/scope/pull/401)
  [#426](https://github.com/weaveworks/scope/pull/426)
- Truncate node names and text in the details pane.
  [#429](https://github.com/weaveworks/scope/pull/429)
  [#430](https://github.com/weaveworks/scope/pull/430)
- Amazon ECS: Stop displaying mangled container names, display the original Container Definition name instead.
  [#456](https://github.com/weaveworks/scope/pull/456)
- Annotate processes in containers with the container name, in the *Applications* view.
  [#331](https://github.com/weaveworks/scope/issues/331)
- Improve graph transitions between updates.
  [#379](https://github.com/weaveworks/scope/pull/379)
- Reduce CPU usage of Scope probes
  [#470](https://github.com/weaveworks/scope/pull/470)
  [#484](https://github.com/weaveworks/scope/pull/484)
- Make report propagation more reliable
  [#459](https://github.com/weaveworks/scope/pull/459)
- Support Weave 1.1 status interface
  [#389](https://github.com/weaveworks/scope/pull/389)

Bug fixes:
- *Trying to reconnect..* in UI even though its connected.
  [#392](https://github.com/weaveworks/scope/pull/392)
- The *Applications* view goes blank after a few seconds.
  [#442](https://github.com/weaveworks/scope/pull/442)
- Frequently getting disconnected lines in UI
  [#460](https://github.com/weaveworks/scope/issues/460)
- Panic due to closing request body
  [#480](https://github.com/weaveworks/scope/pull/480)

## Release 0.6.0

New features:
- Probes now push data to the app, instead of the app pulling it.
  [#342](https://github.com/weaveworks/scope/pull/342)
- Allow probe and app to be started independently, via --no-app and
  --no-probe flags.
  [#345](https://github.com/weaveworks/scope/pull/345)
- Close details pane when changing topology view.
  [#297](https://github.com/weaveworks/scope/issues/297)
- Add support for --probe.foo=bar style flags, in addition to
  --probe.foo bar, which is already supported.
  [#347](https://github.com/weaveworks/scope/pull/347)
- Added X-Scope-Probe-ID header to identify probes when sending
  information to the app.
  [#351](https://github.com/weaveworks/scope/pull/351)

Bug fixes:
- Update scope script to work with master version of weave, where DNS
  has been embedded in the router.
  [#321](https://github.com/weaveworks/scope/issues/321)
- Fixed regression where process names weren't appearing for Darwin
  probes.
  [#320](https://github.com/weaveworks/scope/pull/320)
- Fixed rendering bug resulting in orphaned nodes.
  [#339](https://github.com/weaveworks/scope/pull/339)
- App now only logs to stderr, to match the probe.
  [#343](https://github.com/weaveworks/scope/pull/343)
- Use relative paths for all URLs in the UI.
  [#344](https://github.com/weaveworks/scope/pull/344)
- Removed temporary containers created by the scope script.
  [#348](https://github.com/weaveworks/scope/issues/348)

Experimental features:
- Added support for pcap based packet sniffing, to provide bandwidth
  usage information. It can be enabled via the --capture flag. When
  enabled the probe will monitor packets for a portion of the time, and
  estimate bandwidth usage. Network throughput will be affected if
  capture is enabled.
  [#317](https://github.com/weaveworks/scope/pull/317)

## Release 0.5.0

New features:
- Aggregate all connection information into a single table in the details
  dialog.
  [#298](https://github.com/weaveworks/scope/pull/298)
- Renamed binaries to scope-app and scope-probe
  [#293](https://github.com/weaveworks/scope/pull/293)
- Group containers topology by name only, and not version
  [#291](https://github.com/weaveworks/scope/issues/291)
- Make intra-scope communication traverse the weave network if present.
  [#71](https://github.com/weaveworks/scope/issues/71)

Bug fixes:
- Reduced memory usage
  [#266](https://github.com/weaveworks/scope/issues/266)

## Release 0.4.0

New features:
- Include kernel version and uptime in host details.
  [#274](https://github.com/weaveworks/scope/pull/274)
- Include command line and number of threads in process details.
  [#272](https://github.com/weaveworks/scope/pull/272)
- Include Docker port mapping, entrypoint, memory usage and creation
  date in container details.
  [#262](https://github.com/weaveworks/scope/pull/262)
- Order tables in details panel from least granular to most granular.
  [#261](https://github.com/weaveworks/scope/issues/261)
- Show all container images (even ones without active connections)
  in the containers-by-image view.
  [#230](https://github.com/weaveworks/scope/issues/230)
- Produce process and container views by merging endpoint topology with their
  respective topologies, such that the origins in the details panel always
  aggregate correctly. [#228](https://github.com/weaveworks/scope/issues/228)
- In containers view, show "Uncontained" nodes for each host if they have
  active connections. [#127](https://github.com/weaveworks/scope/issues/127)
- Show connection status in the UI.
  [#162](https://github.com/weaveworks/scope/issues/162)

Bug fixes:
- Reduce CPU usage by caching walks of /proc.
  [#284](https://github.com/weaveworks/scope/issues/284)
- Trim whitespace of process names such that the details panel functions
  correctly in the process-by-name view.
  [#281](https://github.com/weaveworks/scope/issues/281)
- Correctly scope addresses on Docker bridge such that processes on different
  hosts are not incorrectly shown as communicating.
  [#264](https://github.com/weaveworks/scope/pull/264)
- Correctly show connections between nodes which traverse a Docker port
  mapping. [#245](https://github.com/weaveworks/scope/issues/245)
- Make scope script fail if docker run fails.
  [#214](https://github.com/weaveworks/scope/issues/214)
- Prevent left over nodes in the UI when the connection is dropped or Scope is
  restarted. [#162](https://github.com/weaveworks/scope/issues/162)

## Release 0.3.0

- Show containers, even when they aren't communicating.
- Expand topology selectors more descriptive, and remove the grouping button.
- Fix overflow rendering bugs in the detail pane.
- Render pseudonodes with less saturation.

## Release 0.2.0

- Initial release.

repository: defconcepts/scope

repo_name: defconcepts/scope


text:
Contributions are very welcome on this project. Issues should be raised for bugs
and feature requests. Pull requests should be targeted at the master branch and
will run against CI.

Note: The rules in the repo are generated by the code in [tools/rulegen](/tools/rulegen)
and the output rules should therefore not be edited directly. However, if you are
not comfortable editing this code, please submit a PR with just the output files
edited and we'll help update the generator to get the desired result.

Please see the [Developers](https://github.com/rules-proto-grpc/rules_proto_grpc#developers)
section of the project README for further details on how these rules are structured.


text:
# loot

Provides debugging abilities related to loot drop tables.

---
## loot

/tweaked loot [loottable]

/tweaked loot [loottable] [count]

Generates loot as though you had killed/opened the specified loottable and throws the items on the ground.

Specifying a count allows you to run the operation multiple times.

For a full list of loot tables take a look in the [glossary](/glossary/loottables/).

!!! note

    The loot will be generated as though killed/found by the player using the command, using the item in the players main hand.
	This means that you can use luck potions/looting weapons to simulate specific conditions.

!!! example

	```python
	#generates loot for a blacksmiths chest
	/tweaked loot chests/village_blacksmith

	#generates loot for 10 zombies
	/tweaked loot entities/zombie 10
	```

repository: MabinogiGaming/Tweaked-Documentation

repo_name: MabinogiGaming/Tweaked-Documentation


text:
# Jigsaw Multilingual Toxic Comment Classification - Planning

## Working cycle:
1. Read competition information and relevant content to feel comfortable with the problem. Create a hypothesis based on the problem.
2. Initial data exploration to feel comfortable with the problem and the data.
3. Build the first implementation (baseline).
4. Loop through [Analyze -> Approach(model) -> Implement -> Evaluate].

## 1. Literature review (read some kernels and relevant content related to the competition).
- ### Relevant content:
  - [The Illustrated Transformer](https://jalammar.github.io/illustrated-transformer/)
  - [The Illustrated BERT, ELMo, and co. (How NLP Cracked Transfer Learning)](https://jalammar.github.io/illustrated-bert/)
  - [HuggingFace Transformers](https://huggingface.co/transformers/)
  - [Hugging Face: State-of-the-Art Natural Language Processing in ten lines of TensorFlow 2.0](https://medium.com/tensorflow/using-tensorflow-2-for-state-of-the-art-natural-language-processing-102445cda54a)
  - [Simple BERT using TensorFlow 2.0](https://towardsdatascience.com/simple-bert-using-tensorflow-2-0-132cb19e9b22)
  - [TF Hub - bert_en_uncased_L-12_H-768_A-12](https://tfhub.dev/tensorflow/bert_en_uncased_L-12_H-768_A-12/1)
  - [Multilingual Universal Sentence Encoder for Semantic Retrieval](https://ai.googleblog.com/2019/07/multilingual-universal-sentence-encoder.html)
  - [BERT Word Embeddings Tutorial](https://mccormickml.com/2019/05/14/BERT-word-embeddings-tutorial/)
  - [A Visual Guide to Using BERT for the First Time](https://jalammar.github.io/a-visual-guide-to-using-bert-for-the-first-time/)
  - [Multi-Sample Dropout in Keras](https://towardsdatascience.com/multi-sample-dropout-in-keras-ea8b8a9bfd83)
  - [Jigsaw Toxicity Classification 1st place solution presentation](https://docs.google.com/presentation/d/1Km1C8jKpofoRRnWRMka-SGrfRNd8jlp6TuasqVKY91E/edit#slide=id.p)
  - [XLM — Enhancing BERT for Cross-lingual Language Model](https://towardsdatascience.com/xlm-enhancing-bert-for-cross-lingual-language-model-5aeed9e6f14b)

- ### GitHub:
  - [Huggingface transformers](https://github.com/huggingface/transformers)
  - [Hggingface tokenizers](https://github.com/huggingface/tokenizers/tree/master/bindings/python)

- ### Papers:
  - [How to Fine-Tune BERT for Text Classification?](https://arxiv.org/abs/1905.05583)
  - [Multi-Sample Dropout for Accelerated Training
and Better Generalization](https://arxiv.org/pdf/1905.09788.pdf)

- ### Videos:
  - [BERT for Kaggle Competitions | Yuanhae Wu | Kaggle Days](https://www.youtube.com/watch?v=jS79Y8I0DF4&t=9s)
  - [Deep Learning Formulas for NLP Applications | Chenglong Chen | Kaggle](https://www.youtube.com/watch?v=SmsAI0kLJFc&t=0s)
  - [Solving NLP Problems with BERT | Yuanhao Wu | Kaggle](https://www.youtube.com/watch?v=rQQAIJIf60s)
  - [BERT Research by Chris McCormick](https://www.youtube.com/watch?v=FKlPCK1uFrc&list=PLam9sigHPGwOBuH4_4fr-XvDbe5uneaf6)

- ### Kernels:
  - [Jigsaw TPU: DistilBERT with Huggingface and Keras](https://www.kaggle.com/xhlulu/jigsaw-tpu-distilbert-with-huggingface-and-keras)
  - [Jigsaw TPU: XLM-Roberta](https://www.kaggle.com/xhlulu/jigsaw-tpu-xlm-roberta/notebook)
  - [Understanding cross lingual models](https://www.kaggle.com/mobassir/understanding-cross-lingual-models/notebook)

- ### Discussions:
  - [Everything you always wanted to know about BERT (but were afraid to ask)](https://www.kaggle.com/c/google-quest-challenge/discussion/128420)
  - [BERT & Friends Reference](https://www.kaggle.com/c/tensorflow2-question-answering/discussion/126702)
  - [1ST PLACE SOLUTION - Jigsaw competition](https://www.kaggle.com/c/jigsaw-unintended-bias-in-toxicity-classification/discussion/103280#latest-619135)
  - [Let's Complicate Things [Bert]](https://www.kaggle.com/c/google-quest-challenge/discussion/123770)
  - [Past (Kaggle) Jigsaw Competitions & Top Solutions](https://www.kaggle.com/c/jigsaw-multilingual-toxic-comment-classification/discussion/138163)
  - [Insights on achieving 0.9383 without translating data](https://www.kaggle.com/c/jigsaw-multilingual-toxic-comment-classification/discussion/140254)
  - [Good Papers on Toxic Comment Classification](https://www.kaggle.com/c/jigsaw-multilingual-toxic-comment-classification/discussion/144097)
  - [Cheatsheet - Text Preprocessing](https://www.kaggle.com/c/tweet-sentiment-extraction/discussion/146888)

- ### Insights:
  - #### Positive Insights
    - Test set seems to have a 1:5 ratio between positive:negative samples
  - #### Negative Insights
    - Competition labels are heavily unbalanced
    - Train data has only english text
    - Validation data has only text on 3 languages while test has 6 languages


text:
# Preprocessors

Also [preprocessors](/torch_ecg/_preprocessors) acting on `numpy` `array`s.

## Basic Usage

`Preprocessor`s do the job of ECG signal preprocessing before fed into some neural network and are monitored by a manager. A short example is as follows

```python
import torch
from torch_ecg.cfg import CFG
from torch_ecg.preprocessors import PreprocManager

config = CFG(
    random=False,
    bandpass={"fs":500},
    normalize={"method": "min-max"},
)
ppm = PreprocManager.from_config(config)
sig = torch.randn(2, 12, 8000)
sig = ppm(sig)
```

For `Preprocessor`s that operate on the `numpy` `array`s, see the following example

```python
import torch
from torch_ecg.cfg import CFG
from torch_ecg._preprocessors import PreprocManager

config = CFG(
    random=False,
    resample={"fs": 500},
    bandpass={"filter_type": "fir"},
    normalize={"method": "min-max"},
)
ppm = PreprocManager.from_config(config)
sig = torch.randn(12, 80000).numpy()
sig, fs = ppm(sig, 200)
```

## Custom Preprocessors

One can create custom preprocessors to be maintained by the manager. The following is a simple example

```python
import torch
from torch_ecg.cfg import CFG
from torch_ecg.preprocessors import PreprocManager

class DummyPreProcessor(torch.nn.Module):
    """
    a dummy preprocessor that does nothing, similar to `torch.nn.Identity`
    """
    __name__ = "DummyPreProcessor"
    def forward(self, sig:torch.Tensor) -> torch.Tensor:
        """
        """
        return sig

config = CFG(
    random=False,
    bandpass={"fs":500},
    normalize={"method": "min-max"},
)
ppm = PreprocManager.from_config(config)

dp = DummyPreProcessor()
ppm.add_(dp, pos=1)

sig = torch.randn(2, 12, 8000)
sig = ppm(sig)
```

Here is another example for `numpy` version custom preprocessors

```python
from numbers import Real
from typing import Tuple

import numpy as np
import torch
from torch_ecg.cfg import CFG

from torch_ecg._preprocessors import PreprocManager, PreProcessor

class DummyPreProcessor(PreProcessor):
    """
    a dummy preprocessor that does nothing
    """
    __name__ = "DummyPreProcessor"
    def apply(self, sig:np.ndarray, fs:Real) -> Tuple[np.ndarray, int]:
        """
        """
        return sig, fs

config = CFG(
    random=False,
    resample={"fs": 500},
    bandpass={"filter_type": "fir"},
    normalize={"method": "min-max"},
)
ppm = PreprocManager.from_config(config)

dp = DummyPreProcessor()
ppm.add_(dp, pos=1)

sig = torch.randn(12, 80000).numpy()
sig, fs = ppm(sig, 200)
```

The following preprocessors are implemented

1. [baseline removal (detrend)](#baseline-removal)
2. [normalize (z-score, min-max, naïve)](#normalize)
3. [bandpass](#bandpass)
4. [resample](#resample)

## baseline removal

Also known as detrending, via median filter, which removes baseline drifts.

## normalize

Normalization methods including z-score normalization, min-max normalization, etc. are implemented. Refer to [wikipedia](https://en.wikipedia.org/wiki/Feature_scaling#Methods) for more details.

## bandpass

This procedure is performed using finite impulse response (FIR) filters, Butterworth filters, etc., which removes noises of frequencies outside the given pass band.

## resample

Resampling to a fixed sampling rate is done using the `interpolate` function from `torch.nn.functional` or using `resample_poly` function from `scipy.signal`.

## Issues