text:
# PHP Awesome Snippets - VScode extension

[![VScode](https://img.shields.io/badge/Extension-VScode-blueviolet.svg)](https://marketplace.visualstudio.com/items?itemName=hakcorp.php-awesome-snippets)
![Snippets](https://img.shields.io/badge/Type-Snippets-yellow.svg)
![PHP7](https://img.shields.io/badge/PHP-%5E7.0-blue.svg)
![PHP5](https://img.shields.io/badge/PHP-%5E5.4-blue.svg)
[![SemVer](https://img.shields.io/badge/SemVer-1.1.3-%23B71C1C.svg)](https://github.com/h4kst3r/php-awesome-snippets/blob/master/CHANGELOG.md)
[![MIT](https://img.shields.io/badge/License-MIT-%2300C853.svg)](https://github.com/h4kst3r/php-awesome-snippets/blob/master/LICENSE)

[![PSR-1](https://img.shields.io/badge/Standard-PSR--1-%2326A69A.svg)](https://www.php-fig.org/psr/psr-1/)
[![PSR-2](https://img.shields.io/badge/Standard-PSR--2-%2326A69A.svg)](https://www.php-fig.org/psr/psr-2/)
[![PSR-12](https://img.shields.io/badge/Standard-PSR--12-%2326A69A.svg)](https://github.com/php-fig/fig-standards/blob/master/proposed/extended-coding-style-guide.md)

**This [VScode extension](https://marketplace.visualstudio.com/items?itemName=hakcorp.php-awesome-snippets) provide a fullset of snippets for PHP devs. It's pretty simple !**

You can use it to avoid wasting time typing Class blocks, function signatures or other common PHP statements.

![Demo PHP Awesome Snippets](https://github.com/h4kst3r/php-awesome-snippets/raw/master/img/snipdemo.gif)

The code generated is **as compliant as possible** with [PSR-1](https://www.php-fig.org/psr/psr-1/), [PSR-2](https://www.php-fig.org/psr/psr-2/) and [PSR-12](https://github.com/php-fig/fig-standards/blob/master/proposed/extended-coding-style-guide.md) (*Review* stage) coding standards provided by [PHP-FIG](https://www.php-fig.org/).

Snippets are PHP7 oriented (type hinting and return type) but PHP5 compatibility is also provided (see [Functions](#function-snip) and [Methods](#method-snip) sections).

This work is inspired by PHPstorm (*PHP Live Templates*) and other works available on VScode marketplace like [PHP Snippets VS Code](https://github.com/heberalmeida/php-snippets) or [PHP Snippet Pack](https://github.com/jm-mwi/vscode-php-snippets/).

## Usage
Type a snippet (or part of it), press `Enter` or `Tab` (if `editor.tabCompletion` set to `true` in your settings) and the snippet will expand just right there.

> ***Tip :*** Snippets provided in this extension support `tab` to next/previous placeholder.

These snippets are meant to work in **PHP context** (VScode file). However there are also available in **Plain Text context** for convenience and PHP tags are available in **HTML** one.

## Features

These snippets try to be **as intuitive as possible** and to avoid conflicts with previous or built-in snippets.

Placeholders are quite *'easy to use'* though some need optimizations.
> ***Tip :*** If you want to use snippets and completion in placeholders
> look at the [Extension settings](#ext-settings) section.

----
### PHP tags

| Snippet | Output |
| --- | --- |
| php | `<?php ...?>` |
| po | `<?php...` |
| pc | `?>` |
| peco | `<?= ... ?>` |

----
### Superglobals

| Snippet | Output |
| --- | --- |
| gget | `$_GET["..."]` |
| gpost | `$_POST["..."]` |
| gss | `$_SESSION["..."]` |
| gfile | `$_FILES['...']['...']` |
| gcook | `$_COOKIE["..."]` |
| gser | `$_SERVER["..."]` |
| greq | `$_REQUEST["..."]` |
| genv | `$_ENV["..."]` |
| gglob | `$GLOBALS["..."]` |

----
### Arrays

| Snippet | Output |
| --- | --- |
| arr | `[value, value, ...];` |
| ark | `['key' => value, 'key' => value,...]` |
| kv | `'key' => value,` **[1]** |
| va | `value, ` **[1]** |

* **[1]** Addon snippet : use with `arr` or `ark` snippet to add `value` or `key => value` if needed.

----
### Statements and common functions calls

| Snippet | Output |
| --- | --- |
| eco | `echo "...";` |
| inc | `include __DIR__.'...';` |
| inco | `include_once __DIR__.'...';` |
| rqr | `require __DIR__.'...';` |
| rqro | `require_once __DIR__.'...';` |
| df | `define("...", "...");` |
| pr | `print_r(...);` |
| vd | `var_dump(...);` |
| vx | `var_export(...);` |

----
### Functions

| Snippet | Output |
| --- | --- |
| fn | `function func_name(Type $args): void {...}` |
| fna | `function (Type $args): void {...}` |
| fnu | `function (Type $args) use ($vars): void {...}` |

***Tip :*** You can call `functions` snippets above without type hinting and return type (**PHP5 compatibility**) by using **`-`** as prefix.
> * `-fna` for `function ($args) {...}` *(anonymous function block)*

----
### Control structures

| Snippet | Output |
| --- | --- |
| ifb | `if (condition) {...}` |
| ifel | `if (condition) {...} else {...}` |
| ifelif | `if (condition) {...} elseif (condition) {...} else {...}` |
| sw | `switch ($variable) { case 'label': ... break; ... default: ... break; }` |
| cs | `case 'label': ... break;` **[1]** |
| tern | `condition ? if_true : if_false;` |

* **[1]** Addon snippet : use with `sw` snippet to add `case` if needed.

***Tip :*** Other `if ... else` form is also available if needed:

> | Snippet | Output |
> | --- | --- |
> | ifen | `if (condition): ... endif;` |
> | ifelen | `if (condition): ... else: ... endif;` |
> | ifelifen | `if (condition): ... elseif (condition): ... else: ... endif;` |

----
### Loops structures

| Snippet | Output |
| --- | --- |
| fore | `foreach ($iterable as $item) {...}` |
| forek | `foreach ($iterable as $key => $item) {...}` |
| forl | `for ($i = 0; $i < $limit; $i++) {...}` |
| wl | `while ($variable <= $limit) {...}` |
| dowl | `do {...} while ($variable <= $limit);` |

***Tip :*** Other loops form is also available if needed:

> | Snippet | Output |
> | --- | --- |
> | foren | `foreach ($iterable as $item): {...} endforeach;` |
> | forenk | `foreach ($iterable as $key => $item): {...} endforeach;` |
> | forlen | `for ($i = 0; $i < $limit; $i++): {...} endfor;` |
> | wlen | `while ($variable <= $limit): {...} endwhile;` |

----
### Classes, interfaces and traits

| Snippet | Output |
| --- | --- |
| cl | `class ClassName {...}` |
| clx | `class ClassName extends MotherClass {...}` |
| cli | `class ClassName implements Interfaces {...}` |
| clxi | `class ClassName extends MotherClass implements Interfaces {...}` |
| in | `interface InterfaceName {...}` |
| inx | `interface InterfaceName extends Interfaces {...}` |
| trt | `trait TraitName {...}` |

***Tip :*** You can call `Class` snippets above with `abstract` or `final` form by using **`a`** or **`f`** as prefix.
> * `acl` for `abstract class ClassName {...}`
> * `fcli` for `final class ClassName implements Interfaces {...}`

----
### Methods

**Constructor**

| Snippet | Output |
| --- | --- |
| pubc | `public function __construct(Type $args) {...}` |
| proc | `protected function __construct(Type $args) {...}` |
| pric | `private function __construct(Type $args) {...}` |

**Method**

| Snippet | Output |
| --- | --- |
|| **Public methods** |
| pubf | `public function methodName(Type $args): void {...}` |
| pubsf | `public static function methodName(Type $args): void {...}` |
|| **Protected methods** |
| prof | `protected function methodName(Type $args): void {...}` |
| prosf | `protected static function methodName(Type $args): void {...}` |
|| **Private methods** |
| prif | `private function methodName(Type $args): void {...}` |
| prisf | `private static function methodName(Type $args): void {...}` |

***Tip :*** You can call `methods` snippets above with `abstract` or `final` form by using **`a`** or **`f`** as prefix.
> * `aprof` for `abstract protected function methodName(Type $args): void {...}`
> * `fpubsf` for `final public static function methodName(Type $args): void {...}`

***Tip :*** You can call `methods` snippets above without type hinting
and return type (**PHP5 compatibility**) by using **`-`** as prefix.
> * `-apubf` for `abstract public function methodName(parameters) {...}`

----
### Errors

| Snippet | Output |
| --- | --- |
| tryc | `try {...} catch (\Throwable $e) {...}` |
| tryf | `try {...} catch (\Throwable $e) {...} finally {...}` |
| cat | `catch (\Throwable $e) {...}` **[1]** |
| fy | `finally {...}` **[2]** |
| thr | `throw new SomeException("Error statement");` |

* **[1]** Addon snippet : use with `tryc` or `tryf` snippet to add `catch` if needed.
* **[2]** Addon snippet : use with `tryc` snippet to add `finally` if needed.

## Requirements

All you need is VScode installed on your machine.

* Install the extension from `Extensions` menu.

* You can also press `F1` then type:

    `ext install hakcorp.php-awesome-snippets`

## Extension Settings

The VScode default behavior deactivate IntelliSense suggestions when you're filling placeholders. However if you want to use completion and snippets inside placeholders :

* Open your settings.json file ( **{ }** icon at the top right corner of the settings tab).

* Add this line anywhere you want: `"editor.suggest.snippetsPreventQuickSuggestions": false`

Now you can call snippets and any suggestion in placeholders without typing `Ctrl+space`.

## Known Issues

If suggestions menu does not open, press `Ctrl+space` to open it manually.

Sometimes IntelliSense freezes loading or simply doesn't select the called snippet. Backspace and try again, it should work.

## Release Notes

All notable changes to this project will be documented in [CHANGELOG.md](https://github.com/h4kst3r/php-awesome-snippets/blob/master/CHANGELOG.md).

## License

[MIT](https://github.com/h4kst3r/php-awesome-snippets/blob/master/LICENSE) License

gha_language: C


text:
# Team documentation

MkTechDocs is ideal for incorporating team-contributed documentation. Because MkTechDocs documentation is simple Markdown, team members can contribute or edit documents via Git (for example) and let a single technical writer manage the pull requests to keep things as simple and as clear as possible.

This makes scaling documentation easier because the technical writer is no longer limited to his or her own domain knowledge or learned knowledge.

That's a simple case. The following describes a different scenario that lets agile developers contribute to documentation in a more specific and controlled way.

## Case study

In this study, a number of different agile development teams are responsible for individual components of a larger system. A configuration repository maintained by the larger system consists of a number of YAML files that describe the general deployment of each component.

Here, components could be Docker containers, VMs, micro-services, or whatever. Each component could have a different but similar set of deployment instructions for each category below, or it could simply conform to some generic set of instructions and require no extra documentation.

1. Overview
1. Environmental-setup
1. Pre-deployment
1. Deployment
1. Undeployment
1. Upgrading
1. Jenkins integration

Agile team members in this scenario are encouraged to contribute documentation in support of their respective components with those steps in mind. If they feel that specialized instructions for any of the above areas applies to their component, they should create a file in a provided directory within the documention tree that matches their component name in the configuration YAML. This file should contain a standalone Markdown document containing instructions specific for their component for that particular step. E.g. `overview/mycomponent.md`, `upgrading/mycomponent.md`.

For example, suppose a VM named `vm-inventory` exists in some YAML configuration file:

```yaml
location:
  description: >
	This is a sample description of a particular location
  vm-deployments:
         .
         .
         .
    vm-inventory:
      vm-config: vmi.cfg
      release: 1.234
      notes: Some notes about this particular VM
        .
        .
        .
```

Now, we can create a template that loads the YAML containing the list of components, and  looks for files with the same name in the directories listed above. If we find specialized instructions, we output them for a particular stage (e.g. Overview, Undeployment). If we find no specialized instructions, we output some generic ones.

## Managing git commit messages

Often, it is useful for your document's audience to understand what has changed from version to version. Rather than keeping track of this manually, in a "change log," for example, you can leverage Git's commit system.

The `git log` command shows a list of all commits to a respository. Each commit has a unique ID associated with it (SHA1 collisions not withstanding). This means that you can create "versions" by recording specific commit messages that represent the beginning and ending of a document version, pulling out all relevant commit messages dynamically when the document is built.

MkTechDocs includes this functionality in the `mktechdocslib.py` module. Here's an example of how to use it.

 First, we examine the output of `git log` to determine the first and last commit IDs that frame the version of the document we're interested in creating. Note that the output of `git log` is ordered by commit date, so the most recent dates appear first.

Here is a sample Git log:

```
commit 20de5c8bf2a53efe54a71ae06e5b0b2a813d5176
Author: Seidel, Joseph (js2589<EMAIL_ADDRESS>Date:   Tue Mar 7 08:04:25 2017 -0500

    Fixed several formatting issues

commit 3523b7f36d928519bba9568852babd793e783a7c
Merge: cd6c4bc f9b3edf
Author: Seidel, Joseph (js2589<EMAIL_ADDRESS>Date:   Tue Mar 7 06:50:53 2017 -0600

    Merge pull request #71 in FOO_BAR/foo.bar.documentation from feature/FOOBAR/FOOBAR to master

    * commit 'f9b3edfb5194a2be0456d26d742043677948d5ea':
      Added some notes about documentation formats

commit f9b3edfb5194a2be0456d26d742043677948d5ea
Author: Seidel, Joseph (js2589<EMAIL_ADDRESS>Date:   Mon Mar 6 16:21:17 2017 -0500

    Added some notes about documentation formats
```

From this, we determine that the first commit ID is `f9b3edfb5194a2be0456d26d742043677948d5ea` and the last commit ID is `20de5c8bf2a53efe54a71ae06e5b0b2a813d5176`.

Now, in a template.renderer, we can do something like this:

```python
#!/usr/bin/env python

import os
import sys
import datetime
import global_vars
from mktechdocslib import GitCommitDB, render_mktechdocs_jinja2_template

##
# Create a simple renderer function that ouputs a template passed in on the
# command line with the given variable dictionary.
#

def render():
	messages = GitCommitDB("f9b3edfb5194a2be0456d26d742043677948d5ea", "20de5c8bf2a53efe54a71ae06e5b0b2a813d5176").messages
	varDictionary = {"gitMessages":messages,
	                 "numCommits":len(messages)}

	if not os.path.isfile(sys.argv[1]):
		sys.stderr.write("Cannot find " + sys.argv[1] + "\n")
		sys.exit(1)

	print render_mktechdocs_jinja2_template(sys.argv[1], varDictionary)

if __name__ == "__main__":
	render()
```

Here, we import `GitCommitDB` from `mktechdocslib` and add the `GitCommitDB.messages` list object to our variable dictionary. `messages` contains a list of `GitCommitMessage` objects, which have the following properties:

| Property | Type | Description |
|-----------------|-----------|---------------------------------------------------|
| id              | String    | Commit ID |
| mergeID         | String    | Merge commit ID|
| author          | String    | Author of the commit|
| date            | String    | Commit date|
| message         | String    | Commit message|
| mergeCommit     | boolean   | True if the commit is a merge |

Finally, here's our template that displays the information we're interested in:

```
# Document change log

{{ openCurlyBracket }}% if numCommits == 0 %{{ closeCurlyBracket }}
Looks like no changes have been committed.
{{ openCurlyBracket }}% endif %{{ closeCurlyBracket }}

{{ openCurlyBracket }}% for m in gitMessages %{{ closeCurlyBracket }}

{{ openCurlyBracket }}% if not m.mergeCommit %{{ closeCurlyBracket }}
**Date**: {{ openCurlyBrackets }} m.date {{ closeCurlyBrackets }}<br />
**Author**: {{ openCurlyBrackets }} m.author {{ closeCurlyBrackets }}<br />
**Message**: {{ openCurlyBrackets }} m.message {{ closeCurlyBrackets }}<br />
{{ openCurlyBracket }}% endif %{{ closeCurlyBracket }}

{{ openCurlyBracket }}% endfor %{{ closeCurlyBracket }}
```

The version in the example above was hard coded. In reality, it would be better to keep track of version information in a list of tuples. For example:

**versions.py**:

```python
gVersions = [("1.0", "2017-04-06", "f9b3edfb5194a2be0456d26d742043677948d5ea", "20de5c8bf2a53efe54a71ae06e5b0b2a813d5176"),
             ("0.9", "2017-03-25", "d453519c024a49806fbd3a6740a9f0f586aaafbc", "57831131f186a60b864af27e53e06d2772a6d1ef")]
```

In this scheme, the latest version tuple would always be `gVersions[0]`. Or, if you prefer to store the versions in reverse order: `gVersions[len(gVersions)-1]`. Then, our renderer would look like this:

```python
#!/usr/bin/env python

import os
import sys
import datetime
import global_vars
from versions import gVersions
from mktechdocslib import GitCommitDB, render_mktechdocs_jinja2_template

##
# Create a simple renderer function that ouputs a template passed in on the
# command line with the given variable dictionary.
#

def render():
	(versString, date, fcid, lcid) = gVersions[0]

	messages = GitCommitDB(fcid, lcid).messages

	varDictionary = {"gitMessages":messages,
                     "numCommits":len(messages),
                     "versString":versString,
                     "date":date}

	if not os.path.isfile(sys.argv[1]):
		sys.stderr.write("Cannot find " + sys.argv[1] + "\n")
		sys.exit(1)

	print render_mktechdocs_jinja2_template(sys.argv[1], varDictionary)

if __name__ == "__main__":
	render()
```

repository: att/MkTechDocs

branch_name: refs/heads/master

extension: md

gha_language: Python

gha_license_id: NOASSERTION

license_type: permissive

repo_name: att/MkTechDocs


text:
JavaScript is unique amongst the C-like languages in that it doesn't require semicolons at the end of each statement. In many cases, the JavaScript engine can determine that a semicolon should be in a certain spot and will automatically add it. This feature is known as automatic semicolon insertion (ASI) and is considered one of the more controversial features of JavaScript. On the first line, the JavaScript engine will automatically insert a semicolon, so this is not considered a syntax error. The JavaScript engine still knows how to interpret the line and knows that the line end indicates the end of the statement. In the debate over ASI, there are generally two schools of thought. The first is that we should treat ASI as if it didn't exist and always include semicolons manually. The rationale is that it's easier to always include semicolons than to try to remember when they are or are not required.

```
//Bad:
var name = "ESLint"

//Good:
var website = "eslint.org";

```

[Source](http://eslint.org/docs/rules/semi)


text:
# KFData Demo

In this example, we'll train a PyTorch text classification model and then create a KFData inference pipeline for it with Kubeflow Pipelines and Pachyderm.

Requires:
- [docker](https://docs.docker.com/engine/install/)
- [testfaster](https://testfaster.ci)

## Get demo cluster

You'll need a [testfaster account](https://testfaster.ci/login), then get your [access token](https://testfaster.ci/access_token).

```
testctl login --token "<your token>"
testctl get # TODO make this notice ../.testfaster.yml
export KUBECONFIG=$(pwd)/kubeconfig
```

This cluster has Kubeflow 1.1 and Pachyderm 1.11 [preinstalled](../.testfaster.yml) on it.

## Deploy KFData to cluster

TODO (something like ../test.sh)

```
./build-and-deploy-kfdata.sh
```

## Train model

```
./train.sh
```

Will generate `example/output/model.pth`.

## Deploy pipeline

TODO

```
# Uploads the model we trained
./push-model-to-minio.sh

# Deploy the kfp pipeline that will do inference on new data
# TODO: how does kfp library connect to kubeflow cluster?
python inference_pipeline.py

# Push some data and see a Kubeflow pipeline triggered
./inject-data.sh

# Push some more data and see a Kubeflow pipeline triggered with only the
# incremental changes
./inject-more-data.sh
```

repository: pachyderm/kfdata

repo_name: pachyderm/kfdata


text:
# moxa-dio-control

`moxa-dio-control` is a C library for getting and setting Digital Input/Output
ports state.

## Build

This project use autotools as buildsystem. You can build this project by the following commands:

* If the build target architecture is x86_64

	```
	# ./autogen.sh --host=x86_64-linux-gnu --includedir=/usr/include/moxa --libdir=/usr/lib/x86_64-linux-gnu --sbindir=/sbin
	# make
	# make install
	```
* If the build target architecture is armhf

	```
	# ./autogen.sh --host=arm-linux-gnueabihf --includedir=/usr/include/moxa --libdir=/usr/lib/arm-linux-gnueabihf --sbindir=/sbin
	# make
	# make install
	```

The autogen script will execute ./configure and pass all the command-line
arguments to it.

repository: Moxa-Linux/moxa-dio-control

repo_name: Moxa-Linux/moxa-dio-control


text:
---
title: Build your first expertise
weight: 30
---
This page will walk you through the first phase of building your first expertise. You will create your expertise programmatically using the Watson Assistant Builder REST APIs that are accessible in Swagger API reference.

1. **How to run and use the "HelloWorld" boilerplate expertise hosted locally.**
2. How to register and use the local running "HelloWorld" expertise with Assistant Builder service.
3. How to host your "HelloWorld" expertise on Bluemix for others to use.

### Pre-requisite
Make sure you have already [setup your local development environment]({{site.baseurl}}/expertise/setup-local-dev-env/)

### Step 1: Fork the boilerplate
1. Go to  [https://github.com/Watson-Personal-Assistant/ExpertiseBoilerPlateRemote](https://github.com/Watson-Personal-Assistant/ExpertiseBoilerPlateRemote).
2. Click the gray **Fork** button in the top right corner.

### Step 2: Clone your fork of the boilerplate
1. Click the green **Clone or download** button.
2. Copy the `https` path.
3. Using the Terminal app, do command

    `git clone your-github-url`

### Step 3: Install the node dependencies
1. Change directory into your ExpertiseBoilerPlateRemote project directory

    `cd ExpertiseBoilerPlateRemote`

2. Install dependencies using command

    `npm install`

### Step 4: Run the expertise
Start the expertise using command

`npm run start`

### Step 5: Test the "HelloWorld" expertise by having a conversation
The Assistant Builder service Converse API allows you to have a conversation with your expertise.   You can test the expertise using a browser and the Swagger API reference page.  Send the "Hello" utterances in a request to the expertise.
1. Click link [http://localhost:10011](http://localhost:10011) to open browser to Swagger API reference.
2. Click on **Converse**.
3. Click on **/converse**.
4. Click the **Try it out!** button.
5. Click the **Execute** button.
6. Watson responds by saying "Hello world".  You can see the response in the returned JSON "text" attribute below. This response would be delivered by a client application like a chatbot.

```JSON
{
  "reject": false,
  "error": 200,
  "shouldEndSession": true,
  "captureInput": false,
  "speech": {
    "text": "Hello world"
  },
  "context": {
    "application": {
      "id": "app-001",
      "attributes": {}
    },
    "session": {
      "new": true,
      "attributes": {},
      "version": "1.0"
    }
  }
}
```

### Step 6: Use Swagger page to see which intents exist
In the last step, the JSON used to send "Hello" to the expertise also sent along the "intent".  This is required here because you are sending the utterance directly to an expertise, which isn't done in a Assistant application.  The Assistant Builder service of the IBM Assistant will take the utterance, determine the intent, and then send the intent and utterance on to the expertise.  The Assistant Builder service gets the intents from the expertise using the **/intents** API. To see this for yourself, do the following

1. Click link [http://localhost:10011](http://localhost:10011) to open browser to Swagger API reference.
2. Click on **Resources**.
3. Click on **/intents**.
4. Click the **Try it out!** button.
5. Click the **Execute** button.

Response:

```JSON
{
  "hello-world": {
    "visibility": "always",
    "entities": []
  }
}
```

### Finish
Now you have a working expertise and next you will have to register this expertise to Assistant Builder Assistant Builder service.  Text utterances requests are then sent to the Assistant Builder service to get a response from the registered hello world expertise.

 > **What next?** Learn how to [register and test a local expertise]({{site.baseurl}}/expertise/develop-locally/) using a Bluemix hosted Assistant Builder service

repository: KieranDolan/developer

repo_name: KieranDolan/developer


text:
## Dear ImGui bindings

D language bindings to C++ [Dear ImGui](https://github.com/ocornut/imgui) library.

Contains types & functions, with minimal amount of helper functions, one example is work around for inability to provide default values for **ref** parameters.

## Demo
There is ported official imgui OpenGL 3 demo that can be found in examples/basic_demo_gl3 folder.

You can build it using dub, it has pre-build step that downloads necessary stuff for you. (only Windows x64 builds is currently supported)

    cd examples/basic_demo_gl3
    dub build

> NOTE: depending on imgui build static vs dynamic version you might hit link error complaining about  "ImGuiTextBuffer::EmptyString", gentool have no idea how to handle statics from contexts, so when you link static imgui builds you have to edit __imgui_base.d__ file in struct `ImGuiTextBuffer`
and replace
`__gshared static public char[1] EmptyString;`
with
`__gshared static extern char[1] EmptyString;`
(notice that `public` becomes `extern`)

## Build and Usage

> **NOTE: imgui_base.d is no longer maintained as it can be generated using my binding generator called [gentool](https://github.com/Superbelko/ohmygentool)**

This is simply a bindings, it has no external dependencies. However to use in your code compiled imgui library is needed. There is simple CMake config included that simpifies the process.

Inside your project's dub.json just add this to dependencies section *(assuming imgui-d is added as a submodule)*, and import/static library as well.
```json
"dependencies": {
    "imgui-d": {"path": "path/to/bindings"}

    ...
},
"libs": ["imgui"]
```

#### Building the imgui:

1. Clone imgui repository
    ```
    cd folder/where/to/put/imgui
    git clone https://github.com/ocornut/imgui.git
    ```
1.  Copy provided CMakeLists.txt to that folder
1.  Generate the build files, for example for VS 2017 x64 DLL target
    ```
    cd imgui
    mkdir build_x64
    cd build_x64

    cmake -G"Visual Studio 15 2017 Win64" ../ -DCMAKE_WINDOWS_EXPORT_ALL_SYMBOLS=TRUE -DBUILD_SHARED_LIBS=TRUE
    ```
1.  Build it!
    ```
    cmake --build ./ --config RelWithDebInfo
    ```
1. Finally copy the resulting binaries to your application's binaries folder

*It is also possible to build and use as static library.

*Consult the CMake documentation for more information.*

---

## What it is?

Simply a bindings to imgui library. "Dear ImGui" is immediate-mode graphics API agnostic GUI library, it works by emitting geometry data to be rendered by your code.

## Why yet another bindings?

*Made it for my own needs, feel free to use if you like...*

## How it is done?

Originally it was semi-auto regex replace, but now it can be generated using my ```gentool``` binding generator.

Other than that it might be necessary to extract correct mangling for types that cannot be expressed in D *(such as head const types - i.e. ```float* const```, which is const pointer to mutable data and this doesn't makes sense in D)*, most of this is specific to Visual Studio C++ compiler.

license: MIT

repository: Superbelko/imgui-d

repo_name: Superbelko/imgui-d


text:
# hsim

Command Line Tool to generate simulated HTAN metadata.  The simulated metadata is packaged in JSON, and intended to help test new feature development of the HTAN Data Portal.

## Usage

To generate simulated HTAN Data, run:

    hsim generate example_output/sim.json --num_atlases 4

## Running Unit Tests

To run all unit tests:

    pytest

## MIT License

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.

repository: ncihtan/hsim

repo_name: ncihtan/hsim


text:
Project Title
Flexbox Cheat sheet for beginners

Getting Started
This project is created as part of the FlexBox for beginners course by Traversy Media.

Prerequisites
None

Built With
VS Code
Authors
Asha Vakkattil
Credits
Traversy Media - FlexBox CSS in 20 mintutes course
License
This project is licensed under the MIT License


text:
---
layout: post
title: "Installing Lightworks on Gentoo"
date: 2018-09-08 12:38:58
image: '/assets/img/lightworks/lightworks-3.jpg'
description: 'Lightworks is software for editing and mastering digital video in various formats, including resolutions.'
featured-img: ../lightworks/lightworks-3.jpg
tags:
- lightworks
- overlay
- ebuild
- gentoo
---

[Lightworks](https://www.lwks.com/) is software for editing and mastering digital video in various formats, including resolutions. The program is currently available for Windows, Linux and Mac OS. The development of an open source version was announced in May 2010. No source code for the program has been released yet.

In this tutorial we will see the steps to install in **Gentoo**, since it is not in the official **Portage** repository.

First you need to log in as root or use sudo to clone the repository with Git.

{% highlight bash  %}
git clone https://github.com/terroo/lightworks.git /usr/portage/media-video/lightworks
{% endhighlight  %}

Then we will enter the cloned repository and we will run the command to run ebuild.

{% highlight bash  %}
cd /usr/portage/media-video/lightworks
ebuild lightworks-14.5-r11.ebuild manifest clean merge
{% endhighlight  %}

And then we ran the command with emerge to install Lightworks:

{% highlight bash  %}
emerge lightworks
{% endhighlight  %}

As this is an unofficial ebuild, it will probably ask you to update your `/etc`, then run the command below and then install again

> In this case I'll use the `-a` parameter for Portage to ask us if you want to continue

![Lightworks on Gentoo](/assets/img/lightworks/lightworks-1.jpg "Lightworks on Gentoo")

{% highlight bash  %}
etc-update --automode -5
emerge -a lightworks
{% endhighlight  %}

![Lightworks on Gentoo](/assets/img/lightworks/lightworks-2.jpg "Lightworks on Gentoo")

See too: <https://bugs.gentoo.org/468204>

Enjoy!


text:
+++
title = "aws_apigateway_client_certificates Resource"
platform = "aws"
draft = false
gh_repo = "inspec-aws"

[menu.inspec]
title = "aws_apigateway_client_certificates"
identifier = "inspec/resources/aws/aws_apigateway_client_certificates Resource"
parent = "inspec/resources/aws"
+++

Use the `aws_apigateway_client_certificates` InSpec audit resource to test properties of multiple AWS API Gateway client certificates.

The `AWS::ApiGateway::ClientCertificate` resource creates a client certificate that API Gateway uses to configure client-side SSL authentication for sending requests to the integration endpoint.

For additional information, including details on parameters and properties, see the [AWS documentation on AWS API Gateway client certificate.](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-apigateway-clientcertificate.html).

## Installation

{{% inspec_aws_install %}}

## Syntax

Ensure that the client certificate exists.

```ruby
describe aws_apigateway_client_certificates do
  it { should exist }
end
```

## Parameters

This resource does not require any parameters.

## Properties

`client_certificate_ids`
: The identifier of the client certificate.

: **Field**: `client_certificate_id`

`descriptions`
: The description of the client certificate.

: **Field**: `description`

`pem_encoded_certificates`
: The PEM-encoded public key of the client certificate, which can be used to configure certificate authentication in the integration endpoint .

: **Field**: `pem_encoded_certificate`

`created_dates`
: The timestamp when the client certificate was created.

: **Field**: `created_date`

`expiration_dates`
: The timestamp when the client certificate will expire.

: **Field**: `expiration_date`

`tags`
: The collection of tags. Each tag element is associated with a given resource.

: **Field**: `tags`

## Examples

**Ensure a client certificate ID is available.**

```ruby
describe aws_apigateway_client_certificates do
  its('client_certificate_ids') { should include 'CLIENT_CERTIFICATE_ID' }
end
```

**Ensure a PEM encoded certificate is available.**

```ruby
describe aws_apigateway_client_certificates do
    its('pem_encoded_certificates') { should include 'PEM_ENCODED_CERTIFICATE' }
end
```

## Matchers

{{% inspec_matchers_link %}}

The controls will pass if the `get` method returns at least one result.

### exist

Use `should` to test that the entity exists.

```ruby
describe aws_apigateway_client_certificates do
  it { should exist }
end
```

Use `should_not` to test the entity does not exist.

```ruby
describe aws_apigateway_client_certificates do
  it { should_not exist }
end
```

## AWS Permissions

{{% aws_permissions_principal action="APIGateway:Client:ClientCertificates" %}}

repository: inspec/inspec-aws

branch_name: refs/heads/main

gha_language: Ruby

repo_name: inspec/inspec-aws


text:
## Photo Painter
Original Image is feed as input and the output is painted in every 20 iterations. With iterations the parameters are tuned to better and the output resembles more and more to input image.It uses Tensorflow for image creation and cv2 for loading, resizing, saving image and numpy for matrix manupulation.

#### Original Image
![jack photo](/Photo%20Painter/screenshots/jack.jpg)

#### Painted Image
![gif of output](/Photo%20Painter/screenshots/output.gif)

path: /Photo Painter/readme.md


text:
# Deployments

Create the deployment object:

    kubectl apply -f manifests/deployment.yaml

Get the state of the deploloyment:

    kubectl get deployments
    kubectl describe deployment kuard-deployment

## Observing the change to our Pods

In a termial window, observe the state change to the list of pods. We're going to keep this around for this entire lab.

    kubectl get pods --watch

## Scale our pods using Deployments

Update `spec.replicas` in `deployment.yaml` to be `5`, then deploy our changes:

    kubectl apply -f manifests/deployment.yaml

Notice the old pods don't get deleted straight away. This is because of `spec.minReadySeconds` value of 30 seconds.

Update `spec.replicas` in `deployment.yaml` to be `20`, then deploy our changes. Did all of the Pods come up? Let's go checkout the Kubernetes dashboard.

Update `spec.replicas` in `deployment.yaml` to be `2` again.

## Deploy a new version of the kuard container

Update your `deployment.yaml` file, changing the image tag to `2` and adding the following under `spec.template.metadata` in order to provide a reason for the manifest change. This is something that would be template driven by your CD system.

    annotations:
        kubernetes.io/ change-cause: 'Upgraded to version 2.'

Then apply your change:

    kubectl apply -f manifests/deployment.yaml

Observe the deployment history:

    kubectl rollout history deployment/kuard-deployment

## Debugging Tip: Isolating a pod or pods from a ReplicaSet

If a pod pods begin misbehaving, you may not want it to be killed, as you may want to quarantine it (take it out of service) in order to inspect it figure out what went wrong.

To do this, you can change or overwrite the labels (depending upon the replicaset label selector).

Let's take one of the deployment pods out of service.

    # Get a pod name
    kubectl get pods

    # Take it out of service by changing its label
    # NOTE: Changing the label value is only to disassociate it the
    replicaset and service. It has nothing to do with the actual health of the pod and Kubernetes does not care about the value.

    kubectl label pods kuard-deployment--<ID> --overwrite app=kuard-quarantined.

This will cause Kubernetes to disassociate that pod with the deployment which in turn, will cause Kubernetes to create a new pod.

As the renamed pod is now unmanaged, you can exec into it without fear of it being killed.

## Cleanup

We can easily cleanup all of the resources in these labs by telling Kubernetes to delete all of the resources found in the `manifests` directory.

    kubectl delete -f manifests/

It's ok that some of these were not found.

Hope you enjoyed these labs!


text:
---
speaker: Pooja Singla (IISc Mathematics)
title: "Gelfand's criterion and multiplicity one results"
date: 12 October, 2018
time: 3 pm
venue: LH-1, Mathematics Department
series: "Algebra & Combinatorics Seminar"
website: http://www.math.iisc.ac.in/~khare/algcomb18-19.html
---

We will describe Gelfand's criterion for the commutativity of
associative algebras and discuss some of its applications
towards the multiplicity one theorems for the representations
of finite groups.

repository: siddhartha-gadgil/DeptWeb

gha_language: HTML

gha_license_id: MIT

repo_name: siddhartha-gadgil/DeptWeb


text:
# simple-jekyll-theme

## Development Getting Started
1. Install Ruby Gems
2. Install jekyll and bundler
```
gem install jekyll bundler
```
3. Start Local Jekyll server
```
bundle exec jekyll serve
```
or npm start when executes the above command line arguments
```
npm start
```

## TO USE AS A Remote Theme :
[Remote Theme Plugin](#)

Add this line to your Jekyll site's `_config.yml`:

```yaml

plugins:
  -jekyll-remote-theme

remote theme: patomation/simple-jekyll-theme

```
Add this to gem tile:
```
gem "jekyll-remote-theme"
```

## Installation

Add this line to your Jekyll site's `Gemfile`:

```ruby
gem "simple-jekyll-theme"
```

And add this line to your Jekyll site's `_config.yml`:

```yaml
theme: simple-jekyll-theme
```

And then execute:

    $ bundle

Or install it yourself as:

    $ gem install simple-jekyll-theme

## Contributing

Bug reports and pull requests are welcome on GitHub at https://github.com/patomation/hello. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.

## Development

To set up your environment to develop this theme, run `bundle install`.

 To test your theme, run `bundle exec jekyll serve` and open your browser at `http://localhost:4000`. This starts a Jekyll server using your theme. Add pages, documents, data, etc. like normal to test your theme's contents. As you make modifications to your theme and to your content, your site will regenerate and you should see the changes in the browser after a refresh, just like normal.

When your theme is released, only the files in `_layouts`, `_includes`, `_sass` and `assets` tracked with Git will be bundled.
To add a custom directory to your theme-gem, please edit the regexp in `simple-jekyll-theme-temp.gemspec` accordingly.

## License

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

repository: patomation/simple-jekyll-theme

gha_language: CSS

repo_name: patomation/simple-jekyll-theme


text:
# Securing AKS With Azure RBAC

## Introduction

During the workshop, you used a global permission to access and make changes to the cluster. In production clusters, it is recommended that **role-based access control (RBAC)** is used to only allow limited access to users that they need to complete their jobs using the **Principle of least privilege (PoLP)**. In this section, we will configure RBAC and integrate it with **Azure Active Directory (AAD)**. This will ensure that the organization policies applied to AAD would also be effective for users accessing the cluster. This is an important topic because it helps restrict access by attackers and unintentional downtime due to accidental deletion or modification of resources in the cluster.

This is generally safer than using a different address space for users in AKS which is the default. In this section we will be completing the following:

1. Creating a user and user group in AAD connected to the cluster
1. Configuring RBAC in AKS
1. Disable local accounts
1. Configure conditional access
1. Configure just-in-time cluster access

> Note that for this section, you need to be using an Azure tenant with AAD instance where you have global administrator permissions. If you don't have one, please create [a free account here](https://azure.microsoft.com/en-ca/free/search/?OCID=AID2100017_SEM_64fae88fcd6f1197e6ee88294daa302c:G:s&ef_id=64fae88fcd6f1197e6ee88294daa302c:G:s&msclkid=64fae88fcd6f1197e6ee88294daa302c) and deploy an AKS cluster before preceding. It doesn't have to be the AKS workshop cluster.

In Kubernetes RBAC there are three important concepts

1. **Role** is a set of permissions for example, get, watch, list. It defaults to no permissions and every permission needs to be explicitly added and is restricted to a specific namespace
2. **Subject** is either the person or service principal that is assigned the role
3. **Role binding** links a subject to a rule in a specific namespace

Cluster roles and cluster role bindings work similarly except they provide permission across all namespaces in the cluster. In this workshop you will be skimming through the process of securing AKS with Azure RBAC. For more details about how to do this please check out Chapter 8 of the third edition of the free book, [Hands-on Kubernetes on Azure](https://aka.ms/handson-aks-book).

## Enabling AAD integration in your AKS Cluster

In this section we will be creating a user group and enabling Azure AD integration with the AKS cluster. Once a cluster has been integrated with Azure AD, this functionality cannot be disabled.

### Create an AAD Group

1. Search for AAD in the top search bar and select Azure Active Directory

1. In the left plane, select **Groups**

1. Click **+ New Group** at the top

1. In the next page create a security group and give it a name and description. Select your user as the owner and a member of this group. Click **Create** button at the bottom of the screen

1. With the group now created, search for your aks cluster and select it

1. In the pane to the left select **Cluster configuration** under **Settings**

1. Enable **AKS-managed Azure Active Directory**

1. Click **+ Add Azure AD groups as administrators on this cluster**

1. Find the user group you just created and select it

1. Click select at the bottom

1. Click **Save** at the top of the screen

    ![add usergroup to cluster](pictures/add-usergroup-to-cluster.PNG)

### Create a user and group assignment in AAD

In this section you will create a user that you will assign permissions to for your AKS cluster

1. Type AAD in the search bar at the top of the screen and select Azure Active Directory

1. Click on **Users** in the left pane

1. Click on **+ New user** at the top of the resulting screen

1. Provide information about the user including the username. Note down the password and click **Create**

1. Now that the user is created go back to the AAD pane and select **Groups** then click on **+ New group**

1. Enter details about this new user group and add the newly created user as a member of the group

1. Head back to your cluster following the same steps above

1. Click on **Access control (IAM)** in  the left pane then click **+ Add** button and select **Add role assignment**

1. In the resulting pane select **Azure Kubernetes Services Cluster User Role** for the **Role** field and then select your new user in the **Select** field then click **Save**

This concludes setting up AAD RBAC for the cluster.

### Grant User group Access to Storage Account

In this section we will create a storage account to test our RBAC

1. Type *storage* in the search bar at the top of the screen in Azure Portal and select **Storage accounts**

1. Click on the resource group that starts with **cloud-shell-storage**

1. Select **Access control (IAM)** in the resulting pane then click **+ Add**

1. Select **Storage Account Contributor** to the role field and then select the user group you just created for your the user you created

### Configure RBAC in AKS

We begin by setting up our terminal we need to begin by completing the following steps. Setup environment variables and get credentials for your AKS cluster if you haven't already.

```bash
REGION_NAME=eastus
RESOURCE_GROUP=aksworkshop
SUBNET_NAME=aks-subnet
VNET_NAME=aks-vnet
AKS_CLUSTER_NAME=<cluster name>
AKS_CLUSTER_NAME=aksworkshop-12320
```

```bash
az aks get-credentials \
--resource-group $RESOURCE_GROUP \
--name $AKS_CLUSTER_NAME
```

Clone the repository we will be using if you haven't already.

```bash
git clone https://github.com/mosabami/aks-adv-workshop-yaml-files
cd ./aks-adv-workshop-yaml-files/rbac-yaml-files
```

Next we will create two namespaces and deploy applications onto them to test out RBAC in AKS

Get the group ID of the group you created for users and save it in a variable

```bash
USER_GROUP_ID=$(az ad group show -g 'aksworkshop users' \
--query objectId -o tsv)
```

Next we create the namespaces

```bash
kubectl create ns no-access
kubectl create ns delete-access
```

Next we deploy the azure-vote application in both namespaces

```bash
kubectl create -f azure-vote.yaml -n no-access
kubectl create -f azure-vote.yaml -n delete-access
```

Next you create the ClusterRole object

```bash
kubectl create -f clusterRole.yaml
```

Next create the ClusterRoleBinding object. You will need to modify the *clusterRoleBinding.yaml* file and add your user group id to the name parameter at the bottom of the file. Start by copying the user group ID

```bash
echo $USER_GROUP_ID
```

Copy the user ID and open the file to modify it

```
code clusterRoleBinding.yaml
```

Modify the file and replace the "<group-id>" field with your user group id. Save the file and exit to the terminal.

```bash
kubectl create -f clusterRoleBinding.yaml
```

Next you will create a role that is limited to the delete-access namespace. This will allow the user delete pods within the delete-access namespace. This time we are defining a role as opposed to the ClusterRole that was created in the previous steps

```bash
kubectl create -f role.yaml
```

Finally we will be creating a role binding  to link the delete access role to the user we just created. This file also needs to be modified.

```bash
code roleBinding.yaml
```

This time replace the <user e-mail address> with the email address of the user you created. This shows how to bind a role to a user as opposed to a user group. Save the file and exit to the terminal.

Next create the role binding

```bash
kubectl create -f roleBinding.yaml
```

This concludes setting up roles and role bindings for this new user with limited access to managing resources in the cluster. In the next section we will test it out.

## Disable Local Accounts

When deploying a cluster, local accounts are enabled by default. Even when enabling RBAC or Azure Active Directory integration, `--admin` access still exists, essentially as a non-auditable **backdoor** option. For added security, AKS offers the ability to disable local accounts via a flag, `disable-local`.

To use an AKS cluster without local accounts, you must enable the `DisableLocalAccountsPreview` feature flag on your subscription.

Before we start, try logging in with the `--admin` flag to show that the default cluster has it enabled.

```bash
az aks get-credentials --resource-group $RESOURCE_GROUP --name $AKS_CLUSTER_NAME --admin
```

You should see a response similar to the picture below

At the time of writing this, this feature was in preview. Run the command below to enable this preview feature.

```bash
az feature register --namespace "Microsoft.ContainerService" --name "DisableLocalAccountsPreview"
```

Wait for the feature to be registered which would take a few minutes. You can check the status by running the following command.

```bash
az feature list -o table --query "[?contains(name, 'Microsoft.ContainerService/DisableLocalAccountsPreview')].{Name:name,State:properties.state}"
```

After a few minutes, you should see the registered status looking similar to this:

When it is ready, refresh the registration of the *Microsoft.ContainerService* resource provider using the [az provider register](https://docs.microsoft.com/cli/azure/provider#az_provider_register) command:

```bash
az provider register --namespace Microsoft.ContainerService
```

Finally we disable local accounts in our existing cluster.

```bash
az aks update -g $RESOURCE_GROUP -n $AKS_CLUSTER_NAME --disable-local
```

Your output should include the following:

```json
"properties": {
    ...
    "disableLocalAccounts": true,
    ...
}
```

Now attempt to get admin credentials again and this request should fail.

```
az aks get-credentials --resource-group $RESOURCE_GROUP --name $AKS_CLUSTER_NAME --admin
```

You can re-enable it using the following command.

```bash
az aks update -g $RESOURCE_GROUP -n $AKS_CLUSTER_NAME --enable-local
```

Your output should include the following:

```json
"properties": {
    ...
    "disableLocalAccounts": false,
    ...
}
```

## Test RBAC in AKS

In this section we will test out our RBAC.

1. If you are using a terminal, open a new terminal. If you are using Azure cloud shell, log into the Azure portal in a different browser (or InPrivate window of the same browser) using the user you created's credentials.

1. Enter the following to log into the correct tenant **as the user you just created**. Follow the instructions to get logged into the account.

   ```bash
   az login -t <tenant id>
   ```

1. Enter the following to log into your Kubernetes cluster

   ```
   REGION_NAME=eastus
   RESOURCE_GROUP=aksworkshop
   SUBNET_NAME=aks-subnet
   VNET_NAME=aks-vnet
   AKS_CLUSTER_NAME=<cluster name>
   az aks get-credentials -n $AKS_CLUSTER_NAME -g $RESOURCE_GROUP
   ```

1.  This means that RBAC is working since this user was only configured to have access to pods.

1. Ensure your user has access to view all pods

   ```bash
   kubectl get pods -n no-access
   kubectl get pods -n delete-access
   ```

   ![successful pod access](pictures/successful-pod-access.PNG)

1. Check to see that your user has permission to delete pods in the delete-access namespace based on our defined roles and rolebindings. You will find that you have permission to based on the configuration deployed earlier

   ```bash
   kubectl delete pod --all -n delete-access
   ```

   ![allow delete access](pictures/allowed-delete-access.PNG)

1. Let us test delete permissions to delete pods in the no-access namespace. You will find that you do not have permission because there was no role permission defined in that namespace. It denies access by default until a permission is explicitly configured.

   ```
   kubectl delete pod --all -n no-access
   ```

   ![disallow no access](pictures/disallowed-no-access.PNG)

In this section, you verified the functionality of RBAC in AKS clusters.

## Use Conditional and JIT Access with Azure AD

To further enhance the security of your cluster you can use Azure AD with conditional access and Azure AD with just in time access. These options require Azure AD Premium capability. For more details click on the links below:

* [Conditional Access](https://docs.microsoft.com/azure/aks/managed-aad#use-conditional-access-with-azure-ad-and-aks)
* [Just in time Access](https://docs.microsoft.com/azure/aks/managed-aad#configure-just-in-time-cluster-access-with-azure-ad-and-aks)

## Cleanup

Now we go ahead and decommission the workloads. Run the following commands with your main user account that has all the required access.

```bash
kubectl delete -f azure-vote.yaml -n no-access
kubectl delete -f azure-vote.yaml -n delete-access
kubectl delete -f .
kubectl delete ns no-access
kubectl delete ns delete-access
```

## Next step

:arrow_forward: [Security with AAD pod-managed identities](../Security-with-AAD-pod-managed-identities/README.md)

repository: phenixita/aks-levelup

repo_name: phenixita/aks-levelup


text:
# Generative Models

Tensorflow 2.0 implementation of generative models, e.g. VAE, GAN

## Tutorial

- [Tutorial: Deriving the Standard Variational Autoencoder (VAE) Loss Function (2019)](https://arxiv.org/pdf/1907.08956.pdf)
- [An Introduction to Variational Autoencoders (2019)](http://arxiv.org/abs/1906.02691)
- [Tutorial on Variational Autoencoders (2016)](http://arxiv.org/abs/1606.05908)
- [Implementing Variational Autoencoders in Keras: Beyond the Quickstart Tutorial](http://louistiao.me/posts/implementing-variational-autoencoders-in-keras-beyond-the-quickstart-tutorial/)
- [Gaussian mixture VAE: lessons in Variational Inference, Generative models, and Deep Nets](http://ruishu.io/2016/12/25/gmvae/)

## Implementation

- Conditional convolutional auto-encoder, [tensorflow code](./models/conv_cae.py)
- [Auto-Encoding Variational Bayes (2013)](https://arxiv.org/pdf/1312.6114.pdf), [keras code](./models/vae.py)
- [Conditional variational auto-encoder (CVAE) (2015)](https://papers.nips.cc/paper/5775-learning-structured-output-representation-using-deep-conditional-generative-models.pdf), [keras code](./models/conditional_vae.py), [tensorflow code](./models/conv_cvae.py)
- [Adversarial autoencoders (2015)](https://arxiv.org/abs/1511.05644), [keras code](./models/aae.py), [tensorflow code](./models/conv_aae.py)
- [Sparse autoencoder (Andrew Ng)](https://web.stanford.edu/class/cs294a/sparseAutoencoder.pdf), [keras code](./models/sparse_ae.py)
- Variational Auto Encoder with a Concrete latent distribution, [The Concrete Distribution: A Continuous Relaxation of Discrete Random Variables](https://arxiv.org/abs/1611.00712) or [Categorical Reparameterization with Gumbel-Softmax](https://arxiv.org/abs/1611.01144), [keras code](./models/concrete_vae.py)

## Other's Collections

- [pytorch-generative-model-collections](https://github.com/znxlwm/pytorch-generative-model-collections)
- [Generative Models Tutorial with Demo](https://github.com/omerbsezer/Generative_Models_Tutorial_with_Demo)
- [GauravBh1010tt/DL-Seq2Seq](https://github.com/GauravBh1010tt/DL-Seq2Seq)
- [The implementation of the VAE and Gaussian Mixture VAE](https://github.com/psanch21/VAE-GMVAE)
- [Unsupervised clustering with (Gaussian mixture) VAEs](https://github.com/RuiShu/vae-clustering)

## Some Papers

### VAE

> Sequence

- [Generating Sentences from a Continuous Space (2015)](https://arxiv.org/pdf/1511.06349.pdf)
- [Disentangled Sequential Autoencoder (2018)](https://arxiv.org/abs/1803.02991)

### GAN

- Generative models are also promising in the long term future because it has a potential power to learn the natural features of a dataset automatically.

- Generative models are mostly used to generate images (vision area). In the recent studies, it will also used to generate sentences (natural language processing area).

> Image

- [Generative Adversarial Networks (2014)](https://arxiv.org/abs/1406.2661)
- [Conditional GANs (2014)](https://arxiv.org/abs/1411.1784)
- [DCGAN (2015)](https://arxiv.org/abs/1511.06434)
- [Improved Techniques for Training GANs (2016)](https://arxiv.org/abs/1606.03498)
- [Pix2Pix (2016)](https://arxiv.org/abs/1611.07004)
- [StackGAN (2016)](https://arxiv.org/abs/1612.03242)
- [CycleGAN (2017)](https://arxiv.org/abs/1703.10593)
- [Improved Training of Wasserstein GANs (2017)](https://arxiv.org/abs/1704.00028)
- [Progressively Growing GANs (2017)](https://arxiv.org/abs/1710.10196)
- [BigGAN (2018)](https://arxiv.org/abs/1809.11096)
- [StyleGAN (2018)](https://arxiv.org/abs/1812.04948)

> Sequence

- [SeqGAN: Sequence Generative Adversarial Nets with Policy Gradient (2016)](https://arxiv.org/abs/1609.05473)

### Representation Learning

- [A Neural Representation of Sketch Drawings (2017)](https://arxiv.org/abs/1704.03477)
- [Deep InfoMax (2018)](https://arxiv.org/abs/1808.06670)
- [Neural Discrete Representation Learning (2017)](https://arxiv.org/pdf/1711.00937.pdf)

repository: ifding/generative-models

repo_name: ifding/generative-models


text:
docker-nginx-php-fpm
=================

[![](https://badge.imagelayers.io/houseofagile/docker-nginx-php-fpm:latest.svg)](https://imagelayers.io/?images=houseofagile/docker-nginx-php-fpm:latest 'Get your own badge on imagelayers.io')

* Simple docker containers for projects based on php
* based on nginx and php-fpm
* support for bash-profile
* Build with docker-apps generator

## Build image

Use build.sh script to generate the various versions.

## pull image from docker hub

Images should be retrieved from docker hub.
## How to launch  a docker instance with nginx and php-fpm

Use either docker compose or Dockerfile to configure your docker instance, here is a simple example :

    FROM houseofagile/docker-nginx-php-fpm:php7.4

    # add your files
    ADD ./config/projects /root/projects
    ADD ./config/ssh-keys /root/ssh-keys
    ADD ./config/sm-config /root/.symfony-manager/sm-config

    EXPOSE 80
    CMD ["/sbin/my_init"]

Build your docker image:

    docker build -t "someorg/someproject:v1" .

You could add some postinstall scripts to customize your image to your need, basically it only provide a base phusion image with php5-fpm and nginx.

repository: HouseOfAgile/docker-nginx-php-fpm

repo_name: HouseOfAgile/docker-nginx-php-fpm


text:
[![Docker Cloud Build Status Frontend](https://img.shields.io/docker/cloud/build/flaxo/frontend.svg?label=frontend)](https://hub.docker.com/r/flaxo/frontend)
[![Docker Cloud Build Status Backend](https://img.shields.io/docker/cloud/build/flaxo/backend.svg?label=backend)](https://hub.docker.com/r/flaxo/backend)
[![Docker Cloud Build Status data2graph](https://img.shields.io/docker/cloud/build/flaxo/data2graph.svg?label=data2graph)](https://hub.docker.com/r/flaxo/data2graph)

Flaxo is distributed as a set of docker images. Each release or pre-release should have a corresponding docker images
pushed to DockerHub.

## Repositories

- backend server, [flaxo/backend](https://hub.docker.com/r/flaxo/backend)
- web client server, [flaxo/frontend](https://hub.docker.com/r/flaxo/frontend)
- data2graph tool, [flaxo/data2graph](https://hub.docker.com/r/flaxo/data2graph)

## Autobuild

Flaxo DockerHub repositories are configured to autobuild Flaxo versions.
Each time a new version of the Flaxo platform is pushed to the repository then an automated build is triggered.
*Flaxo version is basically a git tag.*

repository: tcibinan/flaxo

branch_name: refs/heads/dev

gha_language: Kotlin

repo_name: tcibinan/flaxo


text:
# NieuwpoortseVistival
End term assignment for Festival in Nieuwpoort

Author: H3AR7B3A7

Property of: Erasmus highschool of Bruxelles

The assignment was to create an app for a festival in Nieuwpoort.
The app had to have a map for people to find their way and a program of artists playing at the festival.
Several other functionalities could only improve our mark once the MVP had been met.
We had about 3 days to present the results.

This was an early introduction to Swift in xCode and in no way represents what a real commercial app should look like.

Special thanks to: Swasse

## License & copyright

© H3AR7B3A7

Department Design & Technologie of the Erasmus Highschool in Brussels

Licensed under the [Apache license](LICENSE).


text:
This example shows how a Pod accesses configuration data from the ConfigMap by reading from a file in a directory of the container. Upon startup, the application would reference these parameters by referencing the named files in the known directory.

View the resource definition.

`ccat consume-via-vol.yaml`{{execute}}

Create the Pod.

`kubectl apply -f consume-via-vol.yaml`{{execute}}

Using the [Dashboard](https://[[HOST_SUBDOMAIN]]-30000-[[KATACODA_HOST]].environments.katacoda.com/), inspect the Pod log and information page to see mapped data.

repository: litmusbot/katacoda-courses

repo_name: litmusbot/katacoda-courses


text:
# Xerock Mesh

**Xerock Mesh** is a firmware to [ESP32 devices](http://espressif.com/en/products/hardware/esp32/resources), implementing a mesh network. It was intended to be used with the **Xerock Procjet**. To know more:

* *Daemon*: [https://github.com/rnascunha/xerock](https://github.com/rnascunha/xerock);

* *Interface*: [https://github.com/rnascunha/xerock_web](https://github.com/rnascunha/xerock_web);

* *Website*: [https://rnascunha.github.io/xerock](https://rnascunha.github.io/xerock).

## Compile and flash

To configure, compile and flash the firmware to your device, first install the IDF toolchain as explained [here](https://docs.espressif.com/projects/esp-idf/en/latest/esp32/get-started/index.html).

 It's mandatory to set:

* **Router SSID**: your local router SSID;

* **Router password**: your local router password;

* **TCP Server IP**: the server IP that the mesh border router will connect;

* **TCP Server Port**: the server port that the mesh border router will connect;

Other facultative options are:

* **Enable DS**: set the configuration of external devices at the nodes (not very well explained, I know);

* **Enable root conflic**: if enabled, more than one device can connect to the server;

* **Mesh Topology**: the topology of the mesh network.

Other options are internal of the mesh network. If you don't know how to set, or how it will impact the network, just leave it at the default values.

Build and flash all devices that will be used:

```
$ idf.py build flash

#Or if you need to set the <port>

$ idf.py -p <port> build flash
```

Access [Xerock](https://rnascunha.github.io/xerock) and open sockets at *TCP Server App* accordingly how you set **TCP Server IP** and **TCP Server Port** parameters. Run the **ESP32 Mesh** script and turn on the devices. If everything was setup right, they must connect shortly.

## Custom firmware

The default firmware provided at this project, together if the [Xerock Website](https://rnascunha.github.io/xerock), will setup the network. But if you try to send any data to any device with this firmware, it will only echo it back. Not much use.

To make your own custom response, you must implement the following method:

```
namespace Mesh{
	node_data_handler(Node_Header* header, uint8_t* payload, uint8_t* buffer, void* arg);
}//Mesh
```

Where:

* **header**: received header (check *Node_Header* implmentation at `mesh/node_types.hpp`;

* **payload**: data payload received (random bytes);

* **buffer**: buffer reserved to be used;

* **arg**: argument set with `Node::fromds_cb_arg(void*)` function;


text:
forestPad
=========

An outliner that allows to organize a group of documents using one or more indexes (trees).

![Mockup]
(https://raw.githubusercontent.com/rodrigoreyes79/forestpad/master/images/mockup.png)

**IMPORTANT**: This is an early preview. Still needs lots of work.

![Early preview image]
(https://raw.githubusercontent.com/rodrigoreyes79/forestpad/master/images/forestpad.png)

## Why another outliner?

I am scratching my own itch here. I am creating a tool I am comfortable with for my personal projects. I like Treepad and Zim, but I needed something a bit more flexible so that I can organize the same group of documents differently based on the task at hand. That's why I am creating ForestPad.

## Why "ForestPad"?

Because each group of documents may be organized using one or more "trees" (hence, you end up building a "forest"). Neat name, ah? :)

# Installation
1. Download and install node-webkit on your computer following the instructions at https://github.com/rogerwang/node-webkit#downloads.
2. Make sure to add the node-webkit executable to your path.
3. Download or clone the repository.
4. Go to the src folder and execute "nw ."


text:
# POST "/v1/generate\_file/"
This route sends a request to the backend to utilize the relevant external APIs and generate the relevant file for the metadata that is submitted. This route is used for file generation **within** a submission.

## Body (JSON)
```
{
    "submission_id": 123,
    "file_type": "D1",
    "start": "01/01/2016",
    "end": "03/31/2016",
    "agency_type": "awarding",
    "file_format": "csv"
}
```

## Body Description

- `submission_id`: (required, integer) the ID of the submission to generate a file for
- `file_type`: (required, string) the file type to generate. Allowable values are:
    - `D1`: generate a D1 file
    - `D2`: generate a D2 file
    - `E`: generate an E file
    - `F`: generate an F file
- `start`: (string) the start date of the requested date range, in `MM/DD/YYYY` string format, should not be used for E/F generation
- `end`: (string) the end date of the requested date range, in `MM/DD/YYYY` string format, should not be used for E/F generation
- `agency_type`: (string) indicates if the file generated should be based on awarding or funding agency. Defaults to `awarding` if not provided. Only used in D1/D2 generation. Only allowed values are:
    - `awarding`
    - `funding`
- `file_format`: (string) indicates if the file generated should be a comma delimited csv or a pipe delimited txt. Defaults to `csv` if not provided. Only used in D1/D2 generation. Only allowed values are:
    - `csv`
    - `txt`

## Response (JSON)

```
{
    "job_id": 1234,
    "status": "finished",
    "file_type": "D1",
    "url": "https://........",
    "size": null,
    "start": "01/01/2016",
    "end": "03/31/2016",
    "message": ""
}
```

## Response Attributes
If the file has not finished generating when this returns, further checks for whether the generation is complete or not should be done using [check\_generation\_status](./check_generation_status.md).

- `job_id`: (integer) job ID of the generation job in question
- `status`: (string) indicates the file's status. Possible values are:
    - `finished`: file has been generated and is available for download
    - `waiting`: file has either not started/finished generating or has finished generating but is not yet uploaded to S3
    - `failed`: an error occurred and the file generation or S3 upload failed, the generated file is invalid, or any other error
    - `invalid`: no generation request has ever been made for this submission ID before
- `file_type`: (string) indicates the file that the status data refers to. Possible values are:
    - `D1`
    - `D2`
    - `E`
    - `F`
- `url`: (string) a signed S3 URL from which the generated file can be downloaded. This will be the string `"#"` if the file is not in the `finished` state.
- `size`: (integer) the size of the generated file in bytes
- `start`: (string) the file start date, in `MM/DD/YYYY` format. If not a D1/D2 file, this key will not be returned.
- `end`: (string) the file end date, in `MM/DD/YYYY` format. If not a D1/D2 file, this key will not be returned.
- `message`: (string) a user-readable error message when the file is `failed`, otherwise returns a blank string

## Errors
Possible HTTP Status Codes not covered by `check_generation_status` documentation:

- 400:
    - Start and end date not provided for D1/D2 generation
    - Start and end date not formatted properly
    - Missing `submission_id` parameter
    - Submission does not exist
    - Invalid `file_type` parameter
- 401: Login required
- 403: Permission denied, user does not have permission to edit this submission


text:
# gateblu-log-tracer
Trace what happened to that dog gone gateblu device

```text
Usage: gateblu-log-tracer [options] [command]

 Commands:

   list-activity      get list of gateblu activity in last 24 hours
   list-failures      get list of gateblu-deployment failures in last 24 hours
   group-failures     get list of gateblu failed activity grouped by gateblu in last 24 hours
   trace              trace a gateblu deployment
   gateblu-activity   show activity for a gateblu uuid
   help [cmd]         display help for [cmd]

 Options:

   -h, --help     output usage information
   -V, --version  output the version number
```

repository: octoblu/gateblu-log-tracer

repo_name: octoblu/gateblu-log-tracer


text:
# SIRF on Ubuntu 16.04 on Docker

Docker wrapper for CCP PET-MR SIRF.

- [SIRF docker source]: https://github.com/CCPPETMR/SIRF-SuperBuild/tree/master/docker
    + See also: [SIRF SuperBuild on Docker wiki]: https://github.com/CCPPETMR/SIRF/wiki/SIRF-SuperBuild-on-Docker
- [Synergistic Image Reconstruction Framework (SIRF) project][SIRF]: https://github.com/CCPPETMR/SIRF
    + [SIRF wiki]: https://github.com/CCPPETMR/SIRF/wiki
- [Collaborative Computational Project in Positron Emission Tomography and Magnetic Resonance imaging (CCP PET-MR)][CCP PET-MR]: https://www.ccppetmr.ac.uk/

[SIRF docker source]: https://github.com/CCPPETMR/SIRF-SuperBuild/tree/master/docker
[SIRF SuperBuild on Docker wiki]: https://github.com/CCPPETMR/SIRF/wiki/SIRF-SuperBuild-on-Docker
[SIRF]: https://github.com/CCPPETMR/SIRF
[SIRF wiki]: https://github.com/CCPPETMR/SIRF/wiki
[CCP PET-MR]: https://www.ccppetmr.ac.uk/

## Tags

The repository is hosted at [hub.docker.com][dockerhub-SIRF].
To pull directly, use:

```sh
docker pull ccppetmr/sirf:<DOCKER_TAG>
```

| `<DOCKER_TAG>` | [SuperBuild] branch/tag |
|:--- |:--- |
| `release` | `<latest_tag>` |
| `<tag>` | `<tag>` |
| `latest` | `master` |
| `devel` | `master` with `cmake -DDEVEL_BUILD=ON` |

[dockerhub-SIRF]: https://hub.docker.com/r/ccppetmr/sirf/
[SuperBuild]: https://github.com/CCPPETMR/SIRF-SuperBuild/

repository: SyneRBI/Hackathon-SIRF-SuperBuild

repo_name: SyneRBI/Hackathon-SIRF-SuperBuild


text:
---
layout: page
title: Can I see the blank consent forms and patient information leaflets?
permalink: /cells/faq/blank-consent-and-patient-info-leaflet/
redirect_from:
  - /model-ethics-forms/
---

### Ethics #1

These documents were generated by the NIHR BioResource and members of the HipSci consortium membership committee. The study was approved by: NRES Committee East of England - Cambridge Central, Study title: Generation of Induced Pluripotent Stem (iPS) Cells and Rare Diseases. REC Ref: 15/EE/0049

* [Child Assent Form](/documents/ethics-1/Child%20Assent%20Form.pdf)
* [Paed PIL 6-10 years young sibling](/documents/ethics-1/Paed%20PIL%206-10%20years%20young%20sibling.pdf)
* [Paed PIL 6-10 years](/documents/ethics-1/Paed%20PIL%206-10%20years.pdf)
* [Parent Guardian Consent form Blood](/documents/ethics-1/Parent%20Guardian%20Consent%20form%20Blood.pdf)
* [Parent Guardian Consent form skin](/documents/ethics-1/Parent%20Guardian%20Consent%20form%20skin.pdf)
* [Parent Guardian PIL](/documents/ethics-1/Parent%20Guardian%20PIL.pdf)
* [Participant Consent form skin biopsy](/documents/ethics-1/Participant%20Consent%20form%20skin%20biopsy.pdf)
* [Participant PIL](/documents/ethics-1/Participant%20PIL.pdf)
* [Participant consent form blood](/documents/ethics-1/Participant%20consent%20form%20blood.pdf)
* [REC favourable opinion letter](/documents/ethics-1/REC%20favourable%20opinion%20letter.pdf)
* [Young People PIL 11-15 years sibling](/documents/ethics-1/Young%20People%20PIL%2011-15%20years%20sibling.pdf)
* [Young People PIL 11-15 years](/documents/ethics-1/Young%20People%20PIL%2011-15%20years.pdf)

### Ethics #2

The following documents have been provided by NIHR Rare Diseases Translational Research Collaboration and the NIHR Great Ormond Street Hospital Biomedical Research Centre. This study was approved by NRES Committee London-Bloomsbury, Study title: Molecular Genetics of Human Birth Defects - mapping and gene identification. REC Ref: 08/H0713/82

* [Assent form for children (age 8–15 years)](/documents/Assent%20form%20participants%20aged%208-15%20v3%2020.09.13%20WTSI_PB.pdf)
* [Information for patients (age 14+ years)](/documents/Info%20sheet%20participants%20aged%2014+%20v5%2012.01.15.pdf)
* [Information for patients (age 8–14 years)](/documents/Info%20sheet%20participants%20aged%208-14%20v2%2020%2009%2013%20WTSI_PB.pdf)
* [Patient information sheet (age under 8 years)](/documents/Info%20sheet%20participants%20aged%20under%208%20v2%2020.09.13%20WTSI_PB.pdf)
* [Consent form for parents / guardians](/documents/Parent%20Consent%20form%20v3%2020%2009%2013%20WTSI_PB.pdf)
* [Consent form for adults](/documents/Participant%20Consent%20form%20v3%2020.09.13%20WTSI%20_PB.pdf)


text:
# :satellite: himawari-rx - HimawariCast Downlink Processor

[![GitHub release](https://img.shields.io/github/release/sam210723/himawari-rx.svg)](https://github.com/sam210723/himawari-rx/releases/latest)
[![Python versions](https://img.shields.io/badge/python-3.6%20%7C%203.7%20%7C%203.8-blue)](https://www.python.org/)
[![Github all releases](https://img.shields.io/github/downloads/sam210723/himawari-rx/total.svg)](https://github.com/sam210723/himawari-rx/releases/latest)
[![GitHub license](https://img.shields.io/github/license/sam210723/himawari-rx.svg)](https://github.com/sam210723/himawari-rx/blob/master/LICENSE)

**himawari-rx** is a decoder for receiving images from geostationary weather satellite [Himawari-8 (140.7˚E)](https://himawari8.nict.go.jp/) via the [HimawariCast](https://www.data.jma.go.jp/mscweb/en/himawari89/himawari_cast/himawari_cast.php) data service operated by [Japan Meteorological Agency](https://www.data.jma.go.jp/mscweb/en/index.html). HimawariCast is a DVB-S2 signal transmitted from [JCSAT-2B (154°E)](https://www.jsat.net/en/contour/jcsat-2b.html) on its [global C-band beam](https://www.satbeams.com/footprints?beam=8542). It can be received with a 2.4m satellite dish and a standard C-band LNB. It may be possible to use a smaller dish however this has not been verified.

**himawari-rx** receives UDP datagrams over a network connection and outputs decoded image files to disk. The UDP datagrams can come from either a DVB-S2 receiver card such as a [TBS5520SE](https://www.tbsdtv.com/products/tbs5520se_multi-standard_tv_tuner_usb_box.html) or a satellite IP receiver such as the [Novra S300D](https://novra.com/product/s300d-receiver). A Software Defined Radio solution using GNU Radio is currently under development.

![Himawari-8 Wavelengths](https://vksdr.com/bl-content/uploads/pages/95f4812a86753b6057b0e37ce4daa5d1/wavelengths.png)

## Getting Started
A (work in progress) guide for setting up the hardware and software components of a HimawariCast receiver is [available on my site](https://vksdr.com/himawari-rx).

**In the meantime here is a quick overview of the required setup:**

HimawariCast is a C-band DVB-S2 downlink on geostationary communication satellite JCSAT-2B at 154°E. The downlink frequency is 4148 MHz with a symbol rate of 2586 ksps and horizontal polarisation. On a standard 5150 MHz LO C-band LNB it has an IF of 1002 MHz.

A standard DVB-S2 receiver card/box such as the [TBS6902](https://www.tbsdtv.com/products/tbs6902-dvb-s2-dual-tuner-pcie-card.html) (PCIe) or [TBS5520SE](https://www.tbsdtv.com/products/tbs5520se_multi-standard_tv_tuner_usb_box.html) (USB) can receive this downlink either using Windows or Linux. The downlink carries multicast UDP packets which are wrapped in [DVB-MPE](https://en.wikipedia.org/wiki/Multiprotocol_Encapsulation) and need to be unwrapped with software such as [TSDuck](https://tsduck.io/), the [TBS IP Tool](https://www.tbsdtv.com/blog/tbs-ip-tool-is-updated-to-v3-0-5-0-which-added-tbs5927-support.html) or [TSReader](https://www.tsreader.com/).

For TSDuck, the following command should work in most cases.

```
tsp -I dvb --adapter 0 --delivery-system "DVB-S2" --lnb "5150000000" --frequency<PHONE_NUMBER> --modulation QPSK --symbol-rate 2586148 --fec-inner "3/5" --roll-off 0.2 --polarity "horizontal" -P mpe --pid 0x03E9 --udp-forward --log -O drop
```

For TSReader, use ``File -> IP/DVB Mode`` and select PID ``0x03E9 (1001)``, then right click on ``UDP: <IP_ADDRESS>`` in the PID list and select ``Retransmit UDP payload``.

To install himawari-rx, download the ``himawari-rx.zip`` from the [latest release](https://github.com/sam210723/himawari-rx/releases/latest) and extract it to a new folder. Next, install the required Python packages with ``pip install -r requirements.txt``. Finally, run himawari-rx with ``python himawari-rx.py``.

himawari-rx will begin decoding images once UDP packets from the downlink are being transmitted onto the local network using TSDuck, the TBS IP Tool or TSReader.

## Imaging Bands
Himawari-8 is capable of capturing Earth in 16 different wavelengths of light, 14 of which are transmitted via the HimawariCast service.

## List of options
#### `rx` section
| Setting   | Description                                                                   | Options                                                 | Default      |
| --------- | ----------------------------------------------------------------------------- | ------------------------------------------------------- | ------------ |
| `path`    | Root output path for received files                                           | *Absolute or relative file path*                        | `"received"` |
| `combine` | Save all images in a single directory (XRIT2PIC compatibility)                | `true` or `false`                                       | `false`      |
| `format`  | File type to output                                                           | `bz2`: Compressed xRIT files
`xrit`: LRIT/HRIT files | `xrit`       |
| `ignored` | List of channels (bands) to ignore
(e.g. `"B09", "IR2"`)                   | Table of available bands   | *none*       |

#### `udp` section
These two options generally do not need to be changed.
| Setting | Description                             | Options                         | Default     |
| ------- | --------------------------------------- | ------------------------------- | ----------- |
| `ip`    | Multicast IP address of DVB-S2 receiver | `<IP_ADDRESS>` - `<IP_ADDRESS>` | `<IP_ADDRESS>` |
| `port`  | UDP output port of DVB-S2 receiver      | *Any UDP port number*           | `8001`      |

## Acknowledgments
  - [@yanderen2](https://twitter.com/yanderen2) - Software testing and TS recordings
  - [tcjj3](https://github.com/tcjj3) - Software testing and scripting
  - [John Bell](https://twitter.com/eswnl) - Software testing and TS recordings
  - [@Apsattv](https://twitter.com/Apsattv) - TS recordings

repository: vk-hca/himawari-rx

repo_name: vk-hca/himawari-rx


text:
# History Version

### v1.0

**2019.3.30** release

**v1.1**  2019.4.2

- fixed a bug, which resulted in that when books in cart were deleted from booklist by administrator, some books would not be displayed properly in cart page
- updated version of one of the back-end dependencies, commons-fileupload, to 1.3.3

### v2.0

**2019.4.23**

- refactored back-end to SpringBoot + Hibernate
- adjusted HTTP api

**v2.1** 2019.4.28

- fixed bugs, which resulted in that
  - visitors and administrators could add to cart and purchase
  - time displayed in orders were not correct due to timezone problems
  - ISBN could not be shown normally
- some beautification
  - the shadow of iconButton + and - is a circle now
  - filter bar is more beautiful now

**v2.2** 2019.5.1

- can empty cart now
- beautified dialogs
- toggling validity will not lead to page refreshing now
- administrators' info won't be shown when managing customers

### v3.0

**2019.5.17**

- refactored database, adding OrderItem table
- adjusted HTTP api

**v3.1** 2019.5.29

- added Test in back-end
- applied Spring Security with JWT to protect api

### v4.0

**2019.5.31** deploy

+ deployed the whole project to cloud server
+ applied some strategies to defend flooding attack

**v4.1** 2019.6.11

+ added api about book review, stored using MongoDB
+ added dao layer at back-end

### v5.0

**2019.6.30**

+ applied Drone, can CI/CD now
+ added comment function
+ beautified front-end UI

##### Last-modified date: 2019.6.30, 6 p.m.

repository: Gusabary/YIBUK

gha_language: JavaScript

repo_name: Gusabary/YIBUK


text:
# Agaricus reae Bon, 1981 SPECIES

#### Status
SYNONYM

#### According to
The Catalogue of Life, 3rd January 2011

#### Published in
Docums Mycol. 11(no. 44): 28 (1981)

#### Original name
Psalliota impudica Rea, 1932

### Remarks
null

repository: mdoering/backbone

path: /life/Fungi/Basidiomycota/Agaricomycetes/Agaricales/Agaricaceae/Agaricus/Agaricus impudicus/ Syn. Agaricus reae/README.md

repo_name: mdoering/backbone