text:
# Lemmet README

A Lemmet extension for Visual Studio Code.

## Features

Lemmet is a indentable Emmet like pug.

### Emmet
```
div#page>div.logo+ul#navigation>li*5>a
```

### Lemmet
```
div#page
  div.logo
  ul#navigation
    li*5>a
```

### Rules

* Use 2 space or TAB for indent.

## Usage

* It is recommended that "emmet.triggerExpansionOnTab" set to "true".
* Write Lemmet (indentable Emmet) code and save as HTML.
* Select area of Lemmet code and Ctrl+Shift+P and type "Lemmet". Then Lemmet code convert to Emmet and selected.
* This is all of this extension's job. After that, Emmet extension will be work for you.
* Ctrl+Space then TAB. HTML tags will be expanded.

![feature X](images/lemmet.gif)

## Release Notes

### 1.0.0

Initial release of Lemmet extension.

repository: hwakimoto/lemmet

repo_name: hwakimoto/lemmet


text:
---
title: Memory
level: 1
language: en-GB
stylesheet: scratch
embeds: "*.png"
materials: ["Club Leader Resources/*.*"]
---

## Community Contributed Project { .challenge .pdf-hidden }
This project was created with Erik and his daughter Ruth. If you'd like to contribute a project of your own, then [get in touch with us on Github](https://github.com/CodeClub).

# Introduction { .intro }

In this project, you will create a memory game where you have to memorise and repeat a sequence of random colours!

# Step 1: Random colours { .activity }

First, let's create a character that can change to a random sequence of colours for the player to memorise.

## Activity Checklist { .check }

+ Start a new Scratch project, and delete the cat sprite so that your project is empty. You can find the online Scratch editor at jumpto.cc/scratch-new.

+ Choose a character and a backdrop. Your character doesn't have to be a person, but it needs to be able to show different colours.

	![screenshot](colour-sprite.png)

+ In your game, you'll use a different number to represent each colour:

	+ 1 = red;
	+ 2 = blue;
	+ 3 = green;
	+ 4 = yellow.

	Give your character 4 different colour costumes, one for each of the 4 colours above. Make sure that your coloured costumes are in the right order.

	![screenshot](colour-costume.png)

+ To create a random sequence, you need to create a _list_. A list is just a variable that stores lots of data _in order_. Create a new list called `sequence` {.blockdata}. As only your character needs to see the list, we can also click 'For this sprite only'.

	![screenshot](colour-list.png)

	You should now see your empty list in the top-left of your stage, as well as lots of new blocks for using lists.

	![screenshot](colour-list-blocks.png)

+ Add this code to your character, to add a random number to your list (and show the correct costume) 5 times:

	```blocks
		when flag clicked
		delete (all v) of [sequence v]
		repeat (5)
			add (pick random (1) to (4)) to [sequence v]
			switch costume to (item (last v) of [sequence v]
			wait (1) secs
		end
	```

	Notice that you have also emptied the list to begin with.

## Challenge: Adding sound {.challenge}
Test your project a few times. You may notice that sometimes the same number is chosen twice (or more) in a row, making the sequence harder to memorise. Can you make a drum sound play each time the character changes costume?

Can you make a different drum sound play depending on the random number chosen? This will be _very_ similar to your code to change the character's costume.

## Save your project { .save }

# Step 2: Repeating the sequence { .activity }

Let's add 4 buttons, for the player to repeat the sequence they've remembered.

## Activity Checklist { .check }

+ Add 4 sprites to your project, that will become buttons. Edit your 4 sprites, so that there's 1 for each of the 4 colours.

	![screenshot](colour-drums.png)

+ When the red drum is clicked, you'll need to broadcast a message to your character, letting them know that the red button has been clicked. Add this code to your red drum:

	```blocks
		when this sprite clicked
		broadcast [red v]
	```

+ When your character receives this message, they should check whether the number 1 is at the start of the list (which means that red is the next colour in the sequence). If it is, you can remove the number from the list, as it's been guessed correctly. Otherwise it's game over!

	```blocks
		when I receive [red v]
		if <(item (1 v) of [sequence v])=[1]> then
			delete (1 v) of [sequence v]
		else
			say [Game over!] for (1) secs
			stop [all v]
		end
	```

+ You could also display some flashing lights once the list is empty, as it means the entire sequence has been guessed correctly. Add this code to the end of your character's `when flag clicked` {.blockevents} script:

	```blocks
		wait until < (length of [sequence v]) = [0]>
		broadcast [won v] and wait
	```

+ Click on your stage, and add this code to make the backdrop change colour once the player has won.

	```blocks
		when I receive [won v]
		play sound [drum machine v]
		repeat (50)
			change [color v] effect by (25)
			wait (0.1) secs
		end
		clear graphic effects
	```

## Challenge: Creating 4 buttons {.challenge}
Repeat the steps above for your blue, green and yellow buttons. Which code will stay the same, and which code will change for each button?

You can also add sounds for when the buttons are pressed.

Remember to test the code you've added! Can you memorise a sequence of 5 colours? Is the sequence different each time?

## Save your project { .save }

# Step 3: Multiple levels { .activity .new-page }

So far, the player only has to remember 5 colours. Let's improve your game, so that the length of the sequence increases.

## Activity Checklist { .check }

+ Create a new variable called `score` {.blockdata}.

	![screenshot](colour-score.png)

+ This `score` {.blockdata} will be used to decide on the length of the sequence the player has to memorise. So, to begin with the score (and the sequence length) is 3. Add this code block to the start of your character's `when flag clicked` {.blockevents} code:

	```blocks
		set [score v] to [3]
	```

+ Instead of always creating a sequence of 5 colours, you now want the `score` {.blockdata} to determine the sequence length. Change your character's `repeat` {.blockcontrol} loop (for creating the sequence) to:

	```blocks
		repeat (score)
		end
	```

+ If the sequence is guessed correctly, you should add 1 to the score, to increase the length of the sequence.

	```blocks
		change [score v] by (1)
	```

+ Finally, you need to add a `forever` {.blockcontrol} loop around the code to generate the sequence, so that a new sequence is created for each level. This is how your character's code should look:

	```blocks
		when flag clicked
		set [score v] to [3]
		forever
			delete (all v) of [sequence v]
			repeat (score)
				add (pick random (1) to (4)) to [sequence v]
				switch costume to (item (last v) of [sequence v]
				wait (1) secs
			end
			wait until < (length of [sequence v]) = [0]>
			broadcast [won v] and wait
			change [score v] by (1)
		end
	```

+ Get your friends to test out your game. Remember to hide the `sequence` {.blockdata} list before they play it!

## Save your project { .save }

# Step 4: High score { .activity }

Let's save the high score, so that you can play against your friends.

## Activity Checklist { .check }

+ Add 2 new variables to your project, called `high score` {.blockdata} and `name` {.blockdata}.

+ If ever the game ends (by pressing the wrong button), you need to check whether the player's score is higher than the current high score. If it is, you need to save the score as the high score, and store the name of the player. Here's how your red button should look:

	```blocks
		when I receive [red v]
		if <(item (1 v) of [sequence v])=[1]> then
			delete (1 v) of [sequence v]
		else
			say [Game over!] for (1) secs
			if < (score) > (high score) > then
				set [high score v] to [score v]
				ask [High score! What is your name?] and wait
				set [name v] to (answer)
			end
			stop [all v]
		end
	```

+ You'll need to add this new code to the other 3 buttons too! Have you noticed that the 'Game over' code in each of the 4 buttons is exactly the same?

	![screenshot](colour-same.png)

+ If ever you need to change any of this code, such as adding a sound or changing the 'Game over!' message, you'd have to change it 4 times! That could get annoying, and waste a lot of time.

	Instead, you can define your own blocks, and reuse them in your project! To do this, click `more blocks` {.blockmoreblocks}, and then 'Make a block'. Call this new block 'Game over'.

	![screenshot](colour-more.png)

+ Add the code from the `else` {.blockcontrol} block from the red button to the new block that appears:

	![screenshot](colour-make-block.png)

+ You've now made a new _function_ called `Game over` {.blockmoreblocks}, which you can use anywhere you like. Drag your new `Game over` {.blockmoreblocks} block onto the 4 scripts for the buttons.

	![screenshot](colour-use-block.png)

+ Now add a sound for when the wrong button is pressed. You only need to add this code _once_ in the `Game over` {.blockmoreblocks} block that you made, and not 4 separate times!

	![screenshot](colour-cough.png)

## Challenge: Making more blocks {.challenge}
Do you notice any other code that is the same for all 4 buttons?

![screenshot](colour-more-blocks.png)

Can you make another custom block, that is used by each button?

## Save your project { .save }

## Challenge: Another costume {.challenge}
Have you noticed that your game starts with your character showing one of the 4 colours, and that they always display the last colour in the sequence while the player is repeating the sequence?

Can you add another plain white costume to your character, which is displayed at the start of your game, and when the player is trying to copy the sequence?

![screenshot](colour-white.png)

## Save your project { .save }

## Challenge: Difficulty level {.challenge}
Can you allow your player to choose between 'easy mode' (using just the red and blue drums) and 'normal mode' (which uses all 4 drums)?

You could even add a 'hard' mode, which makes use of a 5th drum!

## Save your project { .save }

path: /src/scratch/Term 2/Memory/Memory.md

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
## Essential commands

For the Ultima Online Outlands server, I recommend reviewing and running these commands. I feel they make the game experience much better, especially if you are new. The server wiki does a poor job of documenting these and many people don't even know they exist.

All of these commands can be used in this gump:
```
[Commands
```

The commands act like a toggle, just issue them once to turn off, and again to turn on.

### New Players

Essential commands for new players. These will prevent you from flagging accidentally and save a lot of headache.

| Command      | Description                          |
| ----------- | ------------------------------------ |
| `[preventcriminallooting`       | Prevents opening blue corpses  |
| `[preventcriminalhealing`       | Prevents healing criminals  |

### Remove PVP Event Server Spam

I find the server spams too many PVP messages by default - like a lot. Unless you are participating in these events, turn them off. If you are not into PVP, like myself, these will de-clutter your screen:

| Command      | Suppresses                          |
| ----------- | ------------------------------------ |
| `[showstygianriftsannouncements`       | Rifts  |
| `[showcorpsecreekcontestannouncements`       | Shrines  |
| `[showdungeonflashpointannouncements`       |  Flash Points  |
| `[showtownstruggleannouncements`       |   Town Struggles  |

license: MIT

repository: xotl-uoo/scripts

branch_name: refs/heads/main

repo_name: xotl-uoo/scripts


text:
# My Scholarly Article

## Development mode
```
bundle install
bundle exec guard
```

## Build
```
bundle install
bundle exec nanoc compile
```

View on http://localhost:3000/

This article makes use of the [ScholarMarkdown](https://github.com/rubensworks/ScholarMarkdown/) framework.

repository: rubensworks/ScholarMarkdown

gha_language: SCSS

gha_license_id: MIT

repo_name: rubensworks/ScholarMarkdown


text:
# express-boilerplate
A simple express server, to be used as a basis for more complex projects.

## Installation
  * Run `git clone git@github.com:Jwhiles/express-boilerplate.git` in your terminal.
  * cd into the newly created directory.
  * Run `npm install`
  * The server can now be started by typing `npm run start` into your terminal. You can run tests with `npm run test`

## Dependencies
  The server requires express to run.
  Tape and Supertest and dev dependencies, both are used for testing.

repository: Jwhiles/express-boilerplate

repo_name: Jwhiles/express-boilerplate


text:
---
layout: post
title:  "How this site created?"
date:   2016-09-27 08:35:17 +0800
categories: site
---

# How this sited created?

###### Note: Don't forget to replace all the following 'username' with your username

#### Create a github project name 'username.github.io'

#### Prepare jekyll and bundler
```shell
$ gem install jekyll bundler
```

#### Checkout the project 'username.github.io' you just created from github
```shell
$ git checkout https://github/username/username.github.io
```

#### Create boilerplate from jekyll
```shell
$ cd username.github.io
$ jekyll new . --force
# modify 'Gemfile' to use github pages
$ bundle install
```

#### Copy the remanning resources from minimal theme
```shell
$ bundle show minima
# you will see an absolute path of your minima theme's location
$ cp -rf /var/lib/gems/2.3.0/gems/minima-2.0.0/{assets,_includes,_layout,_sass} .
```

Then add following code to the top of your markdown file.

```
---
layout: post
title:  "How this site created?"
date:   2016-09-27 08:35:17 +0800
categories: jekyll update
---
```

If you are working in bash, you can use `$ date "+%F %T %z"` to generate date description.

#### Do testing in your local machine
```shell
$ bundle exec jekyll serve
```

#### Commit and push all your site content to origin
```shell
$ git add .
$ git commit -m 'just created github pages blog'
$ git push
```

#### Congratulations!

#### References
1. [Jekyll quick start guide](https://jekyllrb.com/docs/quickstart/)
2. [Github pages](https://pages.github.com/)

extension: markdown


text:
---
layout: page
title: Markers
---

Markers
=======

An example *libkoki* marker is given to the right; this one is *arena-0*.
There is a dot in the top-left corner of the black border.  This corner is known as the *principal corner*, and its location is important if measuring the marker's orientation about the Z-axis.
There is also some text in the bottom-left corner of the black border.
This text will say something like `"libkoki marker #0 (v0.5) 'ARENA'"`.
Let's break that down:
`#0` means marker number 0;
`(v0.5)` tells you the version of the marker, it is important the latest version is used; and
`'ARENA'` is just a human-readable description of what the marker is for.

A link to download the SR2017 markers will be added to this page once the game has been announced.

Note that a different set of markers will be used for the competition (by adding 100 to all of the markers above).
This is not something you need to worry about, though.
We will handle this for you when your robot is started in a competition mode.

The white space around the markers is very important -- without it, the markers probably won't be recognised.
If the markers become damaged (scuff markers, tears, etc...) they will not function as well (if at all).
If this happens, it is best to just print another one.

repository: edlongman/docs

repo_name: edlongman/docs


text:
## 2.1.0

Compatible Personium version: 1.8.0

Enhancement:

- Update Java version to 17. #161
- Update middlewares. #167

MISC:

- Downloading war files from GitHub releases. #166
- Downloading extension jar files from GitHub releases. #163

See: https://github.com/personium/ansible/milestone/6?closed=1

## 2.0.11

See: https://github.com/personium/ansible/milestone/8?closed=1

## 2.0.10

See: https://github.com/personium/ansible/milestone/5?closed=1

## 2.0.9

See: https://github.com/personium/ansible/milestone/4?closed=1

## 2.0.8a

Bug fixes:

- Fix web_private_ip. #107

## 2.0.8

Enhancement:

- Fix static_inventory/hosts uses many duplicated variables #99
- Separation of bastion and web #97
- X-Personium-RequestKey header output in nginx logs #89
- Upgrade middlewares #103

BugFixes:

- SSH user is hard-coded. #98

## 2.0.7

Support percell fqdn
Corresponded to ElasticSearch 6.6.1

## 2.0.6

Corresponded to ElasticSearch 5.6.14

## 2.0.5

Corresponded to OpenJDK 8.
Corresponded to tomcat 9.c

## 2.0.4

Merge pull request #43 from naoya-mokudai/develop

Fix URL mistake

## 2.0.3

Merge pull request #33 from personium/2.0.3_dev

2.0.3 release

## 2.0.2

Release v2.0.2

## 2.0.1

Changing the specification key of host file.

This ansible has already been confirmed with Personium v1.5.3.

## 2.0.0

ansible for Personium v1.5.2 or later.

## 1.5.1

ansible for Personium v1.5.1 #13

## 1.5.0

ansible for Personium v1.5.0 #11

## 1.4.5

Core and Engine version used for ansible are fixed to 1.4.5.

## 1.4.3

Optimized for Personium v1.4.3.

repository: personium/ansible

branch_name: refs/heads/develop

gha_language: Shell

repo_name: personium/ansible


text:
# MATLAB-ci

A small set of modules written in Node.js for running automated tests of MATLAB code in response to GitHub events.  Also submits code coverage to the Coveralls API.

## Getting Started

Run the install script to install all dependencies, then create your .env file containing your App's tokens, secrets, etc.

### Prerequisites

Requires MATLAB 2017a or later, Node.js and Git Bash.  The following Node.js modules are required:

```
npm install --save express dotenv @octokit/app @octokit/request ...
github-webhook-handler xml2js
```

### Installing

Make sure runAllTests.m is on your MATLAB paths

## Running the tests

TODO

## Deployment

To work properly you need to create install a Github app on your target repository and download the private key.  Update your .env file like so:

```
GITHUB_PRIVATE_KEY=path\to\private-key.pem
GITHUB_APP_IDENTIFIER=1234
GITHUB_WEBHOOK_SECRET=
WEBHOOK_PROXY_URL=
RIGBOX_REPO_PATH=C:\Path\To\Code\Repo
```

To run at startup create a batch file with the following command:

```batch
cmd /k node -r dotenv/config dotenv_config_path=/Path/To/Env/Vars ./Path/To/index.js
```

Create a shortcut in your startup folder ([Windows-logo] + [R] in Windows-10 and enter the command `shell:startup`)

## Built With

* [Serveo](serveo.net) - SSH tunneling service
* [Shields.io](shields.io) - Display shields

## Contributing

Please read [CONTRIBUTING.md](https://gist.github.com/PurpleBooth/b24679402957c63ec426) for details on our code of conduct, and the process for submitting pull requests to us.

## Versioning

We use [SemVer](http://semver.org/) for versioning. For the versions available, see the [tags on this repository](https://github.com/your/project/tags).

## Authors

* **Miles Wells**

## License

This project is licensed under the MIT License - see the [LICENSE.md](LICENSE.md) file for details

repository: Daanikus/matlab-ci

repo_name: Daanikus/matlab-ci


text:
# Explore Fuchsia {#explore-fuchsia}

Once you have Fuchsia up and running on a device or emulator,
check out the following resources:

*  [Run ffx commands](#run-ffx-commands).
*  [Run examples](#run-examples).
*  [Create Fuchsia components](#create-fuchsia-components).
*  [Contribute changes](#contribute-changes).

## Run ffx commands {#run-ffx-commands}

[`ffx`][ffx-overview] is a host tool for Fuchsia target workflows that
provides the consistent development experience across all Fuchsia environments
and host platforms.

The following are some of `ffx` command examples:

*   Display the list of devices:

    ```posix-terminal
    ffx target list
    ```

*   Display the device information:

    ```posix-terminal
    ffx target show
    ```

*   Print the device logs:

    ```posix-terminal
    ffx log
    ```

*   Reboot the device:

    ```posix-terminal
    ffx target reboot
    ```

## Run examples {#run-examples}

To try out Fuchsia's sample software, check out the guides below:

*   [Run an example component](/docs/development/run/run-examples.md)
*   [Run a test component](/docs/development/run/run-test-component.md)

## Create Fuchsia components {#create-fuchsia-components}

The basic executable units of software in Fuchsia are
[components](/docs/concepts/components/v2), and these components interact
with each other using [FIDL](/docs/concepts/fidl/overview.md)
(Fuchsia Interface Definition Language) protocols.

To learn more about Fuchsia components and FIDL, check out the guides below:

*   [Build components](/docs/development/components/build.md)
*   [FIDL overview](/docs/development/languages/fidl/README.md)
*   [FIDL tutorials](/docs/development/languages/fidl/tutorials/overview.md)

## Contribute changes {#contribute-changes}

When you're ready to contribute to the Fuchsia project,
see [Contribute changes][contribute-changes].

## See also

For more information on Fuchsia's development workflows,
check out the following resources:

*   [fx workflows](/docs/development/build/fx.md)
*   [Workflow tips and questions](/docs/development/source_code/workflow_tips_and_faq.md)
*   [Configure editors](/docs/reference/tools/editors/README.md)
*   [Source code layout](/docs/development/source_code/layout.md)
*   [Build system](/docs/development/build/build_system/index.md)

<!-- Reference links -->

[components]: /docs/concepts/components/v2
[run-examples]: /docs/development/run/run-examples.md
[ffx-overview]: /docs/development/tools/ffx/overview.md
[fidl]: /docs/development/languages/fidl
[fidl-tutorials]: /docs/development/languages/fidl/tutorials/overview.md
[fidl-concepts]: /docs/concepts/fidl/overview.md
[run-fuchsia-tests]: /docs/development/testing/run_fuchsia_tests.md
[scenic]: /docs/concepts/ui/scenic/index.md
[contribute-changes]: /docs/development/source_code/contribute_changes.md

repository: gnoliyil/fuchsia

repo_name: gnoliyil/fuchsia


text:
# Right-click "Bash Here" Shortcut in Context Menu for MSYS2 MINGW32/64 shell
These are all the configuration files needed to add "bash here" options in the Windows right-click shortcut/context menu. The menu options will be made available for both right-click on a folder background and [right-click on a folder](https://gist.github.com/magthe/a60293fe395af7245a9e#gistcomment-3164952).

This implementation should work for MSYS2 and MINGW32/64 shells that come with MSYS2.

![screenshot](https://cloud.githubusercontent.com/assets/2238599/15538737/d9d1e3a2-2232-11e6-9426-42c62c69925c.png)

## Usage
- Make sure the environment variable `$HOME` exists and points to `/home/<userid>` from your MSYS2/bash console. To test this, open an MSYS2/bash console, and type and run this command: `echo $HOME`. If it prints a valid path, the variable exists with a valid value. If it does not print a path, you need to fix up your install to include a `$HOME` environment variable (out of scope of this document). This is needed because this script will use `$HOME/.bash_profile`. Then, from an MSYS2/bash console, run these commands:
- From a directory into which you want to clone the direcotry of this repository: `git clone <full URL of this repository>`
- `cd <folder of this repository>`
- `./install` and follow the instructions
- **(Optional)** double-click `install_right_click_menu.reg` file to merge it into your windows registry if not automatically merged by the install script.
- **(Optional)** If you don't see icons in the context menu, please install `msys2-launcher`
   via pacman (`pacman -S msys/msys2-launcher-git`) or from source https://github.com/elieux/msys2-launcher

## Note (Manually add Context Menu shortcuts)
Double-click `install_right_click_menu.reg` and follow the Registry Editor prompts.

## Note (Manually remove Context Menu shortcuts)
Double-click `uninstall_right_click_menu.reg` and follow the Registry Editor prompts.

## Notes
- This script does not depend on `cygpath`.
- If you are using zsh, copy `reg_aio_zsh_msys2_shell_example.template` into you MSYS2 install directory, rename it to `msys2_shell_zsh.cmd`, and edit it as appropriate. You will need to change `TEMPLATE_SHELL` in the install script to `zsh`.
- If you are using MSYS2 with a filesystem newer than 2016.05-2, this script will only generate one `.reg` file, which is all you need to create this context menu. You can delete this directory after merging the `.reg` file.

### Notes (For msys2 version with start_shell.cmd)
- For the MSYS2 version with `start_shell.cmd`, the script will use `bash_here_start_shell.template` for generating bash scripts.

- To use a shell other than `bash` (e.g. to use `zsh`), you might want to create a `start_shell_zsh.cmd` and `(mingw*/msys2)_shell_zsh.bat`. Then, you will need to modify either the template or the bash script generated to call the corresponding batch file.

## License
The MIT License (MIT) 2015 Yifei Zhang


text:
# Examples

## Example 1
* Link: [https://asciinema.org/a/253350](https://asciinema.org/a/253350)
* Command used: `asciinema rec -t "Example 1" -c ./example1.sh`

## Example 2
* Link: [https://asciinema.org/a/253352](https://asciinema.org/a/253352)
* Command used: `asciinema rec -t "Example 2" -i 2 -c ./example2.sh`
* Notes:
  * This one makes sure to trim any pauses longer than 2 seconds, so the `format c:` takes 8 seconds instead of 20. (The `-i 2` parameter).

repository: mmazur/asciinema-scripter

repo_name: mmazur/asciinema-scripter


text:
### [CVE-2021-46382](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-46382)
![](https://img.shields.io/static/v1?label=Product&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Version&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Vulnerability&message=n%2Fa&color=brighgreen)

### Description

Unauthenticated cross-site scripting (XSS) in Netgear WAC120 AC Access Point may lead to mulitple attacks like session hijacking even clipboard hijacking.

### POC

#### Reference
- https://drive.google.com/drive/folders/1NOIoT8yE_HDoLVYhchml5E2Za3Oo6V9Y?usp=sharing

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

repository: trickest/cve

gha_language: HTML

repo_name: trickest/cve


text:
# pointblank <IP_ADDRESS>00 (development version)

* The new `validate_rmd()` function can be used within an R Markdown document for **pointblank** validation testing within specialized validation code chunks inside an R Markdown document. To enable this functionality, `validate_rmd()` is called early within an R Markdown document to signal that validation should occur within specific code chunks having the `validate = TRUE` option set. Using pointblank validation step functions on data in these marked code chunks will flag overall failure if the stop threshold is exceeded anywhere. In the rendered HTML document, the successes and failures of validation tests are clearly shown with status buttons that reveal the otherwise hidden validation statements and any associated error messages.

* Added 24 expectation functions (e.g., `expect_col_exists()`, `expect_rows_distinct()`, `expect_col_schema_match()`, etc.) as complements of the 24 validation step functions; all of these can be used for **testthat** tests of tabular data with a simplified interface that exposes an easy-to-use failure `threshold`.

* Rewrote the internal `stock_stoppage()` and `stock_warning()` functions so that the generated error and warning messages match whether validation step functions are used directly on data or it is expectation functions that are being used.

* The default behavior of using validation step functions (e.g., `col_vals_lt()`) directly on data tables has been changed. Before, a single test unit failure would trigger a warning. Now, a single test unit failing results in an error. Going back to the earlier behavior now requires the use of `actions = warn_on_fail()` (a new helper function, which has a default `warn_at` threshold value of `1`) with each invocation of a validation step function. The `stop_on_fail()` helper function is also new in this release, and has a `stop_at` threshold parameter, also with a default of `1`.

* Console status messages when performing an interrogation now only appear in an interactive session. They will no longer appear during R Markdown rendering nor during execution of unattended scripts.

* A `knit.print()` method was added to facilitate the printing of the agent report table within an R Markdown code chunk.

# pointblank <IP_ADDRESS>

* Fixed implementation of the `col_vals_between()` and `col_vals_not_between()` step functions to work with `tbl_dbi` objects.

* Added the `scan_data()` function, which thoroughly scans any table data so you can understand it better (giving you an HTML report).

* Added the `get_agent_x_list()` function to provide easy access to agent intel

* Added the `get_agent_report()` function to give fine control over the agent's gt-based reportage; also, the agent's default print method is now that report (with default appearance options)

* Added the `get_sundered_data()` function to split the table data into 'pass' and 'fail' pieces after interrogation

* Added the `col_schema_match()` validation step function; it works in conjunction with a `col_schema` object (generated through the `col_schema()` function) to help determine whether the expected schema matches the target table.

* Added multilingual support to reports generated by agent validations and by those produced through the new `scan_data()` function

* More fully integrates the gt (for tables in reports) and blastula (for email production and delivery) packages

* Numerous fixes to ensure compatibility with tibble 3.0.0

# pointblank 0.3.0

The pointblank package has been changed significantly from the previous version in favor of consistency and simplicity, better reporting, and increased power. The internals have been extensively refactored and the API has accordingly gone through revisions.

## Breaking Changes

* The `focus_on()` function has been removed in favor of directly using a data object. This means that a single use of `create_agent()` can now only work on a single table at a time (`create_agent()` now has a `tbl` argument). Also, the input `tbl` can be a `data.frame`, a `tbl_df`, or a `tbl_dbi` object.

* The `preconditions` argument has changed and it can now be used to temporarily transform the table (i.e., transforming for a particular validation step). Previously, this option could only filter the input table but now it's possible to do useful things like joining in a table, adding columns, filtering rows, etc. The `preconditions` args now accepts a list of expressions that manipulate the table data.

* The `action_levels()` helper function is introduced to work with the `actions` argument (in every validation step function). This replaces the `warn_count`, `stop_count`, `notify_count`, `warn_fraction`, `stop_fraction`, and `notify_fraction` arguments. The function allows for evaluation of functions (given in the `fns` argument) as a reaction to exceeding thresholds specified in `warn_at`, `stop_at`, and `notify_at`.

* When using validation step functions directly on data (i.e., no use of `create_agent()`), data is now passed straight through after that validation step. The purpose now in that mode is to create warnings or throw errors if the `warn` or `stop` thresholds are exceeded.

* Across all **pointblank** validation step functions, the argument that stands for table columns has been normalized to `columns`.

* The `incl_na` argument, which was implemented in a few validation step functions, has been renamed to `na_pass` to better indicate its purpose (to consider any encountered `NA` values as passing test units), and, its use has been expanded to other relevant functions.

## New Features

* It's now possible to use `vars()` and certain tidyselect select helpers (e.g., `starts_with()`) when defining `columns` in the **pointblank** validation step functions.

* The `conjointly()` function is a new validation step function that allows for multiple rowwise validation steps to be performed for joint validity testing.

# pointblank 0.2.1

* Revisions on account of API changes in **tidyr** `1.0.0`

# pointblank 0.2.0

* Incorporates corrections related to API changes in **rlang** `0.2.0`

# pointblank 0.1

* First release


text:
You have a roadmap, which is the list of  `tasks`  that your team needs to complete. Each task in this list has a title, a start date, an end date, and a list of the people who will be working on it. You are given some  `queries`, each of which contains a specific person's name and a date. For each query that is made, you need to return the list of tasks on which that person will be working on the date specified in the query, sorted by the tasks' end dates. If their end dates are equal, then sort by the tasks' titles.

Example

For

```
tasks =
[["A", "2017-02-01", "2017-03-01", "Sam", "Evan", "Troy"],
 ["B", "2017-01-16", "2017-02-15", "Troy"],
 ["C", "2017-02-13", "2017-03-13", "Sam", "Evan"]]

```

and

```
queries =
[["Evan", "2017-03-10"],
 ["Troy", "2017-02-04"]]

```

the output should be
`roadmap(tasks, queries) = [["C"], ["B", "A"]]`.
On  `"2017-03-10"`  Evan only has task  `"C"`.
Troy will be working on two tasks on  `"2017-02-04"`,  `"A"`  and  `"B"`. We sort these tasks by their end dates.  `"A"`  has an end date of  `"2017-03-01"`  and  `"B"`  has an end date  `"2017-02-15"`. Since the end date for  `"B"`  is sooner than the end date for  `"A"`, we should return them as  `["B", "A"]`.

Input/Output

-   **[execution time limit] 4 seconds (py3)**

-   **[input] array.array.string tasks**

    A roadmap of the tasks your team is working on. Each  `tasks[i]`  describes one task:  `tasks[i][0]`  is its title,  `tasks[i][1]`  is its start date,  `tasks[i][2]`  is its end date, and all  `tasks[i][j]`  with  `j > 2`  are the names of the people who will work on this task. It's guaranteed that start date is situated before end date or is equal to it. Start date and end date are given in the format `"YYYY-MM-DD".

    _Guaranteed constraints:_
    `1 ≤ tasks.length ≤ 500`,
    `4 ≤ tasks[i].length < 20`.

-   **[input] array.array.string queries**

    A list of queries, where each  `queries[i][0]`  is the name of a person and  `queries[i][1]`  is the date for which you should find the answer.

    _Guaranteed constraints:_
    `1 ≤ queries.length ≤ 500`,
    `queries[i].length = 2`.

-   **[output] array.array.string**

    For each query in  `queries`, return the tasks on which the specified person will be working on the given date, ordered by the tasks' end dates ascendingly. If their end dates are equal, sort by the tasks' titles  lexicographically.

repository: M-Ekrim/codeSignal

repo_name: M-Ekrim/codeSignal


text:
# Section 23 Deploying an Angular App

## Deployment

### Lesson 339 - Module Introduction

After development, to make the application available to the public, we need to deploy it to a server, so people can visit using the domain from the web.

### Lesson 340 - Deployment Preparation & Steps

Deployment steps

1. Use and check environment variables
2. Polish and test the code
3. `ng build --prod` to use AoT compilation to build the code into dist directory
4. Deploy build artifacts to static host
   1. **Static Host** - a web server that is capable of serving HTML/JS/CSS, but not capable of running any server side language (PHP / NodeJS).

### Lesson 341 - Using Environment Variables

Environment Variables are available for all Angular projects created / built with the Angular CLI.

In the `environments` directory under `src`, there are 2 files - `environment.ts` and `environment.prod.ts`. These files contain a `environment` object of environment variables in the form of key-value pairs. Depending on the environment (prod vs dev), Angular CLI swaps between the files to provide the application with different environment variables.

To use the environment variables, import it from `src/environments/environment`, and Angular will swap the env settings base on the build environment.

In `app.component.ts`

```ts
import { environment } from 'src/environments/environment';
@Component({ ... })
export class AppComponent implements OnInit {
  ngOnInit(): void {
    ...;
    console.log(environment.production);
  }
}
```

### Lesson 342 - Deployment Example: Firebase Hosting

After building the prod distribution bundle using `ng build --prod`, the project is ready for deployment.

There are multiple web services that can host static web servers. Some examples are AWS S3 and Firebase. For this course, we use Firebase.

1. `npm install -g firebase-tools` - Install Firebase CLI
2. `firebase login` - Log into Firebase
3. `firebase init` - Connect the local project with a Firebase project
   1. Select Hosting to host the static website
   2. Select the Firebase project to connect to
   3. Set the public directory as the generated bundle folder under `dist`. I.e. `dist/course-project`
   4. Choose Yes to configure the project as a single page app
   5. Do not override the existing HTML file
4. `firebase deploy` - Deploy the firebase project
   1. This will return a URL that is hosting the application

### Lesson 343 - Server Routing vs Browser Routing

When deploying an Angular app, it's important to make sure the hosting server (like S3) is configured to always serve the index.html file. This is so that the server can redirect the route to Angular so it doesn't throw 404s because the server cannot find the route.

url: https://raw.githubusercontent.com/Dxyk/Angular-Udemy/0c756b1efc89ac743091ab42afbdb709d9014585/Section 23 Deploying an Angular App/README.md

repository: Dxyk/Angular-Udemy

repo_name: Dxyk/Angular-Udemy


text:
# Data and Page Generation

## Overview

Most components will consume and render some *data* (content and/or
configuration). For example, a link component might take a target href, some
link text, etc. and render a clickable link on the page. A "where to buy" component
might take a product ID and some credentials for an external service, and render
a list of online retailers. In an ordinary react app, such data might be passed
as props to the component. In Bodiless, components usually provide an interface to
edit the data they render, so the data are part of the application state.

Rather than requiring each component to manage its own state, Bodiless provides a
central store and serialization mechanism. Components are allocated a slot in
that central store where they can read and write the data they need. Each
component is responsible for the structure of its own data, while the store is
responsible for:
- serializing/deserializing data for all components to and from
JSON files on the edit server
- managing data which are shared among components,
- tracking changes globally (for example, to allow for undo/redo).

Note that the ability to edit content is limited to the edit environment. When
Bodiless renders the static site for production, the global store is effectively
immutable, and components simply consume the data therein.

## Flow

THe following diagram illustrates the flow of data in the edit environment.

![Data Flow](assets/data.jpg)

1. Component data are stored in json files on the (local or public) edit server.
   There is a single file for each component, and all data files for a given
   page are kept together in a single directory under `~/src/data/pages`.
   The name of each file corresponds to a key in the store which uniquely
   identifies the component to which the data belong.

2. The Gatsby development server -- or, more properly, the
   [Gatsby Filesystem Plugin](https://www.gatsbyjs.org/packages/gatsby-source-filesystem)
   -- watches the filesystem for changes in the data. When a change is detected,
   Gatsby executes a page query and sends the results over a websocket to
   the browser. There, they are provided as a "data" prop to the top level page
   component. For more information, see [the Gatsby tutorial](https://www.gatsbyjs.org/tutorial/part-four/).

3. The data provided by Gatsby consist of the contents of all json files in the
   directory which corresponds to the current page. These are processed into a
   key-value store (a JS map) keyed by the filename. The elements of this map
   are Mobx observables, so when they are updated they trigger any observer
   component to re-render. As a result, we explicity prevent update of the main
   page component, which would otherwise re-render itself and all children
   whenever a json file was modified. Note also that we compare the incoming
   data from Gatsby to the data already in the score, and only update if it has
   changed.

4. We refer to each element in the store as a "node", and each is represented by
   an instance of the `DefaultContentNode`
   class. A ContentNode is placed in a context which can be access by `useNode()`. The
   component can then read and write to the store via the node's data property.

5. The store also defines a Mobx _reaction_ which listens for changes. When a
   component updates its data. The reaction invokes a `BackendClient`
   to post the updated node to a ligthweight express server
   which in turn serialized the data to json.

6. The backend server is also responsible for managing the git repository which
   contains all code and content for the site, and exposes endpoints to commit
   changes and push them to an upstream remote _Note the client-side
   functionality to consume these endpoints is not yet implemented.

## Working with Data

### Creating Pages

By default, Gatsby creates a page for every component it finds in the `/src/pages/`
directory. Bodiless extends this to create pages recursively for every directory
located under `~/src/data/pages`. Thus, to create a new page,
simply create a new directory or subdirectory there. The URL path to your page
will be the same as its relative path under `~/src/data/pages`. For example, a
directory at `~/src/data/pages/foo/bar` will result in a page at
`http://mysite.com/foo/bar/`.

You can include an index.json file if you wish to specify
templates to use for the page level components of the given page and/or its subpages, eg:
```json
{
    "#template": "mytemplate",
    "#subpage_template": "mysubpagetemplate",
}
```
The templates should be specified as paths relative to `~/src/templates`
and should refer to a React page component, without the jsx extension.
If `#template` key is omitted in the page index.json, then Bodiless will use template specified
in `#subpage_template` of the closest ancestor of the page.
If closest ancestor does not have `#subpage_template`, then the default template (`~/src/templates/_default.jsx`)
will be used.

Alternatively, for one-off pages, you can include an "index.jsx" file containing
the page level component.

If you provide neither index.json nor a page component, 404 page will be returned.

This can/should be customized to fit the needs of your site.

### Page Data

In order to take advantage of the Bodiless data flow, your page-level component (or
template) should use `Page`, and
should export the default page query. the `default template`
is a good example and can be copied to form the basis of your pages.

Note that the Gatsby page query exported by the default template uses a GraphQL "fragment":

```javascript
export const query = graphql`
  query($slug: String!) {
    ...PageQuery,
    ...SiteQuery
  }
`;
```

The fragment is defined by Gatsby Theme Bodiless
and queries the contents of all json files in the directory corresponding to the
page. This can be used as-is, or the page query could be extended in case the
page requries additional data.

### Component Data

Page provides a root node to the node context which initializes the store and
provides a base ContentNode instance in to the Context.
Components that need a node will require a `nodeKey` prop, which will provide each of them with a
new ContentNode that is a child of the current one.

```javascript
export default (props: any) => (
  <Page {...props}>
    <Layout>
      <h1>Default Page</h1>
      <EditorFullFeatured nodeKey="editor" />
    </Layout>
  </Page>
);
 ```

 Note that the ContentNode instance does not store any data; it is simply an
 interface which points to a particular "slot" in the global store. The actual
 storage and retrieval of data are handled by the store's getter and setter
 methods which are injected into the ContentNode constructor (this happens
 within `GatsbyNodeProvider::getRootNode()`).

 While the store itself is a flat set of key-value pairs, the ContentNode interface
 provides a mechanism for creating a hierarchy of content nodes which mirrors
 the component hierarchy. The key names are actually built as *paths*, and `ContentNode`
 provides a `child()` method which will create a new node within the namespace of
 the parent. This allows compound components to name the nodes used by their children
 uniquely on the page by using the nodeKey prop:

 ```javascript
const Blurb =  ({ node }) => (
  <div>
    <header>
      <h1><Editable nodeKey="title" />
      <EditorFullFeatured nodeKey="subtitle" />
    </header>
    <EditorFullFeatured nodeKey="body" />
  </div>
);
```

repository: sastha/Bodiless-JS

repo_name: sastha/Bodiless-JS


text:
Sequence alignment of the ATAC-seq libraries with BWA.
======================================================

Why BWA ?
---------

While Bowtie 1 and 2 seem to be the usual aligners for ATAC-seq data, I happen
to be more familiar with the use of BWA, which I used extensively in my work on
the "_CAGEscan_" method, which uses paired-end alignment for transcritome
analysis.  Since the ATAC-seq libraries analysed here are paired-end, I am
sticking to BWA (`sampe`).  Also, I am using version 0.5.10 because I happen to
have genome indexes ready in this format; I do not expect major differences
with later versions, where the developmens were mostly focused on the `mem`
algorithm, not used here.

The commands below are to be pasted in the command-line shell of a computer
sufficiently powerful to align the libraries.

Alignment command
-----------------

```
alignOnGenome() {
  SAMPLE=$1
  GENOME=$2
  $BWA aln -t8 $GENOME -f ${SAMPLE}_R1.sai <(zcat ${SAMPLE}_R1.fastq.gz | fastx_trimmer -l 30)
  $BWA aln -t8 $GENOME -f ${SAMPLE}_R2.sai <(zcat ${SAMPLE}_R2.fastq.gz | fastx_trimmer -l 29)
  $BWA sampe   $GENOME    ${SAMPLE}_R1.sai ${SAMPLE}_R2.sai \
                           <(zcat ${SAMPLE}_R1.fastq.gz | fastx_trimmer -l 30) \
                           <(zcat ${SAMPLE}_R2.fastq.gz | fastx_trimmer -l 29) |
    samtools view -uS    |
    samtools sort        |
    tee $SAMPLE.bam      |
    samtools view -u -f2 |
    samtools rmdup - -   |
    samtools sort -n     |
    samtools fixmate - - |
    pairedBamToBed12     |
    awk '{OFS="\t"}{if($6=="+"){$9="0,128,0"};if($6=="-"){$9="128,0,128"};print}' |
    sort -V -k1,1 -k2,2n -k3,3 -k6 > $SAMPLE.bed
  rm ${SAMPLE}_R1.sai ${SAMPLE}_R2.sai
}
```

In brief:

 - The reads are aligned using `bwa aln` and `bwa sampe` with standard
   parameters, after trimming them to 30 bases for Read1 and 29 bases for
   Read2.  This is the read length on the MiSeq runs that we produced, and I want
   to minimise the technical differences when comparing our data with other
   datasets such as the ones from the original paper.

 - The output is converted to BAM format and sorted; a copy is kept in the
   filesystems, while the data flows in the next steps through Unix pipes.

 - All the non-properly aligned reads are discarded, and then PCR duplicates are
   removed based on the paired-end coordinates.

 - The pairs are re-sorted by name, and converted to BED12 format using our
   [pairedBamToBed12](https://github.com/Population-Transcriptomics/pairedBamToBed12)
   tool.  (Note that `pairedBamToBed12` generates many errors because of reads
   marked _properly paired_ by BWA on chrM, but where the next mate is maked
   unmapped (0x8).  This was unfortunately not corrected by `samtools fixmate`.

 - The color field is set to green for the positive strand and violet for the
   negative one.  (Cosmetic, to match default colors in the
   [ZENBU](http://fantom.gsc.riken.jp/zenbu/) browser;
   actually, sincce recently is not strictly necessary as ZENBU can now
   override the color field.)

 - The pairs are finally re-sorted by coordinate and saved on the disk.

Alignment on the human (hg19) and mouse (mm9) genomes
-----------------------------------------------------

To search for cross-contaminations, let's align all samples on both genomes,
regardless the nature of the presence of cells.

### Why old version of the genomes ?

As of today, The FANTOM5 data, that defines promoter regions, is still easier
to access on hg19.

### Align on mouse genome

Adjust the paths to your environment, enter the directory containing the
compressed sequence files, and run the loop below.

```
BWA=/home/plessy/snap/bwa_0.5.10/usr/bin/bwa
```

This is alignment of not-so heavy data so I did not spend time to optimise the
speed.  Read a paper, write a grant, take a coffee, go to bed, etc. while it
runs.

```
GENOME=/analysisdata/genomes/mm9_male.fa

for SAMPLE in $(basename -s _R1.fastq.gz *_R1.fastq.gz)
do
  alignOnGenome $SAMPLE $GENOME
done

prename 's/.bam/_mm9.bam/ ; s/.bed/_mm9.bed/' *[A-H][0-9][0-9].b[ae][md] Undetermined_S0_L001.b*
```

### Align on human genome

```
GENOME=/analysisdata/genomes/hg19_male.fa

for SAMPLE in $(basename -s _R1.fastq.gz *_R1.fastq.gz)
do
  alignOnGenome $SAMPLE $GENOME
done

prename 's/.bam/_hg19.bam/ ; s/.bed/_hg19.bed/' *Seq.b[ae][md]
```

### Alignment statistics

#### Proper pairs

```
for bed in *.bed
do
  printf "proper_pairs\t$(basename $bed .bed)\t"
  cat $bed |
  wc -l
done |
  tee ../$LIBRARY.dedupStats.log
```

#### Proper pairs (Q > 20)

```
for bed in *.bed
do
  printf "proper_pairs_Q20\t$(basename $bed .bed)\t"
  awk '$5 > 20' $bed |
  wc -l
done |
  tee ../$LIBRARY.dedupStatsQ20.log
```

#### Redundancy

```
for bam in *.bam
do
  printf "redundancy\t$(basename $bam .bam)\t"
  samtools rmdup $bam  /dev/null 2>&1 |
    grep library |
    cut -f 6 -d ' '
done |
  tee ../$LIBRARY.redundancy.log
```

#### Redundancy (on proper pairs)

```
for bam in *.bam
do
  printf "redundancy2\t$(basename $bam .bam)\t"
  samtools view -u -f2 $bam |
  samtools rmdup - /dev/null 2>&1 |
    grep library |
    cut -f 6 -d ' '
done |
  tee ../$LIBRARY.redundancy2.log
```


text:
# SurviveAmsterdam-backend

## Swift backend demo with Perfect.
This project it is a simply demo to show how to deploy a
REST API services using [Perfect](https://www.perfect.org) on Heroku. What is it Perfect?

 _Perfect is a web server and toolkit for developers using the Swift programming language to build applications and other REST services._

Starting from this Perfect [example](https://github.com/PerfectlySoft/Perfect-Heroku-Buildpack-Example) I decided to create very basic REST services for a my side project [SurviveAmsterdam](https://github.com/darthpelo/SurviveAmsterdam), to show you how is possible to create Backend and Mobile using only `Swift`.

The first scope of this REST APIs is very simple:
* Save Product information to the DB, only `String` properties
* Retrieve all the Products saved by a specific user
* Retrieve all the Products saved on the DB

### Disclaimer
1) I am not a backend developer, my technical background is iOS, hardware and firmware, so feel free to give me suggestions or create pull requests, to improve the handler.

2) Due to the purpose of this project, I create an instance of the database internally in the project (this is a SQLite DB). So after each deploy, the database is destroyed and recreated.

### To Do list
- [x] Delete function
- [ ] Save images on AWS S3
- [ ] Save DB before any deploys

## How to setup
[Here](http://mrchrisbarker.postach.io/post/implementing-swift-backend-server-using-perfect-on-heroku) you can found a great video tutorial about how to implement swift backend server using perfect on Heroku. I suggest this tutorial because is based on the Perfect example that I use as inspiration.

For this example, instead of work on [URL routing](https://github.com/PerfectlySoft/PerfectExample-URLRouting), we used the mustache template solution, to associate the handler witch the URL request and the JSON response. Every

## Server Operations
A Perfect server side project need only one source file `SAHandler.swift`, where you must configure the handler logics with the public function `PerfectServerModuleInit()` and some class which implement the `PageHandler` protocol. In this simple case there are three classes:
* one for the POST API *SAHandlerPost*
* one for the GET Products API *SAHandlerCount*
* the last to GET the number of all the Products saved on the DB *SAHandlerProducts*

```
public func PerfectServerModuleInit() {
    PageHandlerRegistry.addPageHandler("SAHandlerPost") { (r:WebResponse) -> PageHandler in
        // Create SQLite database.
        do {
            let sqlite = try SQLite(SAHandlerPost.trackerDbPath)
            try sqlite.execute("CREATE TABLE IF NOT EXISTS products (id INTEGER PRIMARY KEY, userid TEXT, name TEXT, place TEXT, time REAL)")
        } catch {
            print("Failure creating tracker database at " + SAHandlerPost.trackerDbPath)
        }

        return SAHandlerPost()
    }

    PageHandlerRegistry.addPageHandler("SAHandlerCount") { (r:WebResponse) -> PageHandler in
        return SAHandlerCount()
    }

    PageHandlerRegistry.addPageHandler("SAHandlerProducts") { (r:WebResponse) -> PageHandler in
        return SAHandlerProducts()
    }

    PageHandlerRegistry.addPageHandler(Constants.Mustache.handlerDelete) { (r:WebResponse) -> PageHandler in
        return SAHandlerDelete()
    }
}
```

### Mustache template

A mustache template represents the response (a JSON file) to a GET/PUT request from the client.

This is the `products.mustache` file:
```
{{% handler:SAHandlerProducts}}
{
  "products":[{{#products}}{"userid":"{{userid}}","name":"{{name}}","place":"{{place}}","time":{{time}}}{{^last}},{{/last}}{{/products}}]
}
```
In this example:
- the first line `{{% handler:SAHandlerProducts}}` indicates the handler class that manages the specific API
- the second part between the curly brackets is the template of the JSON response. In this specific case, the value of the *products* key is an array of products.

The object that represent this response in swift is an array of dictionaries `[[String:Any]]`:
`["userid":userid, "name":name, "place":place, "time":time, "last":false]`.

### Makefile
In the video tutorial is missed how to configure properly the `makefile` but based on to the Perfect example, it is very easy to understand how to:
- in the `install` section insert all the mustache & html files
- in the `target` section insert the correct path of the file with the `PerfectServerModuleInit()` implementation.
```
# Makefile for Perfect Server

TARGET = SurviveAmsterdamServer
OS = $(shell uname)
PERFECT_ROOT = /app/.delta/usr/src/perfect/PerfectLib
DEBUG = -g -Onone -Xcc -DDEBUG=1
SWIFTC = swift
SWIFTC_FLAGS = -frontend -c $(DEBUG) -module-cache-path $(MODULE_CACHE_PATH) -emit-module -I /app/.delta/usr/local/lib -I /app/.delta/usr/include -I /app/.delta/usr/include/x86_64-linux-gnu -I $(PERFECT_ROOT)/linked/LibEvent \
	-I $(PERFECT_ROOT)/linked/OpenSSL_Linux -I $(PERFECT_ROOT)/linked/ICU -I $(PERFECT_ROOT)/linked/SQLite3 -I $(PERFECT_ROOT)/linked/LinuxBridge -I $(PERFECT_ROOT)/linked/cURL_Linux
MODULE_CACHE_PATH = /tmp/modulecache
Linux_SHLIB_PATH = $(shell dirname $(shell dirname $(shell which swiftc)))/lib/swift/linux
SHLIB_PATH = -L$($(OS)_SHLIB_PATH)
LFLAGS = $(SHLIB_PATH) -luuid -lswiftCore -lswiftGlibc /app/.delta/usr/local/lib/PerfectLib.so -Xlinker -rpath -Xlinker $($(OS)_SHLIB_PATH) -shared

all: $(TARGET)

install:
	mv $(TARGET).so ../PerfectLibraries
	cp save.mustache ../webroot
	cp products.mustache ../webroot
	cp count.mustache ../webroot
	cp delete.mustache ../webroot
	cp index.html ../webroot
modulecache:
	@mkdir -p $(MODULE_CACHE_PATH)

$(TARGET): modulecache
	$(SWIFTC) $(SWIFTC_FLAGS) "SurviveAmsterdamServer/SurviveAmsterdamServer/SAHandler.swift" -o<EMAIL_ADDRESS>-module-name $@ -emit-module-path<EMAIL_ADDRESS>	clang++ $(LFLAGS<EMAIL_ADDRESS>-o<EMAIL_ADDRESS>
clean:
	@rm *.o
```

## Feedback

Use the [issue tracker](http://github.com/darthpelo/lelylan-ios/issues) for bugs.
<EMAIL_ADDRESS>or [Tweet](http://twitter.com/darthpelo) me for any feedback.

## Authors

(Alessio Roberto)[http://www.twitter.com/darthpelo)

repository: darthpelo/SurviveAmsterdam-backend

gha_language: Swift

repo_name: darthpelo/SurviveAmsterdam-backend


text:
# Quote-Generator

This is a simple web app based on HTML, CSS and Javascript.

- Fething the data in JSON format from the API https://type.fit/api/quotes and saving it in a variable.
- Dynamically inserting a random quote into the DOM on initial loading.
- User is able to load a new quote on a button 'New Quote" click.
- User is able to tweet the quote if he liked it on a 'Twitter' button click.

## About:

The webpage generates random quotes by famous personalities which can be obviously used for our personal motivation or as a tweet to inspire your community.

I had a lot of fun building this project and as usual I learned a lot from building this. Added some customisation to this project so.......

## Installation

1. Open your terminal and change the current working directory to the location where you want the cloned directory to be made.

```bash
$ cd path/to/your/folder/quote-generator/
```

2. Clone repository by typing the following in your terminal:

```bash
$ git clone git@github.com:WPBC/quote-generator.git
```

3. Open the index file to view the quote generator. All done.

### License

This package is released under the MIT license.

#### Feel free to fork and give a star for this project.

## Live Project

> Check out the results [here](https://daniellivingston32.github.io/Quote-Generator/)


text:
---
title: Ongoing 2022
description: Resume about me
show: "no"
# date: '2020-05-30'
# image: 'joint.jpg'
tags: [nofeed]
gerUrl: https://martinmueller.dev/projects-ger
pruneLength: 50
---

## Prowler

Prowler is a cli tool for performing and consulting AWS Security Assessment, Auditing, Hardening, Cost Saving and Incident Response. With more than 180 checks, Prowler provides the most comprehensive security checks offering for AWS. Easily deploy it with the [Prowler AMI](https://aws.amazon.com/marketplace/pp/prodview-jlwcdlc3weta6) or checkout the product video:

[![Prowler Video](https://img.youtube.com/vi/4JYaGylXEMc/0.jpg)](https://www.youtube.com/watch?v=4JYaGylXEMc)
(Click me :D)

## AWS Community Builder

2022 I was elected to an AWS Community Builder. It is really cool as I have the privilege to meet a lot of like-minded diverse builder <3. Let' Build!

## AWS APN Partner

I became an AWS APN Partner. An AWS APN Partner helps customers to find AWS solutions such like migrating to the cloud. You can read more about the APN programm [here](https://aws.amazon.com/partners/).

I am an certified AWS Professional Solution Architekt with many years of Cloud experience. With the following AWS technologies I worked most with:

- AWS CDK / CloudFormation / CodePipeline
- AWS EC2 / Lambda / EKS
- AWS S3 / EBS / EFS
- AWS StepFunctions

If you are interested in my services find write me<EMAIL_ADDRESS>
## Alfresco as a Platform

I work on an Alfresco as a Platform solution to simplify the deployments of Alfresco a lot. In fact you don't need to deploy anything anymore and just can use created Alfresco instances.

If you want to know more have a look at my [Alfresco Provisioner Post](https://martinmueller.dev/alf-provisioner-eng). I'm happy to create an test account for you!

## Happy Bootcamp in Germany (Ludwigslust)

I lead a bootcamp every Saturday and Sunday at 9 o'clock for group exercising. Sounds interesting?

Check out Ludwigslust Happy Bootcamp!

- FaceBook Group: https://www.facebook.com/groups/2547025218953959/
- Meetup: https://www.meetup.com/LuluHB
<!-- ![joint](joint.jpg) -->

gha_language: JavaScript


text:
# DFIRDeadDrop
Took some of my code from the nightshift C2 and created a quick client/server script to pull DFIR evidence off of a machine to a machine where the forensics work will occur. Also created an exe for Windows. This is only using http so be sure to password protect/encypt any evidence prior to transfer. Also if you want to change the keys for the DGA/hash function you can and if you want to change the port or URI you can do that too. I just used pyinstaller to make the exe. You will have to rerun pyinstaller to reflect the changes made to the python script.

Usage:

Running the server on your forensics machine and with a firewall rule open for http/8081

python3 deaddrop.py --server or deaddrop.exe --server

Running the client on the Windows machine you are pulling evidence

deaddrop.exe --client -h http://(ip or domain goes here) -f C:\path\to\file\here

license: Unlicense


text:
Bandits in the Loop
===================

[![PyPI version](https://badge.fury.io/py/bitl.svg)](https://badge.fury.io/py/bitl)
[![Build Status](https://travis-ci.org/tritas/bitl.svg?branch=master)](https://travis-ci.org/tritas/bitl)
[![Documentation Status](https://readthedocs.org/projects/bandits-in-the-loop/badge/?version=latest)](http://bandits-in-the-loop.readthedocs.io/en/latest/?badge=latest)

This module provides tools to design experiments and benchmark multi-armed bandits policies.
The idea is to be able to easily evaluate a new algorithm on multiple problems.
Either generate a simulated dataset and evaluate online, or load a real dataset and evaluate offline.

The idea is to have the following workflow:
```
Choose a policy/policies, initialize them

Load dataset or generate synthetic samples

Initialize environment and benchmark parameters (n_runs, results_folder, ...)

Run simulation and get report as plots, comparative HTML&LaTeX table
```

## Project directory structure
* `environment`: defines global parameters, features, feedback graphs etc.
* `policies`: examples policies for different classes of bandits
* `datasets`: fetch, load, generate data
* `evaluation`: setup and run evaluation and comparison loops
* `utils`: helper functions to generate plots and output formatted results (HTML, TeX)

## Installation

### From `pip`
```
pip install bitl
```
### From source

Download the source
```
git clone https://github.com/tritas/bitl.git
```

Install some dependencies
```
pip -r install requirements.txt
```

Install the package
```
python setup.py install
or
python setup.py develop (--user)
```

## Examples

The `examples` folder will showcase how to use the different functionality.

repository: tritas/bitl

repo_name: tritas/bitl


text:
---
book:
  author: Anne Chambers
  cover:
    name: granuaile-grace-omalley-irelands-pirate-queen.jpg
    tint_color: '#60616b'
  isbn10:<PHONE_NUMBER>
  isbn13: '9780717145829'
  publication_year: 2009
  title: 'Granuaile: Grace O''Malley - Ireland''s Pirate Queen'
  tags:
    - non-fiction
    - history
    - maritime
review:
  date_read: 2017-04-17
  rating: 4
---

Book was interesting, and I enjoyed reading it. It’s unfortunately still rare to read about notable historical women – and indeed, the text notes that Granuaile was largely erased within the annals of the Gaelic historical records. She’s a fascinating character – not just a pirate, but a strategist, politician and naval officer (of sorts).

Like many history books, I found it a little hard to follow the jumble of names, and I sometimes had to re-read bits to be sure I knew what was going on. It might benefit from an edit, and including a few more diagrams and maps. I knocked off a star for that.

branch_name: refs/heads/live

gha_language: Rust


text:
<!--

    Copyright (c) 2002-2017, the original author or authors.

    This software is distributable under the BSD license. See the terms of the
    BSD license in the documentation provided with this software.

    http://www.opensource.org/licenses/bsd-license.php

-->
# Description

JLine is a Java library for handling console input. It is similar in functionality to [BSD editline](http://www.thrysoee.dk/editline/) and [GNU readline](http://www.gnu.org/s/readline/) but with additional features that bring it in par with [ZSH line editor](http://zsh.sourceforge.net/Doc/Release/Zsh-Line-Editor.html). People familiar with the readline/editline capabilities for modern shells (such as bash and tcsh) will find most of the command editing features of JLine to be familiar.

JLine 3.x is an evolution of [JLine 2.x](https://github.com/jline/jline2).

[![Build Status: Linux](https://travis-ci.org/jline/jline3.svg?branch=master)](https://travis-ci.org/jline/jline3)
[![Build Status: Windows](https://ci.appveyor.com/api/projects/status/github/jline/jline3?svg=true)](https://ci.appveyor.com/project/gnodet/jline3)

# License

JLine is distributed under the [BSD License](http://www.opensource.org/licenses/bsd-license.php), meaning that you are completely free to redistribute, modify, or sell it with almost no restrictions.

# Documentation

* [demos](https://github.com/jline/jline3/wiki/Demos)
* [wiki](https://github.com/jline/jline3/wiki)
* [javadoc](https://www.javadoc.io/doc/org.jline/jline/)

# Forums

* [jline-users](https://groups.google.com/group/jline-users)
* [jline-dev](https://groups.google.com/group/jline-dev)

# Maven Usage

Use the following definition to use JLine in your maven project:

    <dependency>
      <groupId>org.jline</groupId>
      <artifactId>jline</artifactId>
      <version>3.5.1</version>
    </dependency>

JLine can also be used with more low-level jars:

    <dependency>
      <groupId>org.jline</groupId>
      <artifactId>jline-terminal</artifactId>
      <version>3.5.1</version>
    </dependency>
    <dependency>
      <groupId>org.jline</groupId>
      <artifactId>jline-reader</artifactId>
      <version>3.5.1</version>
    </dependency>

# Building

## Requirements

* Maven 3.3+ (prefer included maven-wrapper)
* Java 8+

Check out and build:

    git clone git://github.com/jline/jline3.git
    cd jline3
    mvn install

## Continuous Integration

* [Travis](https://travis-ci.org/jline/jline3)
* [AppVeyor](https://ci.appveyor.com/project/gnodet/jline3)

repository: veriktig/scandium

gha_language: Java

repo_name: veriktig/scandium


text:
# Using Generative Adversarial Networks for inversion of Geophysical data

This project explores the feasability of using Generative Adversarial Networks (GAN's) in the pipeline for solving Geophysical problems. This is an extension on the work done by  [Laloy et al., 2019][1]. Laloy in his paper explores the fesability of using GAN's to aid in the inversion process for geophysical problems. The idea is to learn the latent representation of the distribution of

## Table of contents
1. [Installation](#installation)
3. [Background Information](#Background-Information)
4. [Implementation](#implementation)

## Installation

```
$ git clone https://github.com/akhilnas/geophysical-inversion.git
$ cd geophysical-inversion/
$ sudo pip3 install -r requirements.txt
```

## Background Information

## Implementation

The Python Script with the base parameters is run with the following command in Terminal.

```
$ python main.py
```
To use different parameters to execute the training of the model the following command illustrates the modifiable parameters.

```
$ python main.py --n_epochs <Epoch> --batch_size <Batch Size> --lr <Learning Rate> --b1 <Adam Parameter> --b2 <Adam Parameter> --n_cpu <CPU Threads>
--latent_dim <Latent Dimension> --img_size <Image Size> --channels <Channels> --sample_interval <Image Sample Interval>
```

The Code can also be implemented with the help of Docker. For instruction on Docker Installation please see [here][1]. The Docker Implementation is available on [Docker Hub][2].

[1]: https://docs.docker.com/get-docker/
[2]: https://hub.docker.com/r/akhiln/gan

```
$ docker pull akhiln/gan
```

[1]: https://arxiv.org/abs/1812.09140