text:
# MLOps Recipes

__Goal__
To Create a library of modular recipes (parameterized devops pipeline templates) which could then be composed to create custom end to end CI/CD pipelines for Machine Learning

__Why care?__ To sustain business benefits of Machine learning across any organization, we need to bring in discipline, automation & best practices. Enter MLOps.

__Approach__
1. _Minimalistic_: Focus is on clean, understandable pipeline & code
2. _Modular_: Atomic recipes that could be referred and reused (e.g recipe: Deploy to production after approval)

__Status__: [Project board](https://github.com/rsethur/MLOps/projects/1)

__Technologies__: Azure Machine Learning & Azure Devops

__Technical Aspects__
1. Fully CI/CD YAML based multistage pipeline (does not use classic release pipelines in Azure devops)
2. Use YAML based variables template (no need to configure variable groups through UI)
2. Gated releases (manual approvals)
3. CLI based MLOps: use Azure ML CLI from Devops pipelines as a mechanism for interacting with the ML platform. Simple and clean.

__Get Started__
1. Understand what we are trying to do (below section)
2. [Setup the environment](docs/Setup.md)
3. [Run an end to end MLOps pipeline](docs/StartBaseScenario.md)

_Note: Automated builds based on code/asset changes have been disabled by setting `triggers: none` in the pipelines. The reason is to avoid triggering accidental builds during your learning phase._

__MLOps Flow__
![MLOps Flow](docs/imgs/MLOpsFlow.jpg)

__Notes on our Base scenario:__
1. Directory Structure
    1. `mlops` contains the devops pipelines
        1. `model_pipelines` contains individual pipelines for each of the models. These leverage the recipes
        2. `recipes`: contains parameterized, reusable devops pipeline for different scenarios
    2. `models` directory has the source code for the individual models (training, scoring etc)
    3. `setup` directory contains documentation on usage
2. Training: For training we use a simple LogisticRegression model on the German Credit card dataset. We build sklearn pipeline that does feature engineering. We export the whole pipeline as a the model binary (pkl file).
3. We use Azure ML CLI as a mechanism for interacting with Azure ML due to simplicity reasons.

__Acknowledgements__
1. _[MLOpsPython](https://github.com/microsoft/MLOpsPython/) python repo was one of the inspirations for this - thanks to the contributors_
2. _[German Creditcard Dataset](https://archive.ics.uci.edu/ml/datasets/Statlog+%28German+Credit+Data%29)_

`Dua, D. and Graff, C. (2019). UCI Machine Learning Repository [http://archive.ics.uci.edu/ml]. Irvine, CA: University of California, School of Information and Computer Science.`


text:
# basic_nat_wlp_ipv6

Features:

- Works out of the box on bridge or host network
- NAT (Network translation protocol)
- Has configuration wizard
- **WITHOUT** LAN protection (does not allow traffic to LANs connected to server), so you can still access devices in LAN (but **routed** example is recommended, because here traffic is still NAT-ed)

## Configure

``` bash
ovpn_enconf basic_nat
#Protocol udp, tcp, udp6, tcp6 [udp]:
#VPN network [<IP_ADDRESS>]:
#VPN IPv6 network with CIDR [2001:db8::/32]:
#Port [1194]:
#Public IP or domain of server: <PUBLIC IP>
#DNS1 [<IP_ADDRESS>]:
#DNS2 [<IP_ADDRESS>]:
```

license: MIT

repository: SloCompTech/docker-openvpn

branch_name: refs/heads/master

extension: md

gha_language: Shell

gha_license_id: MIT

license_type: permissive

repo_name: SloCompTech/docker-openvpn


text:
# Unifiedbeat

Unifiedbeat reads records from [Unified2](http://manual.snort.org/node44.html) binary files generated by network intrusion detection software and indexes the records in [Elasticsearch](https://www.elastic.co/).
Unified2 files are created by [IDS/IPS software](https://en.wikipedia.org/wiki/Intrusion_prevention_system)
such as [Snort](https://www.snort.org/) and [Suricata](http://suricata-ids.org/).

> #### More
>
> * [Protect the<EMAIL_ADDRESS>
> #### Note
>
> This version is no longer based on a clone of Filebeat, but follows the Beats development guide.

***

### February 18, 2016

#### Usage

1. build from source:
  * ```git clone https://github.com/cleesmith/unifiedbeat```
  * ```cd unifiedbeat```
  * ```go build```
    * if building for linux 64bit platform but on a mac do the following to cross-compile:
      * ```env GOOS=linux GOARCH=amd64 go build```
1. ```mkdir unifiedbeat```
1. ```cd unifiedbeat```
1. copy or scp the unifiedbeat binary file to the unifiedbeat folder
1. ```curl -XPUT 'http://localhost:9200/_template/unifiedbeat'<EMAIL_ADDRESS>1. ```rm .unifiedbeat``` if exists ... this file tracks the previous positions within the unified2 files being tailed and indexed
1. ```nano or vim etc/unifiedbeat.yml``` then change YAML configuration file:
  * sensor:
    * unified2_path: **?**  _# where are the unified2 files, typically: /var/log/snort/snort.log*_
    * unified2_prefix: "snort.log"
    * rules:
      * gen_msg_map_path: **?**  _# the absolute full path, typically: /etc/snort/gen-msg.map_
      * paths: **?**  _# where are the .rules files, typically: /etc/snort/rules/*.rules_
    * fields: _# add fixed/known details about this sensor_
  * .   .   .
  * output:
    * elasticsearch:
      * hosts: ["**?.?.?.?:9200**"]  _# elasticsearch's ip:port - most securely/typically on the same host as Snort_
1. ```cp etc/unifiedbeat.yml /etc/unifiedbeat.yml``` ... this is not required but typically done
1. **./unifiedbeat** -c /etc/unifiedbeat.yml
  * typically this command would be in a systemd, Upstart, or SysV (init.d) script
  * for a quick test use:
    * ```nohup ./unifiedbeat -c /etc/unifiedbeat.yml &```
    * ```ps aux | grep -i unifiedbeat``` ... remember it's pid, so you can kill it
    * use curl, sense, or kibana to look at the indices in elasticsearch
    * ```kill ?pid?``` ... when done testing
1. now, use Kibana or a custom app daily to see what's up with your host and network ... sleep better at night

***

### Kibana screenshots

![Dashboard](https://raw.githubusercontent.com/cleesmith/unifiedbeat/master/screenshots/kibana_dashboard.png "example Kibana dashboard")

> this is just a simple example of a Kibana dashboard and not very useful for security analysts

> see kibana/export.json to import the provided dashboard, search, and visualizations into Kibana

> new to Kibana? this YouTube [playlist](https://www.youtube.com/playlist?list=PLhLSfisesZIvA8ad1J2DSdLWnTPtzWSfI) is helpful

***

#### Event record as shown in Kibana's Discover

![Event](https://raw.githubusercontent.com/cleesmith/unifiedbeat/master/screenshots/kibana_event_record.png "Kibana Discover event record")

> notice the **signature** and **rule_raw** fields

***

#### Packet record as shown in Kibana's Discover

![Packet](https://raw.githubusercontent.com/cleesmith/unifiedbeat/master/screenshots/kibana_packet_record.png "Kibana Discover packet record")

> notice the human readable **packet_dump** field with all layers shown in both hex and text

***

### Sense screenshots

#### Event type document in ElasticSearch

![Event](https://raw.githubusercontent.com/cleesmith/unifiedbeat/master/screenshots/unifiedbeat_event.png "typical Event type document in ElasticSearch")

***

#### Packet type document in ElasticSearch

![Packet](https://raw.githubusercontent.com/cleesmith/unifiedbeat/master/screenshots/unifiedbeat_packet.png "typical Packet type document in ElasticSearch")

***
***

repository: ruflin/unifiedbeat

repo_name: ruflin/unifiedbeat


text:
# JWT-Client

React/Redux Jwt client

### Description
This is boilerplate app with some basic widely-used functionality.

## Run guide
### Pre install requirements
node v10.5.0 \
npm  v6.1.0  \

Setup and run JWT-Server app https://github.com/BagrijRoman/JWT-Server

* Clone project
```git clone <ssh or https link>```
* Install dependencies
```npm install```
* Run project
```npm run dev```

### Features
- Sign up
- Sign in
- Check Token while startup
- Check token while request
- Refreshing tokens

### Will be added
- i18n
- Restore password functionality
- Change password
- Profile page base

#### todo

- unify client server messages structure

- add request functionality (with access token check and refresh token usage)

- setup mail send service on server

- add restore password page and related functionnality

- add i18n
- add i18n config into database and load it on startup

- add run prod instruction
- add build instruction

repository: BagrijRoman/JWT-Client

gha_language: JavaScript

repo_name: BagrijRoman/JWT-Client


text:
---
layout: post
title: "Smart Product for Weight Loss"
description: "A smart product for weight loss through behavior change"
author: annebekker
tags: [BLE, behavior change, weight loss, habits, smartphone, master thesis]
---
{% include JB/setup %}

# A smart product for weight loss through behavior change

![Bitslab functions]({{ site.baseurl }}/attachments/bitslab_functions.png "BitsLab functionality")
{:.some-css-class style="width: 400px; float: right"}

Though an increased caloric intake is the most influential cause of the high and rising prevalence of overweight and obesity, there are no proper technical solutions yet that address this problem. Monitoring intake has shown to be an effective method for reducing intake. However, manual tracking tends to be inaccurate. Additionally, manual tracking requires too much mental effort for prolonged use.

## Design

Within her graduation project, [Anne Bekker]({{ site.baseurl }}/hall-of-fame/) has created a design that automatically monitors the user’s eating patterns. The design, called the BitsLab, facilitates behavior change by helping people analyze and improve their food intake patterns. By changing habits, it focuses on long-term changes. The design consists of an add-on for smartphones and an accompanying app. The add-on is a chewing sensor, located on the zygomatic process (a facial bone).

## Sensing technology

![Talking, Chewing]({{ site.baseurl }}/attachments/chewing.png "Talking, Chewing")
{:.some-css-class style="width: 400px; float: right; margin: 0px 0px 15px 20px;"}

The chewing sensor, a piezoelectric transducer, monitors chewing trough bone conducted audio. The following sample demonstrates a recording of speech followed by the chewing of a pepernoot.

[Audio data]({{ site.baseurl}}/attachments/chewing.mp3) is sent from the add-on to a smartphone app using Bluetooth LE, where it is analyzed by an algorithm. This measured data will provide users with an unbiased overview of their intake pattern.

## App

The app (which is not yet developed) helps users to find out what it is they are actually craving at moments their craving for undesired eating strikes, and to find a substitute behavior that satisfies the same craving. Consecutively, the BitsLab helps users discover what triggers their craving by sending them prompts at times unplanned eating occurs. When filled in, these prompts gather categorized data on potential triggers which can be analyzed by the app and the user.

![App Screen]({{ site.baseurl }}/attachments/bitslab_app_screen.png "App Screen")
{:.some-css-class style="width: 200px; float: left; margin: 0px 20px 0px 0px;"}

Once users have discovered what it is they are craving as well as what triggers this craving, they can start changing the habit. This consists of substituting the routine of unwanted eating by an alternative, healthy behaviour, which was found to satisfy the same craving.

![Loop]({{ site.baseurl }}/attachments/bitslab_loop.jpg "Habit-changing loop")
{:.some-css-class style="float: center;"}

In addition to changing habits, the app will teach users how to form new habits. By taking very small steps, and executing them consistently at a set point within their established routine, a habit will form without requiring much effort.

![Prototype]({{ site.baseurl }}/attachments/bitslab_prototype.jpg "Prototype")
{:.some-css-class style="width: 35%; float: right; margin: 0px 0px 0px 20px;"}

## Proof of concept prototype

The prototype is able to detect chewing. The algorithm for the chewing recognition is based on the extraction and comparison of features of a pre-recorded chew to an unknown incoming sound stream. The movie below shows the chewing algorithm app in action. When the green rectangle appears, chewing is recognized. When the app detects that the user has stopped eating, it will turn back to black.

## A small demonstration

{% video /attachments/bitslab_movie.mp4 %}

# Literature

You can read more in Anne's [master thesis (pdf)]({{ site.baseurl }}/attachments/thesis/annebekker.pdf).

repository: dobots/website

gha_language: HTML

repo_name: dobots/website


text:
---
title: Chocolate Donut Holes (Munchkins) Recipe On Food52.Com
slug: chocolate-donut-holes-munchkins-recipe-on-food52-com
thumbnail: 315573ed035e481aa2bbe1054a9b8524.jpg
image_url: https://cdn2.pepperplate.com/recipes/315573ed035e481aa2bbe1054a9b8524.jpg
source_name: Food 52
source_url: http://food52.com/recipes/32042-chocolate-donut-holes-munchkins
ingredients:
  - 2 tablespoons unsalted butter
  - 1 1/2 ounces unsweetened chocolate, chopped
  - 1 cup all-purpose flour
  - 1/4 cup plus
  - 2 tablespoons granulated sugar
  - 1/4 cup plus
  - 2 tablespoons Dutch-process cocoa powder
  - 3/4 teaspoon baking powder
  - 1/4 teaspoon baking soda
  - 1/2 teaspoon kosher salt
  - 1/4 cup buttermilk
  - 1 tablespoon pure vanilla extract
  - 1 large egg vegetable oil, for frying
  - 2 cups confectioners' sugar
  - 2 tablespoons milk
  - 2 teaspoons pure vanilla extract water, if necessary
---

* Prepare the dough: In a medium heatproof bowl, melt the butter and the chocolate together over a pot of barely simmering water. Remove from the heat and let cool slightly.
* In a large bowl, whisk together the flour, sugar, cocoa, baking powder, baking soda, and salt.
* Add the buttermilk and vanilla to the melted butter mixture and stir to combine. Stir in the egg. Add the wet ingredients to the dry ingredients and stir with a wooden spoon until the mixture is combined. Transfer the dough to a piece of plastic wrap, wrap it well, and let it rest for 30 minutes in the refrigerator.
* In a heavy pot with a candy thermometer attached, heat 3 inches of oil to 360° F. Meanwhile, scoop the dough into 1-tablespoon balls. (A mini ice-cream scoop is a great tool for this.) Roll each ball into a neat circle between the palms of your hands.
* Use a spider or a slotted spoon to gently lower the dough balls into the oil, 4 at a time.  Adjust the flame to maintain the temperature between 350° F and 360° F at all times. Cook the dough until puffed and cooked through, 2 to 3 minutes. (Color isn’t a good indicator of doneness, so feel free to open up the first or second doughnut to make sure it’s cooked through.) Use a slotted spoon to transfer the donuts to a paper towel-lined baking sheet. Repeat with the remaining dough.
* Prepare the glaze: In a small bowl, whisk together the confectioners’ sugar, milk, and vanilla until smooth. The glaze should be about the consistency of heavy cream. Add a little bit of water if necessary. Dip each donut into the glaze. Use a fork to cover each doughnut, then lift it out and tap it against the edge of the bowl to remove excess glaze. Transfer the glazed donuts to a rack set in rimmed baking sheet. Repeat with the remaining doughnuts. Let the donuts stand until the glaze is no longer wet.

repository: tcmacdonald/recipes

repo_name: tcmacdonald/recipes


text:
# Heroku deployment guide

*Note: you're currently viewing the Dota version. This version supports Dota 2 inhouses and its
configuration is a bit trickier because you need a Steam Bot. If you're looking for the standard
version, go
[here](https://github.com/MeLlamoPablo/schedulebot/tree/heroku#heroku-deployment-guide).*

*If you're looking for the local installation instructions, go
[here](https://github.com/MeLlamoPablo/schedulebot/tree/dota#schedulebot--dota-edition).*

If you wanted to host ScheduleBot locally, you'd need to have your computer on 24/7 to have your
bot always online. To avoid that, we could use a PaaS provider, such as
[Heroku](https://www.heroku.com/). Heroku's free plan is good enough for hosting our bot.

## Deployment instructions

To deploy ScheduleBot to Heroku, you will need:

* [NodeJS](https://nodejs.org/en/download/) 6 or above.
* [git](https://git-scm.com/downloads).

First, [sign up to Heroku](https://signup.heroku.com/), and create an app. You may deploy your
bot using the Heroku CLI, or GitHub. I recommend GitHub, as it's easier. If you choose Heroku
CLI, follow the instructions there. If you choose GitHub, first fork this repository. Then, clone
your fork and checkout the `heroku-dota` branch, and install the dependencies:

```sh
$ git clone https://github.com/<your_github_username>/schedulebot.git
$ cd schedulebot
$ git checkout heroku-dota
$ npm install
```

The `heroku-dota` branch is ready to be compatible with Heroku. The differences from `dota` are:

* The database settings are no longer stored in `config.js`, as they are provided by Heroku through
an environment variable.
* The `package.json` file is modified to tell Heroku to use Node 6.
* A `Procfile` with your bot's process is included.

Now edit the bot's settings in `config.js`. You can edit or leave whatever you want, but you should
at least edit:

* `master_channel` with the Discord channel where your bot will operate.
	* If you don't know how to get it, go to Discord's settings, then `Appearance`, then check
	`Developer Mode`. After that, right click on your channel, and click `Copy ID`.
* `default_timezone` with the time zone which will be used by the bot.

Next step is configuring your database. In your app's dashboard, go to `Resources`, and under
`Add-ons`, click `Find more add-ons`. Then search `Heroku Posgres` and add it to your app. The
free version is good enough for personal use.

After adding it, you'll find it under the `Add-ons` section. Click on it to your Heroku Postgres
dashboard, and then click on your newly created Datastore. Scroll down to `Database Credentials`,
 and click `View Credentials`. Now run the setup script entering those credentials:

```sh
$ npm run setup
```

After that, you need to configure your Steam credentials. You'll need to re-enter your Heroku
Postgres database credentials on the Steam setup script.

```sh
$ npm run setup-steam
```

Follow the script's instructions.   Then go to the following link in your browser:

```
https://discordapp.com/oauth2/authorize?client_id=YOUR_CLIENT_ID&scope=bot&permissions=0x00002000
```

Replace `YOUR_CLIENT_ID` by your bot's client ID. Don't forget to grant the "Manage Messages"
permission.

 Be sure to select the `heroku-dota` branch.

The first build should be triggered. When it's done, navigate to `Resources`, and, if everything
went right, you should see two Dynos: `web`, and `bot`. Shutdown `web`, as we don't need it, and
turn on `bot`. After that, your bot will be loaded. Go to the top right corner, under `More`,
then `View Logs` to see the console log. If you see the message
`[INFO] ScheduleBot finished loading.`, the bot is live. Congratulations!

# Usage guide

After deploying your bot, you might want to check out the
[usage guide](https://github.com/MeLlamoPablo/schedulebot/blob/dota/usage/usage-guide.md).

## Updating

Updating your bot is easy. First, you need to know which version you have installed. To do so, go
to Discord and run the command:

```
@ScheduleBot --help
```

*Note: replace `@ScheduleBot` with your app's prefix*. Take note of the current version.

After that, stop your bot. Then, replace your current files with the latest version files. If you
used `git` to clone the repository, this is easy:

```sh
$ git pull --all
```

If you forked this repo to deploy to Heroku, this will not work, because it's pulling from your repo, and not from this one. To solve that, first [configure this repo (MeLlamoPablo/schedulebot) as a remote for your fork (YOUR_GITHUB_USERNAME/schedulebot)](https://help.github.com/articles/configuring-a-remote-for-a-fork/). Then, [fetch this repo](https://help.github.com/articles/syncing-a-fork/) *(change `master` to `dota` or `heroku-dota`, depending on what branch you're working with)*.

However, after this your bot is not ready yet. A database update is also required:

```sh
$ npm run update
```

When prompted to select the current version, select the version you took note of. When prompted
to select the target version, you generally want to select the latest. After that, enter your
database credentials, and your database will also be updated to the selected version.

You're now ready to run your bot again.

repository: previsualconsent/peter-bot-

repo_name: previsualconsent/peter-bot-


text:
# autoscience-ui
A UI to interact with the autoscience API

## Installation (Ubuntu/Debian)

#### 1. Packages needed: npm and nodejs
```
sudo apt-get install npm

curl -sL https://deb.nodesource.com/setup_6.x | sudo -E bash -
sudo apt-get install -y nodejs
```

#### 2.1 Install some global npm packages
```
sudo npm install -g http-server
sudo npm install -g bower
```

#### 2.2 you need compass for grunt
sudo gem install compass

#### 3. Build and start the webserver
NPM takes a while to install the packages the first time.The package are installed locally on the node_modules directory. As a post-install action, npm will also run `bower install` and run unit and e2e test before starting the npm http-server. For more information about the pre- and post npm install and start steps, check `package.json`.

```
npm install
npm start
```
#### 4. Check where your server has started.
Go to your fav browser and type http://localhost:8000
If you wish to configure the server on a different port check the `http-server` configuration in `package.json`.

Enjoy it :-)

repository: natbusa/autoscience

repo_name: natbusa/autoscience


text:
Project Fluent [![Build Status][travisimage]][travislink]
=========================================================

[travisimage]: https://travis-ci.org/projectfluent/python-fluent.svg?branch=master
[travislink]: https://travis-ci.org/projectfluent/python-fluent

This is a Python implementation of Project Fluent, a localization framework
designed to unleash the entire expressive power of natural language
translations.

Project Fluent keeps simple things simple and makes complex things possible.
The syntax used for describing translations is easy to read and understand.  At
the same time it allows, when necessary, to represent complex concepts from
natural languages like gender, plurals, conjugations, and others.

Learn the FTL syntax
--------------------

FTL is a localization file format used for describing translation resources.
FTL stands for _Fluent Translation List_.

FTL is designed to be simple to read, but at the same time allows to represent
complex concepts from natural languages like gender, plurals, conjugations, and
others.

    hello-user = Hello, { $username }!

[Read the Fluent Syntax Guide][] in order to learn more about the syntax.  If
you're a tool author you may be interested in the formal [EBNF grammar][].

[Read the Fluent Syntax Guide]: http://projectfluent.org/fluent/guide/
[EBNF grammar]: https://github.com/projectfluent/fluent/tree/master/spec

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

python-fluent consists of two packages:

* `fluent.syntax` - includes AST classes and parser. Most end users will not
  need this directly. Documentation coming soon!

  To install:

        pip install fluent.syntax

* `fluent.runtime` - methods for generating translations from FTL files.

  To install:

        pip install fluent.runtime

  (The correct version of ``fluent.syntax`` will be installed automatically)

PyPI also contains an old `fluent` package which is an older version of just
`fluent.syntax`.

Usage
-----

For fluent.runtime, see the [docs folder](fluent.runtime/docs) or [read them on
readthedocs.org](https://fluent-runtime.readthedocs.io/en/latest/).

Discuss
-------

We'd love to hear your thoughts on Project Fluent!  Whether you're a localizer
looking for a better way to express yourself in your language, or a developer
trying to make your app localizable and multilingual, or a hacker looking for
a project to contribute to, please do get in touch on the mailing list and the
IRC channel.

 - mailing list: https://lists.mozilla.org/listinfo/tools-l10n
 - IRC channel: [irc://irc.mozilla.org/l20n](irc://irc.mozilla.org/l20n)

Get Involved
------------

python-fluent is open-source, licensed under the Apache License, Version 2.0.
We encourage everyone to take a look at our code and we'll listen to your
feedback.

repository: vsajip/python-fluent

repo_name: vsajip/python-fluent


text:
# Track Suggester

### By Gee (Jiwon) Kang

## Description

#### A survey suggesting user which programming language course track,  offered by Epicodus, he or she should take based on their interests.

#### The survey requires user's full name to submit the form.

#### If the user submits without putting in his/her name, the form is not going to be submitted but instead gives the user a message to enter his/her full name.

#### When submitted, a thank-you alert pops up then displays a thank-you message, with user's name, and information about selections he or she made but not what is entered in the comment box, at the very bottom of the index.html page.

## Setup

* Open Terminal on Desktop
* Configure as a solo user including user name and user email
* On Desktop create a main directory
* Inside main directory create index.html page, and css, js, and img folders, then create files inside folders
* First, create a html page
* Second, create a js page including functions
* Then, style the html page in css
* Open index.html with a web browser
* Run the program by clicking the submit button on index.html page

### Link: [Click here](https://jiwonk42.github.io/track-suggester/)

#### Copyright (c) 2017 Gee (Jiwon) Kang.
#### This software is licensed under the MIT license.


text:
# frontend-functions

This presentation is for the [5th Functional Programming Users Group Meetup](https://www.meetup.com/scala-manila/events/234894294/) where I talk about ReactJS as components and how it parallels functions.

# Viewing the presentation

This uses [Spectacle](https://github.com/FormidableLabs/spectacle/blob/master/README.markdown) which is a React presentation framework, it is a nice framework so you can have React components inline with your presentation. I still prefer (org-reveal)[https://github.com/yjwen/org-reveal/] for it's simplicity and focus for code and text, but a react presentation needs a react presentation library.

Just run `npm install` to build it, `npm start` to start the presentation and then find it at `http://localhost:33000`.

repository: FrancisMurillo/frontend-functions

extension: markdown

repo_name: FrancisMurillo/frontend-functions


text:
# Replicate Old Snapshots using PowerShell

Warning: this code is provided on a best effort basis and is not in any way officially supported or sanctioned by Cohesity. The code is intentionally kept simple to retain value as example code. The code in this repository is provided as-is and the author accepts no liability for damages resulting from its use.

This powershell script replicates existing local snapshots to a replication target. This is useful if you have recently created an replication target and want to programatically replicate existing local snapshots.

## Download the script

Run these commands from PowerShell to download the script(s) into your current directory

```powershell
# Download Commands
$scriptName = 'replicateOldSnapshots'
$repoURL = 'https://raw.githubusercontent.com/bseltz-cohesity/scripts/master/powershell'
(Invoke-WebRequest -Uri "$repoUrl/$scriptName/$scriptName.ps1").content | Out-File "$scriptName.ps1"; (Get-Content "$scriptName.ps1") | Set-Content "$scriptName.ps1"
(Invoke-WebRequest -Uri "$repoUrl/cohesity-api/cohesity-api.ps1").content | Out-File cohesity-api.ps1; (Get-Content cohesity-api.ps1) | Set-Content cohesity-api.ps1
# End Download Commands
```

## Components

* replicateOldSnapshots.ps1: the main powershell script
* cohesity-api.ps1: the Cohesity REST API helper module

Place both files in a folder together, then we can run the script.

First, run the script WITHOUT the -replicate switch to see what would be replicated.

```powershell
./replicateOldSnapshots.ps1 -vip mycluster -username admin -replicateTo CohesityVE -olderThan 1 -IfExpiringAfter 3
```

```text
Connected!
searching for old snapshots...
05/19/2019 23:20:00  VM Backup  (expiring in 3 days. skipping...)
05/20/2019 05:34:46  VM Backup  (expiring in 3 days. skipping...)
05/20/2019 23:20:00  VM Backup  (would replicate for 4 days)
05/19/2019 23:40:01  Infrastructure  (expiring in 3 days. skipping...)
05/20/2019 23:40:01  Infrastructure  (would replicate for 4 days)
05/20/2019 00:00:01  Oracle Adapter  (expiring in 3 days. skipping...)
05/21/2019 00:00:01  Oracle Adapter  (would replicate for 4 days)
05/20/2019 00:20:00  SQL Backup  (expiring in 3 days. skipping...)
05/21/2019 00:20:01  SQL Backup  (would replicate for 4 days)
```

Then, if you're happy with the list of snapshots that will be replicated, run the script again and include the -replicate switch. This will execute the replication tasks

```powershell
./replicateOldSnapshots.ps1 -vip mycluster -username admin -replicateTo CohesityVE -olderThan 1 -IfExpiringAfter 3 -replicate
```

## Parameters

* -vip: Cohesity cluster to connect to
* -username: Cohesity username
* -domain: AD domain name (defaults to local)
* -jobName: (optional) replicate only specified job (otherwise replicate all jobs)
* -replicateTo: name of remote cluster to replicate to
* -keepFor: days to keep replica (default is same as local) existing age is subtracted
* -olderThan: (optional) only replicate if older than X days
* -newerThan: (optional) only replicate if newer than X days
* -IfExpiringAfter: (optional) only replicate if there are X or more days left before expiration
* -replicate: actually replicate (otherwise only a test run)
* -resync: re-replicate to same target

repository: geoffaskam/scripts

repo_name: geoffaskam/scripts


text:
## About

This is the implementation of Conway's Game of Life from the [Rust 🦀 and WebAssembly 🕸 book](https://rustwasm.github.io/docs/book/introduction.html) with a few changes.

### 🛠 Build with `wasm-pack build`

```
wasm-pack build
```

### Run the app

```
cd www
npm i
npm run start
```

repository: mvtenorio/wasm-game-of-life

branch_name: refs/heads/main

repo_name: mvtenorio/wasm-game-of-life


text:
# scqe <IP_ADDRESS>01

* Resolved error created when `min_delta` and `max_delta` were specified, but `delta` was not specified.

* Modularized function call checks.

* Added a `NEWS.md` file to track changes to the package.

* Used formatR to format functions.R

* Minor spelling corrections

repository: jbdatascience/scqe

repo_name: jbdatascience/scqe


text:
---
layout: post
title: "Monitorama 2018 AMS Day 2"
date: 2018-09-07 13:03
comments: true
categories: conferences monitoring
---

## Prometheus for Practitioners: Migrating to Prometheus at Fastly - Marcus Barczak, Fastly

First monitoring system: Ganglia + Icinga. Tried to move to SaaS, ended up supporting two systems, growing pains doubled.

Company infrastructure was scaling horizontally, require scaling monitoring vertically.

Project to review monitoring and replace existing systems: scale with infrastructure growth, easy to deploy and operate, engineer friendly instrumentation, first class API support.

Get started:

- build proof of concept
- pair with pilot team to instrument their services
- iterate through the rest

Infrastructure:

- Pair of instances in each POP, both scraping same devices in the POP.
- Frontend in GCP. Grafana, nginx router, federation and alert manager.

Prometheus server:

- ghost tunnel, tls termination and auth
- service discovery sidecar
- rules loader

Created their own service discovery and proxy for prometheus.

Rough Edges:

- Metrics exploration without prior knowledge
- Alertmanager too flexible
- Federation and global views
- Long term storage still an open question

## Rethinking UX for AI-driven Monitoring Tools - Stephen Boak, Datadog

This was a really great talk and my notes could never do it justice.

https://bit.ly/2MNDlZ9

## Building a monitoring strategy and gaining consensus - Gregory Parker, Trevor Morgan, Standard Chartered Bank

No monitoring strategy for company

Back to Basics: What do your users want? Where is their pain points. Put the building blocks in place. Forget what you have and focus on what you need.

- Talk to business and tech influencers
- Listen to fedback and understand contraints
- Publish clear and detailed first principles based strategy
- Get feedback from stakeholders, revise early and often

Get teams to plug in. Avoid mandates, generate awareness, encourage modern solutions, enlist champions.

Build a data lake with common event structure

What went well:

- Engaged with customers throughout
- Inclusive approach, extensible data model
- Roadshows, Show and Tell, Awareness sessions

What could be changed:

- Spend more time gaining consensus early stage
- Work out how to pay for it
- Focus less on legacy technologies

## Self-hosted & open-source time series analysis for your infrastructure - Alexey Velikiy

Analytic unit - shuld be isolated and customisable

Hastic - python app for processing ts data & plugin for grafana with ui for labelling and rendering preductions

Label patterns in grafana, and then it will generate detections. Pattern is a "shape" - peaks, jumps, troughs etc.

Custom models in python.

https://github.com/hastic/hastic-server

## Monitoring Serverless Things - Mandy Waite, Google

Functions as a Service

By definition, the servers are not accessible. More pieces of monitor and operate.

Retrying function executions is the simplest way to handle failures with serverless functions. Making a function idempotent is required to make it behave correctly on retried execution attempts.

Two distinct variants of functions - http functions, at most once. background functions, at least once.

## How AI Helps Observe Decentralised Systems - Dominic Wellington, Moogsoft

We are living in a different world from the one our systems and processes were designed for

Old world: Static environment, managable alert volumes.
New world: fast growing, fast changing environment, massive alert volumes.

What happens on network edge is now more important, and the edge is far away.

Single faults no longer cause impacts: fault tolerance does not mean zero incidents.

So how do we fix monitoring?

Existing monitoring is incident driven. Assumption that faults are easy to detect, and all failure conditions are knowable.

Dashboards are artefacts of a past failure. Internal health is irrelevant, user requests are what they care about. (Symptom based monitoring)

Observability: continuous stream, high cardinality, build into infra and apps, insight driven. "Actionable Understanding"

Monitoring as it should be: everything passes over a message bus. Then add AI.

AI in IT ops: bring interesting information to the attention of human operators - without having to define it beforehand.

Where to use AI in IT ops:

- Ingestion: reduce noise and false alarms.
- Correlation: identify related events across domains, avoid duplication of effort and missed signals.
- Collaboration: intelligent teaming, root cause analysis, knowledge capture.

Teaching the machine. Inputs matter, choose the right feature vectors. Regression problems: continuous distribution. Classification vs clustering: set of dategories.

In Practise:

- Speed matters, work in real time
- You don't know what you need to know
- AI is a tool, not magic
- Process is how you make sure it works for users

## Incremental-decremental Methods For Real-Time Monitoring - Joe Ross, SignalFx

Statistically grounded approaches: dynamic environments, complexity, volume.

Demands streaming algorithms for time series.

Simple calculation: 3 sigma. Implementation: rolling windows. Framework: prime and stream.

Rolling windows are natural foundation for streaming algorithms.

Comparing distributons is not enough. Metods for modeling: double exponention smoothing, and detecting non-stationary series.

Forecasting:

level change: current window differs from forecast. mean is a poor forecast.

exponential weighted moving average: more recent data more relevant.

double exponential smoothing: models two quantities - level of the series and trend of the series.

incremental decremental solution. how to remove influence of oldest values in sliding window. store additional state: track influence of the initial terms on the terminal values.

Time series classification:

A time series is stationary if it's ditribution does not change over time.
level stationary statistic: tests that a series is stationary around its mean

incremental decremental rolling window implementation: algebraic machinations

repository: johanek/old-blog

repo_name: johanek/old-blog


text:
# FixedSizeArrays

[![Join the chat at https://gitter.im/SimonDanisch/FixedSizeArrays.jl](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/SimonDanisch/FixedSizeArrays.jl?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)

[![Build Status](https://travis-ci.org/SimonDanisch/FixedSizeArrays.jl.svg?branch=master)](https://travis-ci.org/SimonDanisch/FixedSizeArrays.jl)
[![Coverage Status](https://coveralls.io/repos/SimonDanisch/FixedSizeArrays.jl/badge.svg?branch=master)](https://coveralls.io/r/SimonDanisch/FixedSizeArrays.jl?branch=master)

#### This package is 0.4 only
#### Packages that use FixedSizeArrays:
[GeometryTypes.jl](https://github.com/JuliaGeometry/GeometryTypes.jl)
[ColorTypes.jl](https://github.com/SimonDanisch/ColorTypes.jl)

#### Usage and advantages:
FixedSizeArrays is giving any composite type array like behavior by inheriting from FixedSizeArrays.
So you can do something like this:
```Julia
immutable Vec3{T} <: FixedSizeVector{T, 3}
r::T
g::T
b::T
end
Vec3(0) # constructor with 1 argument already defined. Actually, this only works if you created them
#  with @gen_fixed_size_vector, due to ambiguity issues :(
rand(Vec3{Int})+sin(Vec3(0,2,2)) # a lot of array functions are already defined
immutable Mat3x3{T} FixedMatrix{T, 3,3}
v_1::T
...
v_9::T
end
eye(Mat3x3{Float32}) * rand(Vec3{Float32}) # will also "just work"
```
This is expendable to a lot of other areas.
You can define color types (see ColorTypes.jl) the same way, and arbitrary other point types like normals, vertices etc.
As they all inherit from FixedSizeArray, it's very easy to handle them in the same way.
I'm using this for my GPU array types, which can take any fixedsizearray, if its a color, a point or what not, because I can be sure that all the important functions are defined and the GPU can handle them.
If we are able to to compile Julia directly to OpenCL, FixedSizeArrays will hopefully directly map to native OpenCL types.

For some more advantages, you can take a look at [MeshIO](https://github.com/JuliaIO/MeshIO.jl).

Because it's so easy to define different types like Point3, RGB, HSV or Normal3, one can create customized code for these types via multiple dispatch. This is great for visualizing data, as you can offer default visualizations based on the type.
Without FixedSizeArrays, this would end up in a lot of types which would all need to define the same functions over and over again.

#### Roadmap
* use tuple types, best with the new getindex changes (JuliaLang/julia#10525) in julia 0.4
* improve coverage
* incorperate https://github.com/StephenVavasis/Modifyfield.jl
* improve API and consistency

#### TODO's

- [ ] Core Array
	- [x] basic array interface
	- [ ] Inherit from DenseArray (a lot of warnings is caused by this)
	- [ ] use tuples as a basis
- [ ] Indexing:
	- [x] multidimensional access
	- [x] colon access for matrices
	- [ ] multidimensional colon access
	- [ ] setindex!
	- [ ] setindex!/getindex for arrays of FSA (e.g. easy acces to single fields)
	- [ ] access via dimension type (Red -> redchannel)
- [ ] Constructor
	- [x] generic constructor for arbitrary Nvectors
	- [x] fast constructor for arbitrary types
	- [x] different constructors for ease of use (zero, eye, from other FSAs, etc...) (could be more)
- [ ] Functions
	- [x] all kinds of unary/binary operators
	- [x] matrix multiplication
	- [x] matrix functions (inv, transpose, etc...) (could be more)

#### Acknowledgements
[ImmutableArrays](https://github.com/twadleigh/ImmutableArrays.jl) by [twadleigh](https://github.com/twadleigh) was the package that got me going and gave the initial inspirations.
There has been quite a few discussions on [JuliaLang/julia#7568](https://github.com/JuliaLang/julia/pull/7568) shaping the implementation.
Also, [aaalexandrov](https://github.com/aaalexandrov) supplied some code and inspirations.

gha_language: Julia


text:
# Changelog

All notable changes to [min-dash](https://github.com/bpmn-io/min-dash) are documented here. We use [semantic versioning](http://semver.org/) for releases.

## Unreleased

___Note:__ Yet to be released changes appear here._

## 2.0.0

### Breaking Changes

* `FEAT`: expose utilities via main export only ([`cb6ab757`](https://github.com/bpmn-io/min-dash/commit/cb6ab757fa07e8728ba6c7bd692f93a94afecceb))

### Other Improvements

* `CHORE`: generate ES, CJS and UMD bundles using rollup
* `CHORE`: babelify results and don't require `Object.assign` polyfill

## ...

Check `git log` for earlier history.

repository: TheSharpieOne/min-dash

repo_name: TheSharpieOne/min-dash


text:
# Mr.Comic-

## Team Name : CoDeam
### Members  :
            1.Lina Al-mashaikh
            2.Mohammad Khamees
            3.Bisher Nobani
            4.Jameela Othman
            5.Faten Samman
            6.Ali Mohammad

### Project Name : Mr. Comic
- This website is built for fun , take a pill and maybe to refresh your childhood memory, its for carton characters "Comic".
It contains 3 main Ideas ; the first one is to show you a lot of carton characters and its' bios ,
and you can also search about yours,
the second one is we can guess your comic by a guessing game ,
and the last one you can make your comic the hero of the week by voting,
stay tuned

- Its just to get you back 10 - 15 years ago , and getting fun as much as you were feeling back then.

#### WireFrames
- Home Page

![home](imgwireFrames/homepage.png)
- Description Page
![discreption](imgwireFrames/discriptionpage.png)
- Game Page
![game](imgwireFrames/gamepage.png)
- Voting Page
![votingpage](imgwireFrames/votingpage.png)
- About us Page
![aboutpage](imgwireFrames/aboutpage.png)

#### Domain Modeling
![DM](imgwireFrames/MD.jfif)


text:
# Front-end Master Video Downloader

The default behavior of the script is to fetch and download **all** available courses. It is a time consuming process (about 30 minutes) since it use GUI browser to do the crawling.

NOTE:

This assumes you have got a Frontend Master account with subscription

Please do NOT spread the downloadable links to others. Please keep you subscription to continue supporting [FrontendMaster](https://frontendmasters.com/) and getting updates from them.

## Usage

**Requirements**

- Python 2.7
- Google Chrome

```python
# Step 0: Install Google Chromedriver
# The latest version can be found at
# https://sites.google.com/a/chromium.org/chromedriver/downloads

# Step 1: Install dependencies
pip install -r requirements.txt

# Step 2: Edit account info. in config.sample.py
# Step 3: Rename config.sample.py -> config.py

# Step 4 (OPTIONAL): Create courses list
# The --courses-list-only option gives you the opportunity to decide
# what courses you want to download in the next step.
# After it runs, just open the DATA_COURSE_LIST.json file
# and remove those you don't want
python run.py --courses-list-only

# Step 5: Download the courses!
python run.py

# Step 6: Happy hacking!
# Find all the courses videos inside `Download` folder inside project directory
```

## Special Thanks

Thanks [@andreiglingeanu](https://github.com/andreiglingeanu) for his kindness.


text:
# Package management

One of the new features in WMF5 that's worth mentioning is Packagemanagent.

Discover the commands for working with Packagemanagement
```powershell
Get-Command -Modulename PackageManagement
```

Play around with these commands and the Get-Help to see what these does.

```powershell
Get-PackageSource
Get-PackageProvider
Find-PackageProvider Chocolatey
Find-PackageProvider Nuget
Find-PackageProvider Chocolatey|Install-PackageProvider
Find-PackageProvider Nuget|Install-Packageprovider
```
After installing a package provider, you should restart your powershell session. You should then be able to install packages from e.g. chocolatey :

```powershell
find-package GoogleChrome -providername chocolatey|Install-Package
```

## Working with package management in DSC

Install the module for PackageManagement

```powershell

Get-DscResource PackageManagement|Select ModuleName|Get-Module|Install-Module
# Or directly
Find-Module PackageManagementProviderResource|Install-Module
```

## Create a simple configuration to fetch packages

We will now create a first configuration to fetch packages from chocolatey using the package provider Chocolatey.

```powershell

Configuration PackageConfig {

   Import-DscResource -ModuleName PackageManagementProviderResource

   Node localhost {

    PackageManagementSource ChocoSource {
        Ensure = 'Present'
        Name = 'Chocolatey'
        ProviderName = 'Chocolatey'
        SourceUri = 'http://chocolatey.org/api/v2/'
        InstallationPolicy = 'Trusted'
    }

    PackageManagement InstallNotepadPlus {
        DependsOn ='[PackageManagementSource]ChocoSource'
        Ensure ='Present'
        Name = 'notepadplusplus'
        ProviderName = 'chocolatey'
    }

   }

}

PackageConfig -OutputPath .\

```
Run the configuration and see that you now have notepad++ installed on the machine

## Register nuget source for Nuget

Now; we will install a nuget source and install a nuget package. This can be fairly useful for e.g. registring to local nuget repositories, myget etc and installing custom packages.

```powershell

Configuration PackageConfig {

   Import-DscResource -ModuleName PackageManagementProviderResource

   Node localhost {

    PackageManagementSource ChocoSource {
        Ensure = 'Present'
        Name = 'Chocolatey'
        ProviderName = 'Chocolatey'
        SourceUri = 'http://chocolatey.org/api/v2/'
        InstallationPolicy = 'Trusted'
    }

    PackageManagement InstallNotepadPlus {
        DependsOn ='[PackageManagementSource]ChocoSource'
        Ensure ='Present'
        Name = 'notepadplusplus'
        ProviderName = 'chocolatey'
    }

    PackageManagementSource SourceRepository
    {

            Ensure      = "Present"
            Name        = "MyNuget"
            ProviderName= "Nuget"
            SourceUri   = "http://nuget.org/api/v2/"
            InstallationPolicy ="Trusted"
    }

    NugetPackage Nuget
    {
        Ensure          = "Present"
        Name            = "jQuery"
        DestinationPath = "C:\Temp"
        DependsOn       = "[PackageManagementSource]SourceRepository"
    }
   }

}

PackageConfig -OutputPath .\

```
Run the configuration and see that you get JQuery in your temp folder

repository: haraldfianbakken/dsc-workshop

repo_name: haraldfianbakken/dsc-workshop


text:
Python integrations tests
==========

In order to generate tests:
* prepare nosetests venv: `make nose-env`

* generate python client for the API: `make swagger-python

* execute tests (for local/dev1): `make python-tests`

license: ISC

repository: Sudo-error/epoch

repo_name: Sudo-error/epoch


text:
## Using bootstrap-bindown.sh

This is the preferred method for ci or development environments. Each release
contains a shell script `bootstrap-bindown.sh` that will download bindown for
the current os. Place `bootstrap-bindown.sh` from the
[latest release](https://github.com/WillAbides/bindown/releases/latest) in your
project's repository. Don't forget to make it executable first (`chmod +x bootstrap-bindown.sh` on most systems
). Then you can call `bootstrap-bindown.sh`
before `bindown` in the projects bootstrap script or Makefile.

 Pro tip: Your life will be easier with a
lowercase GitHub username.

repository: WillAbides/bindown

gha_language: Go

repo_name: WillAbides/bindown


text:
# Servo Pulse Input

By: DavidG

Language: Spin

Created: Apr 16, 2013

Modified: April 16, 2013

This object reads standard R/C servo pulse widths from a device such as a receiver. It can read an arbitrary number of channels and stores the pulse widths as integer microseconds in the same format used by Servo32.spin.

The object could be useful for channel mixing or autonomous vehicle development.

repository: parallaxinc/propeller

gha_language: Propeller Spin

repo_name: parallaxinc/propeller


text:
# Rool the dice

# Important

:key: Take a look --> https://victorlira-dev.github.io/Roll-the-dice/

Rules

The first player that reaches 100 points wins, if the dice is equal to 1, then the player loses his turn and his current points.

## :mag: About

This project is from Udemy: The Complete JavaScript Course 2021: From Zero to Expert! in this I was challenge to write this code on my own, using pure javascript, this is the second project of this course, we used everything we learned so far, to solidify this knowledge
 course --> https://www.udemy.com/course/the-complete-javascript-course/learn/lecture/22648783?start=1215

---

You can use any tools you like to help you complete the challenge. So if you've got something you'd like to practice, feel free to give it a go.

---
## :information_source: Application installation
- `https://github.com/VictorLira-DEV/Roll-the-dice.git` to clone the repository

### 🎲 Starting the application

1. Open the `index.html` file in the browser to view the pages created.

## :rocket: Technologies used:

Created by **jonas**

Developed by **Victor Lira**


text:
flying-monkey
=============
Navigation for 3DR Drones

# Installation

    npm install flying-monkey
    mv node_modules/flying-monkey .
    rmdir node_modules

or alternately clone this repo followed by

    npm install

And then to install the front end components in the flying-monkey directory

    bower install

# API

## Current URL endpoints

The following is accessed via browser at the ip address of the drone.  *http://droneIP:3000/*

* `/map`: gps coordinates embedded in [mapbox](https://www.mapbox.com/) style map.


text:
# tasks_per_transaction

`tasks_per_transaction` parameter controls how many tasks will be pulled on each transaction against the broker. When your tasks are completed quickly, you might want to change the default number.

Pick a number based on the following assumptions:
- The larger the number, the less friction with the broker and the lower the overhead for the broker
- The greater the number, the more tasks are in the Worker's inner queue that must be completed before the Worker is allowed to communicate with the broker again.
- The greater the number, the more workers might be unable to pull tasks from the queue as it becomes empty.
- The lower the number, the heavier the load on the broker.
- As the number decreases, the task distribution becomes more uniform.

## Definition

```python
tasks_per_transaction: int = 1
```

repository: Intsights/sergeant

gha_language: Python

repo_name: Intsights/sergeant


text:
# Env Alias

[![PyPi](https://img.shields.io/pypi/v/arpwitch.svg)](https://pypi.python.org/pypi/arpwitch/)
[![Python Versions](https://img.shields.io/pypi/pyversions/arpwitch.svg)](https://github.com/verbnetworks/arpwitch/)
[![Build Status](https://api.travis-ci.org/verbnetworks/arpwitch.svg?branch=master)](https://travis-ci.org/verbnetworks/arpwitch/)
[![Read the Docs](https://img.shields.io/readthedocs/arpwitch)](https://arpwitch.readthedocs.io)
![License](https://img.shields.io/github/license/verbnetworks/arpwitch.svg)

## Project
* Github - [github.com/verbnetworks/arpwitch](https://github.com/verbnetworks/arpwitch)
* PyPI - [pypi.python.org/pypi/arpwitch](https://pypi.python.org/pypi/arpwitch/)
* TravisCI - [travis-ci.org/github/verbnetworks/arpwitch](https://travis-ci.org/github/verbnetworks/arpwitch)
* ReadTheDocs - [arpwitch.readthedocs.io](https://arpwitch.readthedocs.io)

## Features / Bugs
Please submit all feature-requests and bug-reports via Github issues -
* https://github.com/verbnetworks/arpwitch/issues

## Versions
Legacy versions based on year-date (eg v2018.2) have been hard-deprecated in favour of a backward incompatible
standard versioning scheme (eg v0.2.0).  Coinciding with this change in version numbers, the command-line args
are quite different to previous versions as well.  The new command-line args are based on user experience and
what works well/better in the field.

## Contact
* https://verbnetworks.com - the laboratory
* https://nicholasdejong.com - personal

repository: LaurentFough/arpwitch

repo_name: LaurentFough/arpwitch


text:
# Budget Tracker App ![License Badge for MIT](https://img.shields.io/badge/License-MIT-green)

# Description
This is a progressive web app that can be used to track and chart a person's incomes and expenses online or offline. When used ofline the site functions normally and sends any updated entries to the database when brought back online.

## Table of Contents
* [Installation](#installation)
* [Usage](#usage)
* [License](#license)
* [Questions](#questions)

### Installation
From a terminal inside the repo, run 'npm install' and then 'npm start' to begin the server. Then you can find it running on localhost:3000

### Usage
This app is used to track instances of income or expese and it will chart them on a line graph that is updated with each new entry. It works online or off. You can enter a new expense or income by entering a name and an amount and then pressing the appropriate add or subtract funds button. This will add the instance, change your running balance, and update the chart.

### License
Budget Tracker App

Copyright © 2020 Caleb Deal

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

### Questions
Please direct questions to my github account, cddeal12 found at [https://github.com/cddeal12](https://github.com/cddeal12)
Alternatively you can reach me by email at<EMAIL_ADDRESS>


text:
A library for isolated developing UI components and automatically taking snapshots of them.

# Playbook

`Playbook` is a library that provides a sandbox for building UI components without having to worry about application-specific dependencies, strongly inspired by [Storybook](https://storybook.js.org/) for JavaScript in web-frontend development.

Components built by using `Playbook` can generate a standalone app as living styleguide.
This allows you to not only review UI quickly but also deliver more robust designs by separating business logics out of components.

Besides, snapshots of each component can be automatically generated by unit tests, and visual regression testing can be performed using arbitrary third-party tools.

For complex modern app development, it’s important to catch UI changes more sensitively and keep improving them faster.
With the `Playbook`, you don't have to struggle through preparing the data and spend human resources for manual testings.

---

## Usage

- [API Document](https://playbook-ui.github.io/playbook-ios)
- [Example App](https://github.com/playbook-ui/playbook-ios/tree/master/Example)

---

### Playbook

`Playbook` is a framework that provides the basic functionality for managing components. It supports both `SwiftUI` and `UIKit`.
Components are uniquely stored as scenarios. A `Scenario` has the way to layout component. Please check the [API Doc](https://playbook-ui.github.io/playbook-ios/ScenarioLayout/) for the variety of layouts.

```swift
Playbook.default.addScenarios(of: "Home") {
    Scenario("CategoryHome", layout: .fill) {
        CategoryHome().environmentObject(UserData.stub)
    }

    Scenario("LandmarkList", layout: .fill) {
        NavigationView {
            LandmarkList().environmentObject(UserData.stub)
        }
    }

    Scenario("UIView red", layout: .fixed(length: 100)) {
        let view = UIView()
        view.backgroundColor = .red
        return view
    }
}
```

`ScenarioProvider` allows you to isolate additional scenarios and keep your playbook building clean.

```swift
struct HomeScenarios: ScenarioProvider {
    static func addScenarios(into playbook: Playbook) {
        playbook.addScenarios(of: "Home") {
            Scenario("CategoryHome", layout: .fill) {
                CategoryHome().environmentObject(UserData.stub)
            }
        }
    }
}

struct AllScenarios: ScenarioProvider {
    static func addScenarios(into playbook: Playbook) {
        playbook.add(HomeScenarios.self)
    }
}
```

You can use the `ScenarioContext` passed to the closure that creates the component to get the screen size in snapshot, or wait before generating a snapshot.

```swift
Scenario("MapView", layout: .fill) { context in
    MapView(coordinate: landmarkData[10].locationCoordinate) {
        // This closure will called after the map has completed to render.
        context.snapshotWaiter.fulfill()
     }
     .onAppear(perform: context.snapshotWaiter.wait)
}
```

---

### PlaybookUI

`PlaybookUI` is a framework that provides user interfaces made by `SwiftUI` for browsing a list of scenarios.

#### PlaybookGallery

The component visuals are listed and displayed.
Those that are displayed on the top screen are not actually doing layout, but rather display the snapshots that are efficiently generated at runtime.

| Browser | Detail |
| ------- | ------ |
|||

#### PlaybookCatalog

The UI that search and select a scenario in a drawer. It's more similar to `Storybook`.
If you have too many scenarios, this may be more efficient than `PlaybookCatalog`.

| Browser | Detail |
| ------- | ------ |
|||

#### How to Save Snapshot Images

To save snapshot images to the photo library from the share button on each UI, `NSPhotoLibraryAddUsageDescription` must be supported.  See the [official document](https://developer.apple.com/library/archive/documentation/General/Reference/InfoPlistKeyReference/Articles/CocoaKeys.html#//apple_ref/doc/uid/TP40009251-SW73) for more information.

---

### PlaybookSnapshot

Scenarios can be tested by the instance of types conform to `TestTool` protocol.
`Snapshot` is one of them, which can generate the snapshots of all scenarios with simulate the screen size and safe area of the given devices.
Since Playbook doesn't depend on XCTest, it doesn't necessarily need to be run on Unit-test.

```swift
final class SnapshotTests: XCTestCase {
    func testTakeSnapshot() throws {
        let directory = ProcessInfo.processInfo.environment["SNAPSHOT_DIR"]!

        try Playbook.default.run(
            Snapshot(
                directory: URL(fileURLWithPath: directory),
                clean: true,
                format: .png,
                keyWindow: UIApplication.shared.windows.first { $0.isKeyWindow },
                devices: [.iPhone11Pro(.portrait)]
            )
        )
    }
}
```

---

### [PlaybookAccessibilitySnapshot](https://github.com/playbook-ui/accessibility-snapshot-ios)

An extension to `Playbook` that uses [AccessibilitySnapshot](https://github.com/cashapp/AccessibilitySnapshot) to produce snapshots with accessibility information such as activation points and labels.

---

### Integration with Third-party Tools

The generated snapshot images can be used for more advanced visual regression testing by using a variety of third party tools.

#### [percy](https://percy.io)

#### [reg-viz/reg-suit](https://github.com/reg-viz/reg-suit)

---

## Requirements

- Swift 5.1+
- Xcode 11.0+
- iOS
  - `Playbook`: 11.0+
  - `PlaybookSnapshot`: 11.0+
  - `PlaybookUI`: 13.0+

---

## Installation

Playbook features are separated into the following frameworks.

- `Playbook`: Core system of component management.
- `PlaybookSnapshot`: Generates snapshots of all components.
- `PlaybookUI`: Products a browsing UI for components managed by Playbook.

### [CocoaPods](https://cocoapods.org)

Add the following to your `Podfile`:

```ruby
target 'YourPlaybook' do
  pod 'Playbook'
  pod 'PlaybookUI'

  target 'YourPlaybookTests' do
    inherit! :search_paths

    pod 'PlaybookSnapshot'
  end
end
```

### [Carthage](https://github.com/Carthage/Carthage)

Add the following to your `Cartfile`:

```
github "playbook-ui/playbook-ios"
```

### [Swift Package Manager](https://developer.apple.com/documentation/xcode/adding_package_dependencies_to_your_app)

Select Xcode menu `File > Swift Packages > Add Package Dependency...` and enter repository URL with GUI.

```
Repository: https://github.com/playbook-ui/playbook-ios
```

Note: Currently, SwiftPM doesn't support specifying the OS version for each library, so only `iOS13` is supported.

---

## License

Playbook is released under the [Apache 2.0 License](https://github.com/playbook-ui/playbook-ios/tree/master/LICENSE).

repository: playbook-ui/playbook-ios

gha_language: Swift

repo_name: playbook-ui/playbook-ios


text:
# Python 5: Types of Data Objects in Python

This section briefly overviews various types of data objects that you may encounter or use in Python. It goes beyond the earlier discussion of variables, which only touches on strings, integers, and values.

## More Complex Types

* string - a *sequence* of characters, usually denoted by round brackets `()`.
* [list](https://www.py4e.com/html3/08-lists) - an indexed and mutable list of values, denoted by square brackets: `[]`. Items can be indexed by their position (starting with 0), or by their value.
* [dictionary](https://www.py4e.com/html3/09-dictionaries) - an array of key-value pairs, denoted by curly brackets: `{}`.
* [tuple](https://www.py4e.com/html3/10-tuples) - an efficient, immutable array of values, denoted by round brackets, with individual values set off by single quotes `('a', 'b')`.

To determine the type of an object, you can always use tye `type()` method.

### Credits
This content generously draws up on the work of Charles Severance in [_Python for Informatics_](http://www.pythonlearn.com/book.php) and [Python for Everybody](https://www.py4e.com/).

repository: morskyjezek/digcur

repo_name: morskyjezek/digcur


text:
---
title: "Dockerizing vim"
categories: article
tags: dev vim docker
---

I have dockerized my vim so that I can pull the image and get my familiar vim setup within minutes from any machine (with docker).

I was heavily inspired by [this](https://github.com/JAremko/alpine-vim) dockerized vim project. Check it out if you think that's enough for you. Or you can use the [images](https://hub.docker.com/r/asyazwan/vim/tags/) I have prepared:

- `asyazwan/vim:tiny`   - 24MB compressed / 61MB uncompressed
- `asyazwan/vim:small`  - 24MB compressed / 61MB uncompressed
- `asyazwan/vim:normal` - 25MB compressed / 62MB uncompressed
- `asyazwan/vim:big`    - 25MB compressed / 62MB uncompressed
- `asyazwan/vim:huge`   - 25MB compressed / 62MB uncompressed

Check out [this](http://www.drchip.org/astronaut/vim/vimfeat.html) table of comparison for the differences between features
{: .notice--info}

But if you want to make your own image, here's how I did it.

I have pushed the Dockerfiles used into [this](https://github.com/asyazwan/docker-vim) repository.  It's to reduce the size of final image since it won't have all the packages required for building vim like `gcc` and various libraries and their headers. Also, if you take out the last 2 `RUN` statements and also remove `ruby`, `perl` and `php7` packages, your vim image (uncompressed) will only be around 30MB!

Remove `--enable-<language>interp` from the build stage and the language package from the last stage if you don't want them. Chances are you won't need them if you don't already know what they are for.

The second-last `RUN` will install additional stuff that I need. `the_silver_searcher` is for using `:Ag` in vim and `fzf` is for lots of useful commands that I use many times a day.
The last `RUN` will clone `fzf` vim plugin and run the install script.

Use `docker build -t vim-base .` to build and you will have a pretty capable vim. Run `docker run --rm vim-base "--version"` to see what features have been compiled with vim.

Now that I have base vim, it's time to bake in some plugins. I've been using the same plugins for some time now and I don't think they're going to change anytime soon, so I decided to put the plugins into my final vim image.  From the base vim image, I create user account the same as I have on the current machine, which can be overriden via `--build-arg`. This is to avoid possible file permission/ownership issues. Then I copy my plugin manager [Plug](https://github.com/junegunn/vim-plug), the plugins, vimrc file, and  [fzf](https://github.com/junegunn/fzf) files. Entrypoint is set to my current favorite terminal.

 Invoke vim with `vim .`.

That's the idea, basically. From any machine with docker I can just clone the repo and build `Dockerfile.plugins` to get my familiar development environment.

Please share if you have suggestions on how to improve it.


text:
## Name

syscall - test a system call

## Synopsis

```**sh
$ syscall [-o] [-l] [-h] <syscall-name> <args...> [buf==BUFSIZ buffer]
```

## Description

The `syscall` utility can be used to invoke a system call with the given arguments.

## Options

* `-o`: Output the contents of the buffer argument specified as buf to stdout.
* `-l`: Print a space separated list of all the Serenity system calls and exit. Note that not all the system calls can be invoked using this tool.
* `-h`: Print a help message and exit.

## Examples

Write a string to standard output:

```sh
$ syscall write 1 hello 5
```

Read a string from the standard input into a buffer and output the buffer contents to stdout:

```sh
$ syscall -o read 0 buf 3
```

Get the pid of the current running process:

```sh
$ syscall getpid
```

Sleep for 3 seconds:

```sh
$ syscall sleep 3
```

Create a directory:

```sh
$ syscall mkdir my-dir 0755
```

Exit the program with status 2:

```sh
$ syscall exit 2
```

## History

This is a direct port of a utility with the same name originated from the Plan 9 operating system.

repository: SerenityOS/serenity

repo_name: SerenityOS/serenity


text:
# floristry
An investigation into responsive chart layouts.

## License
Released under the [MIT License](http://www.opensource.org/licenses/MIT)
[![MIT license](http://img.shields.io/badge/license-MIT-brightgreen.svg)](http://opensource.org/licenses/MIT)

repository: paulhhowells/floristry

repo_name: paulhhowells/floristry


text:
# [kwb.wtaq 0.3.0](https://github.com/KWB-R/kwb.wtaq/releases/tag/v0.3.0) 2022-06-11

* Harmonise with [kwb.pkgbuild](https://kwb-r.github.io/kwb.pkgbuild)

# [kwb.wtaq 0.2.1](https://github.com/KWB-R/kwb.wtaq/releases/tag/v0.2.1) 2016-09-06

**First Github release:**

* added /src files for WTAQ-2 from
* added test for WTAQ2 calculation results on Windows

# kwb.wtaq 0.2.0  Unreleased

Developed within project
[OPTIWELLS-2](https://www.kompetenz-wasser.de/en/project/optiwells-2-betriebsoptimierung-von-trinkwasserbrunnen/)
(internal SVN repo rev1268)

# kwb.wtaq 0.1.3  Unreleased

### UCODE related
* Bug fix in ucPlotPng

# kwb.wtaq 0.1.2  Unreleased

### WTAQ related

* new: print.wtaqConf, wtPlotResult,
* removed: wtPlotPWell, wtPlotOWell,
* renamed: wtPlotProfile -> wtPlotConf
* wtReadPlotLst: stop if file is empty, returns object of class "wtaqResult"
* wtReadPlotMtx: returns object of class "wtaqResult"
* wtReadInpFile: bug fix
* wtConf: returns object of class "wtaqConf"
* wtInpFileLines: new arg "dbg", float formats 9.3f/9.2f,
* wtConfEx2, wtConfEx3: return object of class "wtaqConf", examples

### UCODE related

* new: ucPlot, ucReadSummary, ucPlotSummary
* ucPlotPng: arg "data" renamed -> "wtaqResult"

# kwb.wtaq 0.1.1  Unreleased

### WTAQ related
* new functions: wtReadInpFile, wtCheckConf
* wtConfDrainage, wtConfTimes, wtConfSolution, wtConfPumpwell:
  numeric defaults
* wtInpFileLines: arg "pvals" renamed "conf", format consideration
* wtConf: argument check

### UCODE related

* support of "serial" and "parallel" running of UCODE/WTAQ
* names of UCODE-files modified
* ucRunParallel: generation of HTML- and png-files for calibration progress visualisation
* new functions: ucPlot, ucPlotPng, htmlMain, htmlCurrent, htmlHistory
* change in arguments: ucPrepCalib, ucWriteBatchUcode, ucWriteMainInput,
  ucConf_Model_Command_Lines, ucInpFileLines

# kwb.wtaq 0.1.0  Unreleased

* depends on package hydroGOF

* Functions have been renamed:
  wtGeneral       -> wtConfGeneral,
  wtAquifer       -> wtConfAquifer,
  wtDrainage      -> wtConfDrainage,
  wtTimes         -> wtConfTimes,
  wtSolution      -> wtConfSolution,
  wtPumpwell      -> wtConfPumpwell,
  wtObswell       -> wtConfObswell,
  wtParSetting    -> wtConf,
  wtParSettingEx3 -> wtConfEx3
* New functions:
  wtReadPlot, wtConfWellnames, wtDefaultConf
  functions related to UCODE, starting with "uc"
* Changes:
  wtRun: default for wtaq

# kwb.wtaq 0.0.1  Unreleased

**First creation of the package containing:**

* wtReadPlotLst()
* wtReadPlotMtx()
* wtSetPars()
* wtRunScenarios()

gha_language: Fortran


text:
---
ID: 422
post_title: 'Named Pipes before TCP/IP causes "SQL Server does not exist or access denied" error message'
author: Roel van Lisdonk
post_excerpt: ""
layout: post
permalink: >
  https://www.roelvanlisdonk.nl/2009/05/22/named-pipes-before-tcpip-causes-sql-server-does-not-exist-or-access-denied-error-message/
published: true
post_date: 2009-05-22 08:41:09
---

Applies to Microsoft SQL Server 2000
If Named Pipes come before TCP/IP in the SQl Server Client Network Utility, you can get the error message "SQL Server does not exist or access denied", when you try to connect remotely to your Microsoft SQL Server 2000 instance. When you connect localy on the server everything seems to work fine.

Solution
Disable all network protocols except TCP/IP in the SQl Server Client Network Utility
Restart the service of your Micorosft SQL Server 2000 instance.

repository: roelvanlisdonk/blogposts

repo_name: roelvanlisdonk/blogposts


text:
# Escaping

Prevent markdown from rendering certain styling, you can escape them. In the examples below the italics are part of a filename and italics styling is unwanted.

## Escape with backticks

Code backticks escape any styling characters inside them.

Code:

    Update the `_config.yml` file then run [`__init__.py`](__init__.py).

Result:

Update the `_config.yml` file then run [`__init__.py`](__init__.py).

## Escape text with backslash

Code:

    Update the \_config.yml file then run \_\_init\_\_.py.

Result:

Update the \_config.yml file then run \_\_init\_\_.py.

## Escaping links

Escape the link text using backslash or backticks. The target does not need escaping.

    Update the [\_config.yml](_config.yml) file.

Update the [\_config.yml](_config.yml) file.

## Dash not bullet point

```markdown
> "Art is never finished, only abandoned."
>
> \- Leonardo da Vinci
```

> "Art is never finished, only abandoned."
>
> \- Leonardo da Vinci

gha_language: Makefile


text:
# Assignment 3
Link to this [Assignment](https://github.com/ondrasouk/Digital-electronics-1/tree/main/Labs/03-vivado)
Link to [top of repository](https://github.com/ondrasouk/Digital-electronics-1)
## Preparation
![](images/n4r.png)
[Source link](https://reference.digilentinc.com/_media/reference/programmable-logic/nexys-a7/n4r.png)
## Multiplexer
### Listing of architecture
```VHDL
architecture Behavioral of mux_2bit_4to1 is

begin

process (a_i, b_i, c_i, d_i, sel_i)
    begin
        f_o <= a_i when (sel_i = "00") else
               b_i when (sel_i = "01") else
               c_i when (sel_i = "10") else
               d_i;
    end process;

end Behavioral;
```
### Listing of stimulus process
```VHDL
     p_stimuls : process
     begin
     report "Stimulus process started" severity note;
     --init. signal
        s_a <= "11";
        s_b <= "11";
        s_c <= "11";
        s_d <= "11";
     --1.st combination
        s_sel <= "00";
            s_a <= "01";
            wait for 100 ns;
            s_a <= "10";
            wait for 100 ns;
            s_a <= "11";
     --2.nd combination
        s_sel <= "01";
            s_b <= "01";
            wait for 100 ns;
            s_b <= "10";
            wait for 100 ns;
            s_b <= "11";
     --3.rd combination
        s_sel <= "10";
            s_c <= "01";
            wait for 100 ns;
            s_c <= "10";
            wait for 100 ns;
            s_c <= "11";
     --4.th combination
        s_sel <= "11";
            s_d <= "01";
            wait for 100 ns;
            s_d <= "10";
            wait for 100 ns;
            s_d <= "11";
        report "Stimulus process ended" severity note;
        wait;
     end process p_stimuls;
```
### Screenshot of simulation
![](images/mux.png)
## Tutorial
### Project creation
![](images/sc1.png)
Click on File > Project > New. In opened window click on Next.
![](images/sc2.png)
First specify location of new project and then project name. Click on Next.
![](images/sc3.png)
Select RTL Project and click on Next.
![](images/sc5.png)
Select target and simulator language as VHDL. Click on Create File and fill filename and click on OK.
![](images/sc4.png)
It will look like this.
Next up is adding constrains files, but we will only click on Next.
![](images/sc6.png)
Next is choosing hardware and we click on Boards and then on "Nexys A7-50T" and click on Next.
![](images/sc7.png)
Project summary will look like this.
Click on Finish.
![](images/sc8.png)
There will be another dialog window with module name, enter name and click on OK.
You have created a new project!
### Adding source file
![](images/sc9.png)
Click on plus in project manager or at the toolbar > Files > Add Sources. In dialog window select design source and click on Next.
![](images/sc10.png)
Click on Create File, fill filename and click on OK and Next.
![](images/sc11.png)
Fill Entity name or add I/O ports Definitins and click on OK.
### Adding testbench file
![](images/sc12.png)
Open dialog for adding sources and select simulation sources. Click on Next.
![](images/sc13.png)
In the next window click on Create File, fill filename and click on OK and Next.
![](images/sc14.png)
Fill entity name and click on OK.
### Running simulation
![](images/sc15.png)
Click on toolbar in Flow > Run Simulation > Run Behavioral Simulation
![](images/sc16.png)
Wait for program to complete and you will see simulation output.


text:
A file path with associated metadata.

See:

* [Members](members.md)
* [Constructors](constructors.md)
* [Static Functions](statics.md)
* [Functions](functions.md)

The File is one of two important data structures in OpenBR (the [Template](../template/template.md) is the other).
It is typically used to store the path to a file on disk with associated metadata.
The ability to associate a key/value metadata table with the file helps keep the API simple while providing customizable behavior.

When querying the value of a metadata key, the value will first try to be resolved against the file's private metadata table.
If the key does not exist in its local table then it will be resolved against the properties in the global Context.
By design file metadata may be set globally using Context::setProperty to operate on all files.

Files have a simple grammar that allow them to be converted to and from strings.
If a string ends with a **]** or **)** then the text within the final **[]** or **()** are parsed as comma separated metadata fields.
By convention, fields within **[]** are expected to have the format <tt>[key1=value1, key2=value2, ..., keyN=valueN]</tt> where order is irrelevant.
Fields within **()** are expected to have the format <tt>(value1, value2, ..., valueN)</tt> where order matters and the key context dependent.
The left hand side of the string not parsed in a manner described above is assigned to [name](members.md#name).

Values are not necessarily stored as strings in the metadata table.
The system will attempt to infer and convert them to their "native" type.
The conversion logic is as follows:

1. If the value starts with **[** and ends with **]** then it is treated as a comma separated list and represented with [QVariantList][QVariantList]. Each value in the list is parsed recursively.
2. If the value starts with **(** and ends with **)** and contains four comma separated elements, each convertable to a floating point number, then it is represented with [QRectF][QRectF].
3. If the value starts with **(** and ends with **)** and contains two comma separated elements, each convertable to a floating point number, then it is represented with [QPointF][QPointF].
4. If the value is convertable to a floating point number then it is represented with <tt>float</tt>.
5. Otherwise, it is represented with [QString][QString].

Metadata keys fall into one of two categories:
* camelCaseKeys are inputs that specify how to process the file.
* Capitalized_Underscored_Keys are outputs computed from processing the file.

Below are some of the most commonly occurring standardized keys:

Key             | Value          | Description
---             | ----           | -----------
name            | QString        | Contents of [name](members.md#name)
separator       | QString        | Separate [name](members.md#name) into multiple files
Index           | int            | Index of a template in a template list
Confidence      | float          | Classification/Regression quality
FTE             | bool           | Failure to enroll
FTO             | bool           | Failure to open
\*_X             | float          | Position
\*_Y             | float          | Position
\*_Width         | float          | Size
\*_Height        | float          | Size
\*_Radius        | float          | Size
Label           | QString        | Class label
Theta           | float          | Pose
Roll            | float          | Pose
Pitch           | float          | Pose
Yaw             | float          | Pose
Points          | QList<QPointF> | List of unnamed points
Rects           | QList<Rect>    | List of unnamed rects
Age             | float          | Age used for demographic filtering
Gender          | QString        | Subject gender
Train           | bool           | The data is for training, as opposed to enrollment
_\*              | \*              | Reserved for internal use

<!-- Links -->
[QString]: http://doc.qt.io/qt-5/QString.html "QString"
[QVariantList]: http://doc.qt.io/qt-5/qvariant.html#QVariantList-typedef "QVariantList"
[QRectF]: http://doc.qt.io/qt-5/qrectf.html "QRectF"
[QPointF]: http://doc.qt.io/qt-5/qpointf.html "QPointF"

repository: biometrics/openbr

gha_license_id: NOASSERTION

repo_name: biometrics/openbr


text:
# Demo Video stream app
This project is made as a template for scalable and flexible API endpoints, Video streaming and User-Address management.

## [Live Demo](https://demo-video-stream.herokuapp.com/swagger)
## [![App](https://raw.githubusercontent.com/IvanDimanov/demo-video-stream/master/image.png)](https://demo-video-stream.herokuapp.com/swagger)

## Tech stack
- fastify: [https://www.fastify.io/](https://www.fastify.io/)
- objection: [https://vincit.github.io/objection.js/](https://vincit.github.io/objection.js/)
- Swagger: [https://github.com/fastify/fastify-swagger](https://github.com/fastify/fastify-swagger)
- TypeScript: [https://www.typescriptlang.org/](https://www.typescriptlang.org/)

## Run locally
### Clone repo
```
git clone git@github.com:IvanDimanov/demo-video-stream.git
cd ./demo-video-stream
npm ci
cp .env.example .env
```

### Sync Database
Make sure the `DB_URL` ENV VAR in `.env` is accessible.
```
npm run db-migrate-latest
npm run db-seed
```

### Run the app
```
npm start
```

Open Swagger Docs [http://localhost:8000/swagger](http://localhost:8000/swagger)

Open Video Streaming app [http://localhost:8000/app](http://localhost:8000/app)
<br />

## Tests
We use [`mocha`](https://mochajs.org), [`chai`](https://www.chaijs.com), and [`sinon`](https://sinonjs.org) for our unit tests.
```
npm run test
```

Test coverage and report
```
npm run test-report
```

repository: IvanDimanov/demo-video-stream

repo_name: IvanDimanov/demo-video-stream


text:
## Unit Testing

The package provides functions to perform unit tests against a blank CDM. The unit test framework assumes you have established an empty CDM and have populated the vocabulary tables. Additionally, it is highly recommended to index the vocabulary tables when executing the unit tests.

This Unit Testing part is not needed to execute the study this is for development purposes only.

### unit Test connection details
Create or add to the file `.Renviron` in the root of the package to hold the settings for connecting to the CDM for unit testing.
````
# --------------------------------
# ------ Unit Test DB ------------
# --------------------------------
UT_DBMS = "postgresql"
UT_DB_SERVER = "myserver/unittest"
UT_DB_PORT = 5432
UT_DB_USER = dbUserName
UT_DB_PASSWORD = anotherSuperSecretPassword
UT_CDM_SCHEMA = "cdm"
UT_COHORT_SCHEMA = "results"
UT_TEST_CASES_FILE_LOCATION = "<path_to_cloned_project>/DrugUtilization/inst/testCases"
UT_TEST_CASES_RESULTS_LOCATION = "<path_to_cloned_project>/DrugUtilization/testResults"
````

### Unit Test Definitions

Unit tests are defined as .JSON files and are located in the folder `inst/testCases`. The general structure is shown here:

````
{
    "cdm.person": [
        {
            "person_id":1,
            "gender_concept_id":8532,
            "year_of_birth":1999,
            "race_concept_id":0,
            "ethnicity_concept_id":0
        },
        {
            "person_id":2,
            "gender_concept_id":8507,
            "year_of_birth":1995,
            "race_concept_id":0,
            "ethnicity_concept_id":0
        }
    ],
    "cdm.observation_period" : [
        {
          "observation_period_id": 1,
          "person_id":1,
          "observation_period_start_date":"2000-01-01",
          "observation_period_end_date":"2001-01-01",
          "period_type_concept_id": 0
        },
        {
          "observation_period_id": 2,
          "person_id":2,
          "observation_period_start_date":"2000-01-01",
          "observation_period_end_date":"2001-01-01",
          "period_type_concept_id": 0
        }
    ],
    "cdm.drug_exposure": [
        {
          "drug_exposure_id": 1,
          "person_id":1,
          "drug_concept_id":40852223,
          "quantity": 30,
          "days_supply": 30,
          "drug_exposure_start_date":"2000-01-01",
          "drug_exposure_end_date":"2000-01-31",
          "drug_type_concept_id":0
        },
        {
          "drug_exposure_id": 2,
          "person_id":2,
          "drug_concept_id":40852223,
          "quantity": 30,
          "days_supply": 30,
          "drug_exposure_start_date":"2000-01-01",
          "drug_exposure_end_date":"2000-01-31",
          "drug_type_concept_id":0
        }
    ]
````

In the example above, we define 2 patients with an observation period (mandatory) and a single drug exposure for use in a test.

### Unit Test SQL

The .JSON files described above are processed and turned into SQL located in `inst/testCases/sql` by using the R script located in `extras/CreateUnitTestData.R`. The SQL is generated and designed to create the patients as defined in the .JSON files in a blank CDM.

Before using `extras/CreateUnitTestData.R` be sure to set the enviroment variable `UT_TEST_CASES_FILE_LOCATION` shown in the Installation section above and replace `<path_to_cloned_project>` with the file path where you cloned the project from GitHub.

### Unit Test Execution

Once the SQL files with the test cases are generated, we can execute the unit tests. To do this, create a blank CDM using the appropriate scripts found on https://github.com/OHDSI/CommonDataModel. Load in the vocabulary and index the vocabulary related tables.

Next, configure the `UT_*` settings as shown in the Installation section to provide a connection to a database that you plan to use for performing the unit tests. The account that is used for these unit tests will need to have read/write access to the CDM schema to create the test cases and full control over the results schema to execute the analysis and to remove tables after each test.

The file `extras/ExecuteUnitTests.R` is used to execute the unit tests against the unit test CDM. This script will take all of the SQL files in `inst/testCases/sql` and iteratively do the following:

- Create the data in the CDM as defined in the .SQL file
- Execute the DUS analysis for those patients in the test case
- Export the results and use the test case name as the `databaseName`
- Each test result is then exported to the file location defined in `UT_TEST_CASES_RESULTS_LOCATION`

Once complete, the process will then launch the results explorer app enabling you to review the test results. The database drop down will hold the name of each test case so you can review the results.

repository: vperaEMC/RanitidineStudy

repo_name: vperaEMC/RanitidineStudy


text:
# microGUID
Tiny single-header GUID implementation for C++

Implements standard compliant type 4 GUID (random one)
Uses xorshiro for random generation, and seeds from std::random_device.

## Usage

```cpp
//use this define exactly in one source file
#define MICROGUID_IMPLEMENTATION
#include "microGUID.h"

void generate_guid(){
	guid::GUIDGenerator generator;
	//seed the generator
	generator.init();

	//build a optimal binary guid. 2 int64s of state
	guid::BinaryGUID binary = gen.make_binary_guid();
	//create a text based guid. stores null-terminated string inside
	guid::TextGUID text = guid::convert_to_text(binary);
}

```

license: Unlicense


text:
---
layout: page
title: 06. Design
permalink: /design/
---
# Other Design Choices
#### Messaging/Real-Time Connectivity
* WebSocket Server & Client
* Defined Messaging Prototocol
* Assumed Server driven experience
* Uses 'Observer Pattern'/Node Events library.

#### Servers, PaaS / Saas:
* Informated by client cost.
* Database
    * Compose.io
* Node Process
    * http://modulus.io/ (Bought out? became Xervo)
    * http://xervo.io/ (Stopped)
    * Heroku (PaaS)
        * SendGrid
        * PaperTrail / Logging

#### Messaging
* Observer pattern
* Realtime/Restful

#### File Structure
#### Switching to Deepstream.io
#### Switching to Heroku
#### Integration of Deepstream/Express.js

#### Security
* Password Hash,
* JWT (JSON Web Tokens)

#### Major Changes
* Separation from Space Escape
    * Expanded Spec
* Deepstream.io
* Modulous > Xervo > Heroku

repository: EnglishAdam/pres-wm

repo_name: EnglishAdam/pres-wm


text:
# w3id.org rewrite rules
We use [w3id.org](https://github.com/perma-id/w3id.org) identifiers throughout the model. The current mappings are as
follows:

| http://w3id.org/biolink/biolinkml/... | http://biolink.github.io/biolinkml/... | Purpose | Example |
| :----------------------------------:  | :------------------------------------: | ------- | ------- |
| includes/types[.sfx] | includes/types[.sfx] | Language types (and other includes) (.sfx set by conneg if not already specified -- .ttl, .yaml, .owl, .shex, ...) | http://w3id.org/biolink/biolinkml/includes/types --> http://biolink.github.io/biolinkml/includes/types.yaml (Accept: text/yaml) |
| | | | http://w3id.org/biolink/biolinkml/includes/types --> http://biolink.github.io/biolinkml/includes/types (Accept: text/html) |
| type/[X][.sfx]  | docs/types/[X] | Access to metamodel type definitions w/ conneg | http://w3id.org/biolink/biolinkml/type/Bool --> http://biolink.github.io/biolinkml/docs/types/Bool |
| meta[.sfx] | meta[.sfx] | Access to Biolink meta models w/ conneg | http://w3id.org/biolink/biolinkml/meta --> http://biolink.github.io/biolinkml/meta.yaml (Accept: application/yaml) |
| | | |  http://w3id.org/biolink/biolinkml/meta.owl --> http://biolink.github.io/biolinkml/meta.owl (*What SHOULD we use for conneg for OWL/TTL?*) |
| meta/[X][.sfx] | docs/[X][.sfx] | Access to metamodel class and slot definitions w/ conneg | http://w3id.org/biolink/biolinkml/meta/Definition --> http://biolink.github.io/biolinkml/docs/Definition.jsonld (Accept: application/json) |
| context.jsonld | context.jsonld | metamodel context.jsonld for converting json instances to RDF | http://w3id.org/biolink/biolinkml/context.jsonld --> http://biolink.github.io/biolinkml/context.jsonld |

## Testing the rewrite rules

```bash
> cd httpd
> docker image build . -t http_test
> docker run --rm -d -p <port>:80 --name http_test http_test
> cd ../../..
> pipenv install
> pipenv shell
(biolinkml) > cd tests/test_rewrite_rules
(biolinkml) > export SERVER="http://localhost:<port>"
(biolinkml) > python test_rewrite_rules.py
ssssss
----------------------------------------------------------------------
Ran 6 tests in 0.000s

OK (skipped=6)
(biolinkml) > exit
> docker stop http_test
```

7. ** If necessary, make a pull request to w3id.org w/ changes **

repository: biolink/biolinkml

repo_name: biolink/biolinkml


text:
# Authentication

Broid API uses JSON Web Token (JWT).
This is an open standard ([RFC 7519](https://tools.ietf.org/html/rfc7519)) that defines a compact and self-contained way to transmit information securely between parties as a JSON object. Since this information is digitally signed, it can be verified and trusted. JWTs can be signed using a secret (with the HMAC algorithm) or a public/private key pair using RSA.

Let's explain some concepts of this definition further.
  - Compact: Because of its smaller size, JWTs can be sent through an URL, POST parameter, or inside an HTTP header. Additionally, the smaller size means transmission is fast.
  - Self-contained: The payload contains all the required information about the user, avoiding the need to query the database more than once.

A JWT is composed of a header, a payload, and a signature. The payload contains information called claims which describe the subject to whom the token was issued.
A JWT typically looks like the following: ``xxxxx.yyyyy.zzzzz``

*Your API keys carry many privileges, so be sure to keep them secret! Do not share your secret API keys in publicly accessible areas such GitHub, client-side code, and so forth.*

The authentication to the API is performed via **Authorization Bearer Header**.

!!! tip ""

 Example of an `Authorization` query

```bash
$ curl https://api.broid.ai/v1/status \
   -H 'Authorization: Bearer {JWT_TOKEN}'
```

repository: edroot/broid-docs

repo_name: edroot/broid-docs


text:
# Integration of internal and external gene expression and drug-perturbation data to empower novel immune therapies against Parkinson’s Disease

<!-- @import "[TOC]" {cmd="toc" depthFrom=2 depthTo=6 orderedList=false} -->

<!-- code_chunk_output -->

* [State of The Art](#state-of-the-art)
	* [ROGER Database](#roger-database)
		* [Annotation Problems:](#annotation-problems)
		* [RESTful APIs for scientific R pipelines](#restful-apis-for-scientific-r-pipelines)
	* [Gene Expression Analysis](#gene-expression-analysis)
		* [Methods for differential gene expression](#methods-for-differential-gene-expression)
		* [Methods for batch-effect correction in meta-analysis](#methods-for-batch-effect-correction-in-meta-analysis)
		* [Methods for gene-set/pathway enrichment analysis](#methods-for-gene-setpathway-enrichment-analysis)
* [References](#references)

<!-- /code_chunk_output -->

<!-- hey [see @fenner2012a]. -->

<!-- @import "chapters/sota.md" -->

## References

repository: RCBiczok/MasterThesis

repo_name: RCBiczok/MasterThesis