text:
# sysmon-config | A Sysmon configuration file for everybody to fork #

This is a Microsoft Sysinternals Sysmon configuration file template with default high-quality event tracing.

The file provided should function as a great starting point for system change monitoring in a self-contained package. This configuration and results should give you a good idea of what's possible for Sysmon. Note that this does not track things like authentication and other Windows events that are also vital for incident investigation.

      **[sysmonconfig-export.xml](https://github.com/SwiftOnSecurity/sysmon-config/blob/master/sysmonconfig-export.xml)**

**TEST VERSION THAT INCLUDES DNS LOGGING:** **[z-AlphaVersion.xml](https://github.com/SwiftOnSecurity/sysmon-config/blob/master/z-AlphaVersion.xml)**

Because virtually every line is commented and sections are marked with explanations, it should also function as a tutorial for Sysmon and a guide to critical monitoring areas in Windows systems.

Pull requests and issue tickets are welcome, and new additions will be credited in-line or on Git.

      **[See forks of this configuration](https://github.com/SwiftOnSecurity/sysmon-config/network)**

      **[See @ion-storm Threat Intelligence SIEM fork](https://github.com/ion-storm/sysmon-config)**

Note: Exact syntax and filtering choices are deliberate to catch appropriate entries and to have as little performance impact as possible. Sysmon's filtering abilities are different than the built-in Windows auditing features, so often a different approach is taken than the normal static listing of every possible important area.

## Use ##
### Install ###
Run with administrator rights
~~~~
sysmon.exe -accepteula -i sysmonconfig-export.xml
~~~~

### Update existing configuration ###
Run with administrator rights
~~~~
sysmon.exe -c sysmonconfig-export.xml
~~~~

### Uninstall ###
Run with administrator rights
~~~~
sysmon.exe -u
~~~~

## Required actions ##

### Prerequisites ###
Highly recommend using [Notepad++](https://notepad-plus-plus.org/) to edit this configuration. It understands UNIX newline format and does XML syntax highlighting, which makes this very understandable. I do not recommend using the built-in Notepad.exe.

### Customization ###
You will need to install and observe the results of the configuration in your own environment before deploying it widely. For example, you will need to exclude actions of your antivirus, which will otherwise likely fill up your logs with useless information.

The configuration is highly commented and designed to be self-explanatory to assist you in this customization to your environment.

### Design notes ###
This configuration expects software to be installed system-wide and NOT in the C:\Users folder.

If your users install Chrome themselves, you should deploy the [Chrome MSI](https://enterprise.google.com/chrome/chrome-browser/), which will automatically change the shortcuts to the machine-level installation. Your users will not even notice anything different.


text:
# Stock Span

The stock span problem is a financial problem where
we have a series of n daily price quotes for a stock
and we need to calculate the span of stock’s price
for all n days.

The span Si of the stock’s price on a given day i
is defined as the maximum number of consecutive
days just before the given day, for which the price
of the stock on the current day is less than or equal
to its price on the given day.

Now, you need to find out the span values for the
given number of days and their daily prices.

For example, if an array of 7 day's prices is
given as {100, 80, 60, 70, 60, 75, 85}, then the
span values for corresponding 7 days are {1, 1, 1, 2, 1, 4, 6} .

### Input Format:

Input consists of n+1 integers. The first integer corresponds
to n, the number of days.

The next n integers correspond to stock prices on days 1, 2...n.

### Output Format:

The output consists of n integers that correspond to the span values.

### Sample Input 1:

```
7
100
80
60
70
60
75
85
```

### Sample Output 1:

```
1
1
1
2
1
4
6
```

### Sample Input 2:

```
4
55
21
33
12
```

### Sample Output 2:

```
1
1
2
1
```

### Sample Input 3:

```
3
12
43
21
```

### Sample Output 3:

```
1
2
1
```

license: MIT

repository: KamalDGRT/ProgrammingPractice

branch_name: refs/heads/main

extension: md

gha_license_id: MIT

license_type: permissive

repo_name: KamalDGRT/ProgrammingPractice


text:
### This PR introduces the following changes

<!-- Remove individual sections if not needed. -->

<!-- Fix or feature that would cause existing functionality to not work as expected. -->
<!-- Used to identify changes which need to be flagged for major releases. -->
- **Breaking changes**:
  - Breaking change 1
  - Breaking change 2

<!-- List non-breaking change which fixes an issue. -->
- **Bug fixes**:
  - Bug fix 1
  - Bug fix 2

<!-- List non-breaking change which adds functionality. -->
- **New features**:
  - New feature 1
  - New feature 2

<!-- List non-breaking change which removes functionality. -->
- **Removed features**:
  - Removed feature 1
  - Removed feature 2

<!-- Optional: List tests added/removed to cover fixes or features -->
- **Test updates**:
  - Test 1

<!-- Optional:  List documentation updates to cover fixes or features-->
- **Documentation updates**:
  - Page 1

gha_language: HCL


text:
# Integration testing with resources

Integration testing on resources requires periodic jobs. To achieve this, batch
scripts are offered under the `batch_scripts` folder. Currently, there is a
script for SDSC Comet.

The script defines the following to execute the test:

- A `TEST` environment variable that contains the path to the test files to be
  executed. All test paths should be included and be space-separated.
-
    Example:
    ```
    TEST="radical.pilot/tests/integration_tests/test_resources/test_rm/test_slurm.py"
    ```

- Moves to the assigned folder for testing, which is the same as submitting the
  script, removes any prior copy of RP's repo, the previous virtual environment
  variable, and clones the `devel` branch only.

- Loads the necessary modules, creates and activates a virtual environment.
  Those lines should be updated for every resource. After the virtual
  environment's activation, the script installs RP and runs the tests. If one
  or more or those tests fail, the script runs a utility python file that
  creates an RP repository issue. This python file takes as arguments the name
  of the resource and the log filename. Update the resource name accordingly.

- Send a singal to Github with the state of the test via a `curl` command. For example:
```bash
   curl -H "Accept: application/vnd.github.everest-preview+json" \
    -H "Authorization: token $GIT_TOKEN" \
    --request POST \
    --data '{"event_type": "test_<resource>", "client_payload": { "text": "<state>"}}' \
    https://api.github.com/repos/radical-cybertools/radical.pilot/dispatches
```
Please see existing batch scripts for the data specifics.

- Finally, the script submits another job to the queue.

## Setup
Tests require that a Github token is set up and included in the `.bashrc` of the
account that runs the tests. On Summit instead of adding an environment variable,
change the `GIT_TOKEN` entry with your actual token.

Example:
```
export GIT_TOKEN=soimethignsomething
```

## Create a Github workflow

The last part is to create a Github workflow that provides information about the
state of the integration tests. This Github workflow file lives under
`.github/workflows`.

The template of such a file is:
```yaml
name: Resource Integration Test

on:
  repository_dispatch:
    types: [ test_<resource> ]
  schedule:
    - cron: '0 0 1 */1 *'

jobs:
  inter_jobs:
    runs-on: ubuntu-latest
    steps:
    - name: Check event
      if: github.event.client_payload.text
      run: |
        echo "Event text: ${{ github.event.client_payload.text }}"
        if [ ${{ github.event.client_payload.text }} == "success" ]
        then
            echo "Success"
        else
            echo "Failure"
            false
        fi
  periodic_jobs:
    if: github.event.client_payload.text == null
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v2
    - name: Set up Python 3.6
      uses: actions/setup-python@v2
      with:
        python-version: 3.6.13
    - name: Install dependencies
      run: |
        python -m pip install --upgrade pip
        pip install requests
    - name: Cron
      run: |
        tests/bin/radical-pilot-test-verify -y '<filename>' -d 7

```

This file receives a signal from outside, checks the payload and succeeds or
fails based on the payload. Also, it defines a monthly cron job that checks if
it received a signal the last week. If not, it fails the test for the specific
resource.

## Add a badge

It is necessary to add a badge in the main README file of RP for a resource
where integration tests are running. The badge looks like:
```
[![Resource Integration Tests](https://github.com/radical-cybertools/radical.pilot/actions/workflows/<filename>.yml/badge.svg)](https://github.com/radical-cybertools/radical.pilot/actions/workflows/<filename>.yml)
```

---

branch_name: refs/heads/devel

gha_language: Python

gha_license_id: NOASSERTION


text:
# Awesome Integrations

Here's a list of awesome xplr integrations that you might want to check out.

If none of the following integrations work for you, you can create your own and
[let us know][1].

## Categories

- [Editor][2]
- [Shell][3]
- [Security Tools][4]

## Editor

- [**vim-floaterm**][6] xplr integrated in vim-floaterm (Neo)vim plugin.
- [**xplr.nvim**][9] Opens xplr inside nvim, and hosts a msgpack client inside xplr.
- [**xplr.vim**][5] Pick files in Vim using xplr.

## Shell

- [**powerlevel10k**][7] Powerlevel10k prompt for xplr shell.

## Security Tools

- [**gpg-tui**][8] Import GPG certificates using xplr.

[1]: https://github.com/sayanarijit/xplr/discussions/categories/show-and-tell
[2]: #editor
[3]: #shell
[4]: #security-tools
[5]: https://github.com/sayanarijit/xplr.vim
[6]: https://github.com/voldikss/vim-floaterm#xplr
[7]: https://github.com/romkatv/powerlevel10k/blob/191d1b89e325ee3b6d2d75a394654aaf4f077a7c/internal/p10k.zsh#L4756-L4768
[8]: https://github.com/orhun/gpg-tui#importreceive
[9]: https://github.com/fhill2/xplr.nvim


text:
# TellaPeer

Ruby peer client for the CSETella P2P network.
CSE 552 Spring 2013
Keith Stone

## To run

Requires Ruby 2.0

```
bundle install
bundle exec thor client:start
```

Default serves on port 9000 and serves a GUID as the text.

Available options:
* --reply
    * Text to serve
* --log_level
    * DEBUG, INFO, WARN, FATAL
* --ttl
    * Message time to live
* --public_ip
    * Public IP to communicate over the protocol (Stops auto-find of this value)
* --port
    * Port to run our server on
* --local
    * Run the server on localhost

## Code structure

* client.thor
    * Handles reading of command line options and starting the various threads that need to run and starts the server.
* lib/tella_peer/message.rb
    * Subclass for all messages. Implements the marshalling and unmarshalling of the bits after they cross the wire. There is a implementation of each type of message that implements logic needed by those individual methods to pack and unpack themselves.
* lib/tella_peer/connection.rb
    * Models a high level wrapper around the actual socket connection. Contains the logic for what to do when receiving various messages as well as how to watch the socket in a threaded way.
* lib/tella_peer/connections.rb
    * Models the group of connections. Is responsible for keeping track of all currently open connections and to reach out to new potential connections. This class also hold most of the statistics my status page shows including overal message counts, potential connections, and active connections.

I was able to build a pretty solid test base around my own message creation, marshalling and unmarshalling. These were not to hard as they were essentually unit tests and could be stubbed out to test exactly the pieces I was unsure of. What was impossible to test and I think still broken is my interations with peers. Predicting how peers were going to drop or act was not something I could model out 100%. My answer to this was just logging and monitoring. When running log level DEBUG the output is very verbose so as to be able to see and fix issues that my tests missed.

## Web server

I have screen caps of my status page in the sinatra_server folder. My NAT is open on <IP_ADDRESS>:4567 but I am running on my laptop so I may not be available during the day as it comes to work with me.

branch_name: refs/heads/master


text:
# What's this
A simple script which dumps G Suite groups (mailing list) to JSON(machine-readable) and CSV(Excel-Readable) files.

# Preparation
## Create a Google Cloud project
Create a project on new Google Cloud Platform.

## Activate API
Activate "Groups Settings API".

## Create credentials
Create a new OAuth Client ID. You need both of client Id and client secret.

## Get token
Execute this:
`ruby authorize.rb <filename.json>` (filename is optional)

You'll be asked to input client id and client secret and get a URL. Open it with your web-browswer and you'll get an authrorization code. Return to the console and paste it.

These actions finally end up with a credentials file. It contains:

* client Id
* client secret
* refresh token

This is all you need to access Google API. The refresh token can generate a fresh token ANYTIME, and the refresh token NEVER expires, so you have to store it in a safe vault.

# Dump
Execute this:
`ruby dump.rb <your-domain.com> <filename.json>` (domain is required, filename is optional)

All the groups hosted on your G Suite domain will be dumped to:

* `dump_DOMAINNAME.json`
* `dump_DOMAINNAME_1.csv`
* `dump_DOMAINNAME_2.csv`

CSV files have two different formats.

repository: netebakari/dump-gsuite-group

repo_name: netebakari/dump-gsuite-group


text:
# Install Fonts using VBA

This is a simple class that can be added to an Excel VBA project, that will handle loading a custom font file when the workbook is opened.

## Setup

Add the font install class to a VBA project.

The ThisWorkbook module is an example of how to call the class when a Excel VBA project is first opened.

You should change the name of "MyFontFile.ttf" to be the name of your font file.

The code assumes the font file is in the same directory as the workbook.


text:
# ProfileConfig
A portable container housing my profile configuration files, namely those dealing with git, vim, and bash. Also houses a colection of simple utility bash scripts. I also recommend diff-so-fancy which I use as my git diff processor.

There are numerous dependencies that I have not documented but likely will
at some point.

Installation:
- run 'install.sh' from the repo root directory

repository: brandon-garcia/ProfileConfig

repo_name: brandon-garcia/ProfileConfig


text:
# TcpingSharp

[![Build status](https://ci.appveyor.com/api/projects/status/wlqxpimm4gpvbqhb?svg=true)](https://ci.appveyor.com/project/Elepover/tcpingsharp/build/artifacts)

A simple, lightweight TCP Ping tool written in C#.

## Downloads

Binaries available below are compiled from `master` branch for stability. To get the latest build, click the badge above.

![](https://ci.appveyor.com/api/projects/status/wlqxpimm4gpvbqhb?svg=true&branch=master&passingText=build%3A%20latest%20available&pendingText=build%3A%20in%20progress&failingText=build%3A%20using%20fallback%20build)

| OS | Architecture | Download |
| :----- | :----- | :----- |
| Windows | x86 | [Download](https://ci.appveyor.com/api/projects/Elepover/tcpingsharp/artifacts/win-x86.zip?branch=master) |
| Windows | x64 | [Download](https://ci.appveyor.com/api/projects/Elepover/tcpingsharp/artifacts/win-x64.zip?branch=master) |
| Windows | arm | [Download](https://ci.appveyor.com/api/projects/Elepover/tcpingsharp/artifacts/win-arm.zip?branch=master) |
| Windows | arm64 | [Download](https://ci.appveyor.com/api/projects/Elepover/tcpingsharp/artifacts/win-arm64.zip?branch=master) |
| OS X / macOS | x64 | [Download](https://ci.appveyor.com/api/projects/Elepover/tcpingsharp/artifacts/osx-x64.zip?branch=master) |
| Linux | x64 | [Download](https://ci.appveyor.com/api/projects/Elepover/tcpingsharp/artifacts/linux-x64.zip?branch=master) |
| Linux | arm | [Download](https://ci.appveyor.com/api/projects/Elepover/tcpingsharp/artifacts/linux-arm.zip?branch=master) |
| Linux | arm64 | [Download](https://ci.appveyor.com/api/projects/Elepover/tcpingsharp/artifacts/linux-arm64.zip?branch=master) |

## Features

- Customizable timeout
- Ping multiple IPs of a single domain simutaneously
- Unix-like PING output
- Two pinging modes

## Usage

```
usage: tcping target [options]
  target: tcping target, can be a domain, hostname or IP
  options:
    -h, -?, --help          Print this message.
    -p, --port target_port  Set target port, default value is 80.
    -t, --timeout timeout   Set timeout, default value is 5000 (ms)
    -m, --multiple          Allow pinging multiple IPs simultaneously.
    -a, --animate           Animate output into a single line, incompatible
                              with -m option.
    -s, --stats             Periodically print statistics.
    -r, --rtt               Instead of showing time spent establishing a
                              TCP connection (~2x RTT), show half of the
                              value (~actual RTT).
```

## Implementation

To avoid flooding the server with TCP connection requests, TcpingSharp will wait for 1 second before trying again.

To establish a TCP connection, these requests are sent/received:

```
1 -> [SYN]
2 <- [SYN,ACK]
3 -> [ACK]
4 -> [FIN,ACK]
5 <- [FIN,ACK]
6 -> [ACK]
```

### Without `-r` option

TcpingSharp measures the time

- from **the first SYN packet is sent**
- to **the last ACK packet is sent**

Which is the time cost to establish a TCP connection and in theory, the sum of two client <-> server transmissions' and 5 packets' (1-2 and 3-5) time. Then TcpingSharp closes the connection safely, if established successfully.

### With the `-r` option

TcpingSharp still measures the same time as running without `-r` option, but the result time is always **divided in half**. So every result is the average time of two client <-> server transmissions in 5 packets.

### Accuracy

TcpingSharp is currently unable to give an accurate time of a single round-trip. Since even with the `-r` option, the average value is consisted of two different transmissions.

The first RTT is measured by:

```
-> [SYN]
<- [SYN,ACK]
```

The second RTT is measured by:

```
-> [ACK]
-> [FIN,ACK]
<- [FIN,ACK]
```

repository: itsnotyoutoday/tcpingsharp

repo_name: itsnotyoutoday/tcpingsharp


text:
# tg-channel-watcher
[![telethon version](https://img.shields.io/badge/telethon-v<IP_ADDRESS>-blue.svg)](https://github.com/LonamiWebs/Telethon)
[![license](https://img.shields.io/github/license/xates/tg-channel-watcher.svg)](LICENSE)
[![last commit](https://img.shields.io/github/last-commit/google/skia.svg)](https://github.com/xates/tg-channel-watcher/commits/master)

## Introduction

This project is the combination of two simple Python 3 scripts that I
originally wrote for myself, and then I decided to make public so that everyone
could make use of and improve them.

Any contribution to the project is highly appreciated and welcome, however,
please _try to_ follow the [PEP8](https://pep8.org) specification in order to
keep the code clean, tidy and consistent.

The two components of **tg-channel-watcher** (which are also the two original
separate projects) are:

- **forwarder**: checks all the messages sent in a list of channels and
forwards (to yourself or to someone else) the ones matching a set of regexes,

- **downloader**: downloads all the media (images and/or documents) sent in a
list of channels, except for the formats specified in a blacklist.

## Getting started

After you have cloned the repository, run the command `pip3 install -r
requirements.txt` to install all the required dependencies.
You may want to use a [virtual environment](http://bit.ly/1fhx5mq) for that.

Before running the script, create a configuration file with your settings using
the file [`example.ini`](example.ini) as reference.
Then, run the script with the configuration file as first parameter, like that
`./main.py config.ini`, or without any parameter to use the `config.ini` file
in the same directory.

repository: psyhredkiy/tg-channel-watcher

repo_name: psyhredkiy/tg-channel-watcher


text:
# SkyWalking Kubernetes Event Exporter

[![GitHub stars](https://img.shields.io/github/stars/apache/skywalking-kubernetes-event-exporter.svg?style=for-the-badge&label=Stars&logo=github)](https://github.com/apache/skywalking-kubernetes-event-exporter)
[![Twitter Follow](https://img.shields.io/twitter/follow/asfskywalking.svg?style=for-the-badge&label=Follow&logo=twitter)](https://twitter.com/AsfSkyWalking)

[![Check](https://github.com/apache/skywalking-kubernetes-event-exporter/actions/workflows/build-and-test.yaml/badge.svg)](https://github.com/apache/skywalking-kubernetes-event-exporter/actions/workflows/build-and-test.yaml)

<img src="http://skywalking.apache.org/assets/logo.svg" alt="Sky Walking logo" height="90px" align="right" />

SkyWalking Kubernetes Event Exporter is able to watch, filter, and send Kubernetes events
into [Apache SkyWalking](https://github.com/apache/skywalking) backend, afterwards, SkyWalking associates the events
with the system metrics and thus gives you an overview about how the metrics are effected by the events.

## Configurations

Configurations are in YAML format, or config map if running inside Kubernetes,
otherwise, [the default configuration file](assets/default-config.yaml) will be used if there is neither `-c` option
specified in the command line interface nor config map is created in Kubernetes.

All available configuration items and their documentations can be found
in [the default configuration file](assets/default-config.yaml).

## Deployments

Go to [the /deployments](deployments) directory, modify according to your needs,
and `kubectl apply -f skywalking-kubernetes-event-exporter.yaml`.

You can also simply run `skywalking-kubernetes-event-exporter start` in command line interface to run this exporter from
outside of Kubernetes.

# Download

Go to the [download page](https://skywalking.apache.org/downloads/) to download all available binaries, including macOS,
Linux, Windows.

# Contact Us

* Mailing list<EMAIL_ADDRESS>Send email
  to [dev-subscribe@skywalking.apache.org](mailto:dev-subscribe@skywalking.apache.org), follow the reply to subscribe
  the mail list.
* Join `skywalking` channel at [Apache Slack](http://s.apache.org/slack-invite). If the link is not working, find the
  latest one at [Apache INFRA WIKI](https://cwiki.apache.org/confluence/display/INFRA/Slack+Guest+Invites).
* Twitter, [ASFSkyWalking](https://twitter.com/ASFSkyWalking)
* QQ Group: 901167865(Recommended), 392443393
* [bilibili B站 视频](https://space.bilibili.com/390683219)

# License

[Apache 2.0 License.](LICENSE)


text:
## 06.02.2018 - 1.4.2
* Added default splashscreens for Android & iOS.
* Added default icons icons for Android & iOS.
* Added default favicon.
* Added default Cordova plugin configuration.
* Modified the config.xml to match the plugin configurations.

## 30.01.2018 - 1.4.1
* Updated dependencies.
* Rearranged README.md to be more clear.

## 19.01.2018 - 1.4.0
* Updated Framework7 & Framework7-vue dependencies.
* Framework7 is using v2.0.6 and Framework7-vue is using v2.0.0
* Refactor and code formatting.
* Added and connected Framework7-vue's kitchen sink app available on [GitHub](https://github.com/framework7io/framework7-vue)

## 15.01.2018 - 1.3.3
* Updated Vue from v2.2.4 to v2.5.13
* Added axios as a dependency to make API calls.
* Added vue2-google-maps to be able to use google maps inside the apps.
* Made a demo page that is accessible from the main view and that displays a working google map.

## 12.01.2018 - 1.3.2
* Re-arranged existing components into a more modular setup to serve as an example.
* Made a custom style change demonstration on the main-view component. Using the now in place 7-1 pattern for custom scss styles.
* Slight refactor of files and code.

## 11.01.2018 - 1.3.1
* Added support for the 7-1 patter for scss styles although the styles that come with the template haven't been correctly placed in their respective .scss files according to the template, wait until release 1.3.2 for this.
* Added additional npm script `npm run dev:browser` will open un a dashboard for visualizing the webpack build status and other information while in development mode and also opens up a development server that has live-reload capabilities.
* Added the /platforms and /www folders to the .gitignore file for easier commits, these files will only be used for development and production of an app.

## 11.01.2018 - 1.3.0
* Information update for this fork.
* Updated package.json with additional scripts and dependencies.
* Added cordova-plugin-whitelist.

## 29.11.2017 - 1.2.1
* Updated dependencies.
* Fixed device.js related errors.

## 23.07.2017 - 1.2.0
* Updated dependencies.

## 10.05.2017 - 1.1.3
* Changed uglify-js dependency version.
* Removed source-map-loader dependency.

## 04.05.2017 - 1.1.2
* Added support for scss to one page component.
* Chokidar dependency added to template's package.json.

## 25.04.2017 - 1.1.1
* Added whitespace support to command paths. You can use folder names with whitespace now.

## 25.04.2017 - 1.1.0
* Added static folder for static assets. Static folder directly copies to www folder on compile time also static folder automatically sync with www/static when you are using live-reload.
* Directory structure changed.
* Dependency added: `chokidar`

## 25.04.2017 - 1.0.12
* Provided compatibility with latest webpack-dev-server update. Added ip:port to public argument for live reload.
* The double nails were standardized as single nails in `beforedep.js` and `hookers.js`.

## 07.04.2017 - 1.0.11
* Fixed Device_router.html has been made compatible with Android < 4.4.0.
* Fixed key to vue lists
> Thanks for **konstantin-popov** for fixes.
* Added .editorconfig and files edited with this config.

## 14.03.2017 - 1.0.10
* Added epipebomb for linux and mac os.
* Fixed webpack ^2.2.1 support
* Fixed buffer size for webpack outputs
* Updated uglify js version to latest (for ES6 features)

## 17.01.2017 - 1.0.4
* Dev-server supports hot-module-replacement now!

## 16.01.2017 - 1.0.1
* Supports phonegap now!
* Template now uses `webpack-dev-server` for live-reload. So cordova-plugin-browsersync dependency dropped.
* `webpack-dev-server` dependency added.
* You can use `cordova (run|emulate) (ios|android|browser) -- --lr` now. lr means `live-reload`.
* Added `before_deploy` hook. You can check at: [beforedep.js](template_src/hooks/beforedep.js)
* [hookers.js](template_src/hooks/hookers.js) changed.
* [CordovaDeviceRouter.js](template_src/webpack/dev_helpers/CordovaDeviceRouter.js) added. In `live-reload` mode, server injects the `cordova.js` file according to where you are connecting.
* [device_router.html](template_src/webpack/dev_helpers/device_router.html) added. In `live-reload` mode, this file routes you to right location.

repository: ArmandoHerra/VCWF-Template

repo_name: ArmandoHerra/VCWF-Template


text:
# Chip-8-Emulator

A CHIP-8 emulator in C++

CHIP-8 is an interpretted programming language developed by Joseph Weisbecker in the mid 70s and was initally used on the COSMAC VIP and Telmac 1800 8-bit microcomputers to make game programming easier. CHIP-8 programs are run using a CHIP-8 virtual machine.

## Compiling and Running
Nothing special is needed other than SDL2.

You can run it with:
```
./chip-8 <ROM file>
```

## TODO
*	~~Fix SDL implementation~~ Done
*	Add audio
*	Add function keys
*	Add Super Chip-8 opcodes
* Use function pointers instead of switch case
* Improve graphics using filters

## References
Some helpful resources I used

- http://www.multigesture.net/articles/how-to-write-an-emulator-chip-8-interpreter/
- http://en.wikipedia.org/wiki/CHIP-8
- http://devernay.free.fr/hacks/chip8/C8TECH10.HTM


text:
+++

date = "2020-04-14"
title = "web animation"
draft = false
categories = [ "web design"]
tags = ["web design", "lists", "html", "css", "animation"]

+++

**Making things move on your page.**

<!--more-->

## TRANSFORMS & TRANSITIONS

Transform your content by moving, scaling, and rotating. Transitions allow those changes to happen over time.

*   [w3schools - css3 2d transforms](https://www.w3schools.com/css/css3_2dtransforms.asp "opens in new tab")
*   [w3schools - css 3d transforms](https://www.w3schools.com/css/css3_3dtransforms.asp "opens in new tab")
*   [w3schools - transitions](https://www.w3schools.com/css/css3_transitions.asp "opens in new tab")
*   [shay howe - transforms](http://learn.shayhowe.com/advanced-html-css/css-transforms/#transform-syntax "opens in new tab")
*   [thoughtbot - transitions and transforms](https://robots.thoughtbot.com/transitions-and-transforms "opens in new tab")
*   [css reference - transitions](https://cssreference.io/transitions/ "opens in new tab")
*   [easing generator](https://matthewlein.com/tools/ceaser "opens in new tab")

## CSS ANIMATION

Program your content to move around and do interesting things.

*   [w3schools - css3 animation](https://www.w3schools.com/css/css3_animations.asp "opens in new tab")
*   [tutsplus intro to css3 animation](https://webdesign.tutsplus.com/tutorials/a-beginners-introduction-to-css-animation--cms-21068 "opens in new tab")
*   [css animation for beginners](https://robots.thoughtbot.com/css-animation-for-beginners "opens in new tab")
*   [animation properties explanation from css-tricks](https://css-tricks.com/almanac/properties/a/animation/)
*   [css animation weekly newsletter](http://weekly.cssanimation.rocks/)

## TRANSFORM & ANIMATE LIBRARIES & TOOLS

A few prebuilt tools to manipulate your content instead of starting from scratch.

*   [animate.css](https://daneden.github.io/animate.css/ "opens in new tab")
*   [hover.css](https://ianlunn.github.io/Hover/ "opens in new tab")
*   [obnoxious.css](http://tholman.com/obnoxious/ "opens in new tab")
*   [animista](http://animista.net/ "opens in new tab")
*   [magic animations](https://www.minimamente.com/example/magic_animations/ "opens in new tab")
*   [css animate.com](http://cssanimate.com/ "opens in new tab")
*   [css animation kit](http://angrytools.com/css/animation/ "opens in new tab")
*   [animation cheatsheet](http://www.justinaguilar.com/animations/index.html "opens in new tab")

---

As always, if you have additional resources or find a broken link, please contact me.

repository: chad-bennett/start

repo_name: chad-bennett/start


text:
<link rel="stylesheet" type="text/css" href="/assets/css/asciinema-player.css" />

# Setup

## Install from [PyPI](https://pypi.org/project/meerschaum/)

```bash
python -m pip install --upgrade meerschaum
```

??? info "Optional dependencies"
    Meerschaum will auto-install packages as you use them (into a virtual environment, to preserve your base environment).

    If you'd rather install all of its dependencies at installation, you can request the `full` version:
    ```bash
    python -m pip install --upgrade meerschaum[full]
    ```

## Choose a database

1. **Pre-configured DB**

    If you have [Docker](https://www.docker.com/get-started), you can run the pre-configured [Meerschaum stack](/reference/stack/).

    ```bash
    mrsm stack up -d db
    ```

    The keys for this pre-configured [connector](/reference/connectors/) are `sql:main`.

    ??? example "Watch an example"
        <asciinema-player src="/assets/casts/stack.cast" size="small" preload="true" rows="10"></asciinema-player>

2. **Built-in SQLite DB**

    The keys for the built-in SQLite database are `sql:local`.

3. **Use your own DB**

    You can [connect your own database](/reference/connectors/#creating-a-connector) with:

    ```bash
    mrsm bootstrap connector
    ```

    ??? example "Watch an example"
        <asciinema-player src="/assets/casts/bootstrap-connector.cast" size="small" preload="true"></asciinema-player>

## Connect to your instance

![Meerschaum instance prompt](/assets/screenshots/prompt.png){ align=left } Open the Meerschaum shell with `mrsm` or `python -m meerschaum`.

By default, your prompt's instance is the database `sql:main` from the [pre-configured stack](/reference/stack/).

To test the connection, run the command `mrsm show pipes`. A successful connection should return the message:

💢 No pipes to show.

??? tip "Change your instance"

    Your default back-end [instance connector](/reference/connectors/#instances-and-repositories) is `sql:main`. You can see other configured connectors (e.g. `sql:local`) with `mrsm show connectors`.

    To temporarily change instances, open the `mrsm` shell and run the command `instance` followed by the keys.

    ```bash
    mrsm
    instance sql:local
    ```

    To permanently change your default instance:

    1. Open your configuration with `mrsm edit config`.
    2. Navigate to the key `instance:` at the bottom of the file.
    3. Edit the keys to the [`SQL` or `API` connector](/reference/connectors/#instances-and-repositories) of your new instance.

    ??? example "Watch an example"
        <asciinema-player src="/assets/casts/change-instance.cast" size="small" preload="true"></asciinema-player>

If you've successfully connected, try [building a pipe](bootstrap/) to get that data flowing!

repository: brendanblanchard/Meerschaum

repo_name: brendanblanchard/Meerschaum


text:
# Quaid
A single-page webapp that decrypts text using only client-side JavaScript.

# Demo
[Demo page](https://sowbug.github.io/quaid/). Enter the passphrase `correct horse battery staple` into the text box.

# Use case
Hopefully you're reading this before the following actually happens to you.

* You're on vacation, and [your Uber driver takes off with your electronics](https://fymhotsauce.rocks/blogs/news/my-uber-driver-robbed-me-so-i-took-uber-to-court-and-won).
* You purchase a replacement phone with the cash in your pocket, but you realize that you don't have the 2FA tokens needed to get back into your digital identity.

# Overview
* Create a text file containing your secrets -- [Google backup codes](https://support.google.com/accounts/answer/1187538?hl=en), Dropbox 2FA OTP secret, emergency phone numbers, etc.
* Encrypt the file using GPG's symmetric encryption (`gpg -c -a secrets.txt`).
* Reformat the resulting `secrets.txt.asc` with `< secrets.txt.asc ./asc_to_js > ciphertext.js`.
* Use this project to generate a single-page webapp (`./build_spa`).
* Publish the resulting file, `docs/index.html`, on a webserver somwhere.
* Next time you lose your phone far from home, visit the site and decrypt with whatever passphrase you used to encrypt the file.

As long as you have access to a modern web browser, you should be able to recover
the text file. All you need to do is remember the URL and the passphrase.
Hopefully your URL was HTTPS so you know nobody messed with it in transit, and you control
the webserver so you can be confident nobody altered the resources at rest.

# Acknowledgements

* Thanks to https://github.com/openpgpjs/openpgpjs for the main functionality of this project.
* Inspired by the original version of the movie [Total Recall](http://www.imdb.com/title/tt0100802/). [Relevant scene](https://www.youtube.com/watch?v=a5ztlWzi0kY).

repository: sowbug/quaid

repo_name: sowbug/quaid


text:
[ ]()Security Groups
--------------------

A common new-user issue with OpenStack is failing to set an appropriate security group when launching an instance. As a result, the user is unable to contact the instance on the network.

[Security groups are sets of IP filter rules that are applied to an instance's networking. They are project specific, and project members can edit the default rules for their group and add new rules sets. All projects have a "default" security group, which is applied to instances that have no other security group defined. Unless changed, this security group denies all incoming traffic.]()

### [ ]()General Security Groups Configuration

The `nova.conf` option `allow_same_net_traffic` (which defaults to `true`) globally controls whether the rules apply to hosts that share a network. When set to `true`, hosts on the same subnet are not filtered and are allowed to pass all types of traffic between them. On a flat network, this allows all instances from all projects unfiltered communication. With VLAN networking, this allows access between instances within the same project. If `allow_same_net_traffic` is set to `false`, security groups are enforced for all connections. In this case, it is possible for projects to simulate `allow_same_net_traffic` by configuring their default security group to allow all traffic from their subnet.

![[Tip]](resources/BFBF620F8D90A3D218E3CB86AA150E79.png)Tip

As noted in the previous chapter, the number of rules per security group is controlled by the `quota_security_group_rules`, and the number of allowed security groups per project is controlled by the `quota_security_groups` quota.

### [ ]()End-User Configuration of Security Groups

Security groups for the current project can be found on the OpenStack dashboard under **Access & Security**. To see details of an existing group, select the **edit** action for that security group. Obviously, modifying existing groups can be done from this **edit** interface. There is a **Create Security Group** button on the main **Access & Security** page for creating new groups. We discuss the terms used in these fields when we explain the command-line equivalents.

From the command line, you can get a list of security groups for the project you're acting in using the `nova` command:

    $ nova secgroup-list
    +---------+-------------+
    | Name    | Description |
    +---------+-------------+
    | default | default     |
    | open    | all ports   |
    +---------+-------------+

To view the details of the "open" security group:

    $ nova secgroup-list-rules open
    +-------------+-----------+---------+-----------+--------------+
    | IP Protocol | From Port | To Port | IP Range  | Source Group |
    +-------------+-----------+---------+-----------+--------------+
    | icmp        | -1        | 255     | <IP_ADDRESS>/0 |              |
    | tcp         | 1         | 65535   | <IP_ADDRESS>/0 |              |
    | udp         | 1         | 65535   | <IP_ADDRESS>/0 |              |
    +-------------+-----------+---------+-----------+--------------+

These rules are all "allow" type rules, as the default is deny. The first column is the IP protocol (one of icmp, tcp, or udp), and the second and third columns specify the affected port range. The fourth column specifies the IP range in CIDR format. This example shows the full port range for all protocols allowed from all IPs.

When adding a new security group, you should pick a descriptive but brief name. This name shows up in brief descriptions of the instances that use it where the longer description field often does not. Seeing that an instance is using security group `http` is much easier to understand than `bobs_group` or `secgrp1`.

As an example, let's create a security group that allows web traffic anywhere on the Internet. We'll call this group `global_http`, which is clear and reasonably concise, encapsulating what is allowed and from where. From the command line, do:

    $ nova secgroup-create \
           global_http "allow web traffic from the Internet"
    +-------------+-------------------------------------+
    | Name        | Description                         |
    +-------------+-------------------------------------+
    | global_http | allow web traffic from the Internet |
    +-------------+-------------------------------------+

This creates the empty security group. To make it do what we want, we need to add some rules:

    $ nova secgroup-add-rule <secgroup> <ip-proto> <from-port> <to-port> <cidr>
    $ nova secgroup-add-rule global_http tcp 80 80 <IP_ADDRESS>/0
    +-------------+-----------+---------+-----------+--------------+
    | IP Protocol | From Port | To Port | IP Range  | Source Group |
    +-------------+-----------+---------+-----------+--------------+
    | tcp         | 80        | 80      | <IP_ADDRESS>/0 |              |
    +-------------+-----------+---------+-----------+--------------+

Note that the arguments are positional, and the `from-port` and `to-port` arguments specify the allowed local port range connections. These arguments are not indicating source and destination ports of the connection. More complex rule sets can be built up through multiple invocations of `nova secgroup-add-rule`. For example, if you want to pass both http and https traffic, do this:

    $ nova secgroup-add-rule global_http tcp 443 443 <IP_ADDRESS>/0
    +-------------+-----------+---------+-----------+--------------+
    | IP Protocol | From Port | To Port | IP Range  | Source Group |
    +-------------+-----------+---------+-----------+--------------+
    | tcp         | 443       | 443     | <IP_ADDRESS>/0 |              |
    +-------------+-----------+---------+-----------+--------------+

Despite only outputting the newly added rule, this operation is additive:

    $ nova secgroup-list-rules global_http
    +-------------+-----------+---------+-----------+--------------+
    | IP Protocol | From Port | To Port | IP Range  | Source Group |
    +-------------+-----------+---------+-----------+--------------+
    | tcp         | 80        | 80      | <IP_ADDRESS>/0 |              |
    | tcp         | 443       | 443     | <IP_ADDRESS>/0 |              |
    +-------------+-----------+---------+-----------+--------------+

The inverse operation is called `secgroup-delete-rule`, using the same format. Whole security groups can be removed with `secgroup-delete`.

To create security group rules for a cluster of instances, you want to use SourceGroups.

SourceGroups are a special dynamic way of defining the CIDR of allowed sources. The user specifies a SourceGroup (security group name) and then all the users' other instances using the specified SourceGroup are selected dynamically. This dynamic selection alleviates the need for individual rules to allow each new member of the cluster.

The code is structured like this: `nova secgroup-add-group-rule <secgroup> <source-group> <ip-proto> <from-port> <to-port>`. An example usage is shown here:

    $ nova secgroup-add-group-rule cluster global-http tcp 22 22

The "cluster" rule allows SSH access from any other instance that uses the `global-http` group.

repository: mtint/STFC-SCD-OPENSTACK

path: /HOWTO/Security Groups - OpenStack Operations Guide.md

repo_name: mtint/STFC-SCD-OPENSTACK


text:
# Note Taker App
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
## Description
- This app allows the user to write notes onto a server that is then saved onto a json file (server side), the user can then later come back and click on any of the notes to retrieve their saved information.
## Table of Contents
- [Installation](#installation)
- [Usage](#usage)
- [Credits](#credits)
- [Questions](#questions)
- [License](#license)
## Installation
- Go to the deployed app using this link ->
## Usage
- The user will first click on the home button titled "Get Started", the user will then be redirected to the page to write, save, and retrieve prior notes
## Credits
- Express , UUID
## Questions
- github.com/Pherenzia
- You may reach me here at for any qeustions<EMAIL_ADDRESS>## License
- MIT

repository: Pherenzia/Note-Taker

repo_name: Pherenzia/Note-Taker


text:
---
layout: default
---

# 1995-02-02 - Ending the Crusade

## Header Data

From: Nathan Zook<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: 22a65a2c7d626acd23a8d1c4dbfc790564ed8ea1527bc88e0464d2e270e23bf3

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1995-02-02 01:00:02 UTC

Raw Date: Wed, 1 Feb 95 17:00:02 PST

## Raw message

```
{% raw  %}From: Nathan Zook<EMAIL_ADDRESS>Date: Wed, 1 Feb 95 17:00:02 PST
To<EMAIL_ADDRESS>Subject: Ending the Crusade
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

Here is an idea to tone down the dos crusade for those of you with procmail
and a vindictive streak:  Instead of routing all of those messages to
/dev/null, forward them back to the authors, perhaps with a notice that the
message appears to have been mistakenly routed to you?

Nathan

{% endraw %}
```

## Thread

+ Return to [February 1995](/archive/1995/02)

+ Return to "[Nathan Zook <nzook@bga.com>](/authors/nathan_zook_nzook_at_bga_com_)"
+ Return to "[Rick Busdiecker <rfb@lehman.com>](/authors/rick_busdiecker_rfb_at_lehman_com_)"

+ 1995-02-02 (Wed, 1 Feb 95 17:00:02 PST) - Ending the Crusade - _Nathan Zook<EMAIL_ADDRESS>  + 1995-02-02 (Wed, 1 Feb 95 18:21:10 PST) - [Re: Ending the Crusade](/archive/1995/02/4f6a0509fffb046d114b5f7041e15ea34cca99fc22b1bcbfe722ffc2def7b973) - _Rick Busdiecker<EMAIL_ADDRESS>


text:
---

title: 'Interrogative project management: A four-sonnet sequence on task-level discovery'
layout: post

---
Project management requires much asking
Of clients and coders for more info
So that a PM can get to tasking
in Basecamp, Jira, or maybe Trello.
But before productive action can start
five basic questions need some addressing.
These _W_ queries allow the heart
of a project to beat without stressing.

When newspapers report on the here'n now
All are asked the Five: _who, what, when, where, why_
(Plus the anti-alliterative _how_)
To separate truth from black-hearted lie.
These words can help PM pre-production
workflows work without any obstruction.

## Who/What
Who is requesting the task to be done?
Hopefully one with authorizing writ.
Nothing’s worse than delivering a ton
of code your main stakeholder ne'er green-lit.
But approved work needs timely assigning
by the PM, who does the budget checks,
to a single assignee, defining
who will do what; What's what we'll ask for next.
What needs to be done is estimated.
Both effort and outcome identified
We get on the same page by what’s stated
The approval process is also eyed.
With the who and the what firmly nailed down
PMs can move on to When-n-where Town.

## When/Where
Slotting in work depends when it is due,
But also when can we start on our code?
The budget might not allow immediate action,
So know when to begin and when to be done.
And since we don't code like cowboys risking,
When can this work be sent to production?
And where is production code sent whisking?
Where will staging code endure construction?
And there are more wheres that need to be known,
Like where will we track task conversation
And where to track time as efforts are sown.
(Untracked time causes PM frustration.)
With all aforementioned finally filed,
Seek out the tamers of projects most wild.

## Why/How
Because it was there, Mallory labored
Summiting peaks as if they were hillsides
But change for change’s sake is like a jaybird
Spinning through space on a whimsy joyride.
Why work is sought out is crucial to find;
The code must target an issue to thrive.
Issues mean metrics to keep top of mind
To suss out success once code work goes live.
Lastly is how, as in _How is this solved?_
Let your dev team handle all this thinking
After, you should understand what's resolved;
Give space at first for solution linking.
Your workflow will flourish when firstly fed
these basic questions, John knowingly said.


text:
This example demonstrates the privacy levels between parent and child classes.

Below is the `psuedo code` C++ code for the inherited access modifiers.

```cpp
class ParentClass
{
    public:
        int var1;

    protected:
        int var2;

    private:
        int var3;
};

class ChildClass_1 : public ParentClass
{
    // var1 is public for this class
    // var2 is protected for this class
    // var3 cannot be accessed from this class
};

class ChildClass_2 : protected ParentClass
{
    // var1 is protected for this class
    // var2 is protected for this class
    // var3 cannot be accessed from this class
};

class ChildClass_3 : private ParentClass
{
    // var1 is private for this class
    // var2 is private for this class
    // var3 cannot be accessed from this class
};
```

repository: Prathmeshrjoshi/CppND-practice

repo_name: Prathmeshrjoshi/CppND-practice


text:
# Contributing

Contributions are welcome, and they are greatly appreciated!
Every little bit helps, and credit will always be given.

## Environment setup

Nothing easier!

Fork and clone the repository, then:

```bash
cd aria2p
make setup
```

> NOTE:
> If it fails for some reason,
> you'll need to install
> [PDM](https://github.com/pdm-project/pdm)
> manually.
>
> You can install it with:
>
> ```bash
> python3 -m pip install --user pipx
> pipx install pdm
> ```
>
> Now you can try running `make setup` again,
> or simply `pdm install`.

You now have the dependencies installed.

You can run the application with `pdm run aria2p [ARGS...]`.

Run `make help` to see all the available actions!

## Tasks

This project uses [duty](https://github.com/pawamoy/duty) to run tasks.
A Makefile is also provided. The Makefile will try to run certain tasks
on multiple Python versions. If for some reason you don't want to run the task
on multiple Python versions, you can do one of the following:

1. `export PYTHON_VERSIONS= `: this will run the task
   with only the current Python version
2. run the task directly with `pdm run duty TASK`

The Makefile detects if a virtual environment is activated,
so `make` will work the same with the virtualenv activated or not.

## Development

As usual:

1. create a new branch: `git checkout -b feature-or-bugfix-name`
1. edit the code and/or the documentation

**Before committing:**

1. run `make format` to auto-format the code
1. run `make check` to check everything (fix any warning)
1. run `make test` to run the tests (fix any issue)
1. if you updated the documentation or the project dependencies:
    1. run `make docs-serve`
    1. go to http://localhost:8000 and check that everything looks good
1. follow our [commit message convention](#commit-message-convention)

If you are unsure about how to fix or ignore a warning,
just let the continuous integration fail,
and we will help you during review.

Don't bother updating the changelog, we will take care of this.

## Commit message convention

Commits messages must follow the
[Angular style](https://gist.github.com/stephenparish/9941e89d80e2bc58a153#format-of-the-commit-message):

```
<type>[(scope)]: Subject

[Body]
```

Scope and body are optional. Type can be:

- `build`: About packaging, building wheels, etc.
- `chore`: About packaging or repo/files management.
- `ci`: About Continuous Integration.
- `docs`: About documentation.
- `feat`: New feature.
- `fix`: Bug fix.
- `perf`: About performance.
- `refactor`: Changes which are not features nor bug fixes.
- `style`: A change in code style/format.
- `tests`: About tests.

**Subject (and body) must be valid Markdown.**
If you write a body, please add issues references at the end:

```
Body.

References: #10, #11.
Fixes #15.
```

## Pull requests guidelines

Link to any related issue in the Pull Request message.

During review, we recommend using fixups:

```bash
# SHA is the SHA of the commit you want to fix
git commit --fixup=SHA
```

Once all the changes are approved, you can squash your commits:

```bash
git rebase -i --autosquash master
```

And force-push:

```bash
git push -f
```

If this seems all too complicated, you can push or force-push each new commit,
and we will squash them ourselves if needed, before merging.

license: ISC

gha_license_id: ISC


text:
---
name: ADR
about: Suggest/record an architecture decision record
title: ''
labels: ADR
assignees: ''

---

# Title

## Status

> What is the status, such as proposed, discussed, accepted, rejected, deprecated, superseded, etc.?

## Context

> What is the issue that we're seeing that is motivating this decision or change?

## Decision

> What is the change that we're proposing and/or doing?

## Consequences

> What becomes easier or more difficult to do because of this change?

Easier:
*

More Difficult:
*

repository: orange-cloudfoundry/paas-templates

branch_name: refs/heads/manual-drop

gha_language: Shell

repo_name: orange-cloudfoundry/paas-templates


text:
# Scout-Quest
This software is meant for games with a big group of people. All you need is a Webserver running PHP and a MySQL server for the database.
The system is based on https://github.com/wpuehringer/quest/ but is completely rewritten to eliminate the use of a java based application. The UI is designed with Semantic UI (https://github.com/Semantic-Org/Semantic-UI) and should work on most platforms.

Setup:
1. Put all the files on your webserver and fill in the connect.php file with your DB login data
2. Create a Database and import the sampleDB.sql
3. Use phpMyAdmin or similar tools to get rid of the sample data in case you don't need it.
4. Add your Groups with the help addGroup.php
5. Add your Participants and assign them to their group using addUser.php
6. Add your Qusets with addQuests.php
7. Activate and Deactivate Quests using activateQuests.php
8. Assign your Users to active Quests using assignQuest.php
9. Close quests and distribute points using closeQuest.php
10. View all active quests on a public screen with openQuests.php - use your browsers zoom settings to adjust the layout for your screen resolution - sorry for that
11. view the points of all groups using showPoints.php

This system will be tested at the Upperaustrian "LAK 2016 - Challange accepted!"

If you are planing on using this system please give me some feedback!
Feel free to contact me if you have troubles.

2016 Daniel Glocker


text:
# Peniophora sambuci (Pers.) Burt, 1926 SPECIES

#### Status
SYNONYM

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

#### Published in
Ann. Mo. bot. Gdn 12: 233 (1926)

#### Original name
null

### Remarks
null

repository: mdoering/backbone

path: /life/Fungi/Basidiomycota/Agaricomycetes/Hymenochaetales/Schizoporaceae/Hyphodontia/Hyphodontia sambuci/ Syn. Peniophora sambuci/README.md

repo_name: mdoering/backbone


text:
## groper: simple Python command line and config file options

Python programs that run from the command line often times contain code that looks like this:

    DEFAULT_PORT = 8080
    def main():
        if len(sys.argv) > 2 and sys.argv[1] == '-p':
            port = int(sys.argv[2])
        else:
            port = DEFAULT_PORT

While technically correct, this code does not scale well. The next evolution of this code would use either getopt, argparse or optparse to help abstract parsing command line options. However, at some point the number of options would grow so large that a configuration file might be warranted and ConfigParser is introduced.

However, the complexity of the code grows as this happens. To use (argparse|optparse|getopt) + ConfigParser effectively and correctly the program needs to:

*   Parse the command line args, and figure out where the configuration file resides
*   Read the configuration file and combine it with the command line args (the command line args take precidence)
*   If not all required command line args are specified, print program usage and exit.
*   The wrapper around ConfigPraser needs to provide a simple way to access the data
*   Some values need to have defaults, which should be used if the config file and the command line args do not specify one

Implementing this logic in each Python program is redundant. However, it seems that most programs do it this way. groper provides a simple unified interface for reading command line args, configuration files, setting defaults, printing program usage and even generating sample configuration files. Here is an example of its usage:

    from groper import define_opt, init_options, options

    define_opt('server', 'host', type=unicode, cmd_name='host', cmd_short_name='h', default='localhost')
    define_opt('server', 'port', type=int, cmd_name='port', cmd_short_name='p', default=8080)
    define_opt('server', 'daemon', type=bool, cmd_name='daemon', cmd_short_name='d')

    # init_options() will automatically read this file. If you don't use a config file, simply comment this out
    #define_opt('meta', 'config', type=unicode, cmd_only=True, cmd_name='config', cmd_short_name='c', is_config_file=True)

    # If specified: program usage will be printed and returned
    # The cmd_group param means that when the usage is printed, this option will be specified in its own group
    define_opt('meta', 'help', type=bool, cmd_only=True, cmd_name='help', cmd_short_name='H', is_help=True, cmd_group='help')

    def main():
        init_options()
        print options.server.host
        print options.server.port
        print options.server.daemon

    if __name__ == '__main__':
        main()

That's it. You can use the options object from any module in which you import it to get access to the program settings. The *default* argument to the define_opt() function also provides a great feature: you can now specify all your constants as configurable options that can be read from the configuration file.

As if that wasn't enough, you can even generate sample configuration files:

    from groper import define_opt, init_options, options

    define_opt('server', 'host', type=unicode, cmd_name='host', cmd_short_name='h', default='localhost')
    define_opt('server', 'port', type=int, cmd_name='port', cmd_short_name='p', default=8080)
    define_opt('server', 'daemon', type=bool, cmd_name='daemon', cmd_short_name='d')

    print generate_sample_config()

Hopefully you will find groper useful. It can be installed via PyPi:

    $ pip install groper

groper is licensed under the MIT license and is Copyright (c) 2011 Igor Partola

repository: ipartola/groper

repo_name: ipartola/groper


text:
---
layout: page
title: ELF64
description: 2021 - ongoing, C-Stem
img: assets/img/elf64.jpg
importance: 2
category: Tools
---

## ELF 64 parser in C

---

Writing code to parse an ELF binary seems to be something that I have to do at least once every two years.
As part of my `C-Stem` initiative, I decided to package my C implementation into a library.

The library supports symbol lookups (but does not parse relocations... yet).

I might be able to get my hands on my Go and Rust implementations and publish them here as well.

## Code

Github repository


text:
# Slide In on Scroll
Project completed for the 30 day vanilla JS coding challenge. Set images to slide in from the sides of the page as the user scrolls down on the page.

## License
This project is licensed under the Apache License - see the LICENSE file for details

## Acknowledgments
JavaScript30 by Wes Bos provided challange, starting HTML, starting styling, starting javascript, images and additional reference material. - https://javascript30.com/

repository: CannyBangbang/Slide-In-on-Scroll

repo_name: CannyBangbang/Slide-In-on-Scroll


text:
[![Gem Version](https://badge.fury.io/rb/vagrant-butcher.png)](http://badge.fury.io/rb/vagrant-butcher)

# Vagrant::Butcher

If you're using Vagrant with the Chef-Client provisioner, e.g. for creating cookbooks, it creates a client and a node on the Chef server. Once you destroy the VM, both the client and node will be kept on the server, which may cause problems if you fire up the same VM again.

This gem attempts to correct that.

## Installation

Installation will depend on whether you're using bundler or not.

### If you're using Bundler

Add this line to your cookbook's Gemfile:

    gem 'vagrant-butcher'

And then execute:

    $ bundle

### If you're not using bundler

You have to install this plugin via Vagrant:

    $ vagrant gem install 'vagrant-butcher'

Explanation for that is found on the [Vagrant Plugins Documentation](http://vagrantup.com/v1/docs/extending/types.html)

## Usage

The plugin is loaded automatically once installed.

By default, the gem looks for the Chef server settings on `$HOME/.chef/knife.rb`. This can be overrdidden by setting:

    Vagrant::Config.run do |config|
      config.vm.provision :chef_solo do |chef|
        chef.knife_config = '/path/to/knife.rb'
      end
    end

## Contributing

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

repository: pikesley/vagrant-butcher

repo_name: pikesley/vagrant-butcher


text:
# log's Standards

Yes, we have those!
This repository is the collection of all the standard practices we employ at [*log*](https://log.pt). It is a work in continuous progress and, hopefully, it will always be better yet never finished.
This is our vision on things, and in all cases it is a mix of several sources and experience, which is itself a mix of other sources. Of the 0.001% of "originality" that you may find here, consider it our gift to you.

Although we do not pretend to teach anyone, a Loguiano should follow these best practices in every code he/she builds so as to improve efficiency within the team.

We have a simple site in the hoven to make things more *pretty* and readable. But in the mean time feel free to browse the repository and read whatever you feel like.

## Using this stuff

It goes without saying, that you may use any part of this collection of documents as you please. We are making it open to give back and learn from others through sharing.

## Sources

As we've said, most of what is here is not original. In every section you will find a list of sources that contributed to its final result. Some sources are also distributed along the documents for particular insight on a specific guideline.

To all of these amazing people we say:

    Thank You

## Contributions

Contribuitons are most welcome in their natural form of Pull Requests, the following guidelines are just to keep things following with ease:
* If it's something new, make sure it's not hidden somewhere in here already or that we didn't dismiss it for something else.
* Make sure you supply some arguments for the benefits/advantages your change provides.

**Special thanks to:** [@goblindegook](https://github.com/goblindegook), [@s3rgiosan](https://github.com/s3rgiosan), [@xipasduarte](https://github.com/xipasduarte), [@RicCastelhano](https://github.com/RicCastelhano) and [@Narayon](https://github.com/Narayon).

repository: log-oscon/Standards

repo_name: log-oscon/Standards


text:
# Continuous K6 Performance Tests on K8s

Continuous K6 performance and load tests on Kubernetes. We will spin up an InfluxDB to
store our load test data and Grafana to display. The K6 load test will continuously be
executed using a CronJob.

## Usage with plain YAML

```bash
# first we deploy the demo application deployment
$ kubectl apply -f continuous-nginx.yaml

# next you can deploy the K6 stack with InfluxDB and Grafana
$ kubectl create namespace k6
$ kubectl apply -f continuous-k6k8s.yaml -n k6

# open Grafana and import on of these K6 load test dashboards
# - see https://grafana.com/dashboards/2587
# - see https://grafana.com/grafana/dashboards/4411
$ open http://localhost:3000
```

## Usage with Pulumi

Just for fun, I also created Pulumi infrastructure as code to create the Continuous K6 load test stack.

```bash
# to create the Pulumi code from scratch type this
$ pulumi new kubernetes-typescript --force
$ kube2pulumi typescript -f continuous-k6k8s.yaml

# and fire up the K6 stack
$ pulumi up

# open Grafana and import on of these K6 load test dashboards
# - see https://grafana.com/dashboards/2587
# - see https://grafana.com/grafana/dashboards/4411
$ open http://localhost:3000
```

## Create retention policy for InfluxDB

If you run the load tests continuously, you may want to create a retention policy to cleanup the test data from time to time.

```bash
# connect to the influx pod
$ kubectl exec -it pod/influxdb -- /bin/sh

$ influx
$ create retention policy "k6_1d" on "k6" duration 1d replication 1 default
$ exit
```

## Adhoc K6 load test with custom Docker image

```bash
# build and push the K6 load test image
$ docker build -t k6-nginx-test .
$ docker tag k6-nginx-test lreimer/k6-nginx-test
$ docker push lreimer/k6-nginx-test

# run the image as a pod
# be sure to pass the --restart flag, otherwise the containers gets restarted
$ kubectl run k6-nginx-test --image lreimer/k6-nginx-test --restart=Never --attach
$ kubectl delete pod/k6-nginx-test
```

## Maintainer

M.-Leander Reimer (@lreimer<EMAIL_ADDRESS>
## License

This software is provided under the MIT open source license, read the `LICENSE` file for details.


text:
# Electrolux Wellbeing

[![GitHub Release][releases-shield]][releases]
[![License][license-shield]](LICENSE)

[![hacs][hacsbadge]][hacs]
[![Project Maintenance][maintenance-shield]][user_profile]
[![BuyMeCoffee][buymecoffeebadge]][buymecoffee]

Get the status from your Electrolux devices connected to Wellbeing. **Currently, only fetching of values are supported**

### Supported and tested devices

- Pure A9 Air Purifier

{% if not installed %}

## Installation

1. Click install.
1. In the HA UI go to "Configuration" -> "Integrations" click "+" and search for "Wellbeing".

{% endif %}

[buymecoffee]: https://www.buymeacoffee.com/JohNan
[buymecoffeebadge]: https://img.shields.io/badge/buy%20me%20a%20coffee-donate-yellow.svg?style=for-the-badge
[commits-shield]: https://img.shields.io/github/commit-activity/y/JohNan/wellbeing.svg?style=for-the-badge
[commits]: https://github.com/JohNan/homeassistant-wellbeing/commits/main
[hacs]: https://hacs.xyz
[hacsbadge]: https://img.shields.io/badge/HACS-Custom-orange.svg?style=for-the-badge
[license-shield]: https://img.shields.io/github/license/JohNan/wellbeing.svg?style=for-the-badge
[maintenance-shield]: https://img.shields.io/badge/maintainer-%40JohNan-blue.svg?style=for-the-badge
[releases-shield]: https://img.shields.io/github/release/JohNan/wellbeing.svg?style=for-the-badge
[releases]: https://github.com/JohNan/homeassistant-wellbeing/releases
[user_profile]: https://github.com/JohNan


text:
# Install Harbor Locally

This document will discuss installing the Harbor container image registry on a workstation.

Requirements:

* This document assumes OSX
* Brew is installed
* [Docker for Desktop for OSX](https://docs.docker.com/docker-for-mac/install/) is installed

## Kind

Kind stands for "Kubernetes in Docker" and is an easy way to get a local Kubernetes cluster running.

*Note: Docker for Desktop also provides Kubernetes functionality, but in this example we are using Kind, which will deploy k8s into Docker*

Install kind with brew.

```
brew install kind
```

Create a kind based cluster.

*Note the use of "extraPortMappings"*

```
cat <<EOF | kind create cluster --config=-
kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
nodes:
- role: control-plane
  kubeadmConfigPatches:
  - |
    kind: InitConfiguration
    nodeRegistration:
      kubeletExtraArgs:
        node-labels: "ingress-ready=true"
        authorization-mode: "AlwaysAllow"
  extraPortMappings:
  - containerPort: 80
    hostPort: 80
    protocol: TCP
  - containerPort: 443
    hostPort: 443
    protocol: TCP
EOF
```

Once that kind cluster is created we can see k8s nodes.

```
$ kubectl get nodes
NAME                 STATUS   ROLES    AGE     VERSION
kind-control-plane   Ready    master   2m31s   v1.17.0
```

## Contour Ingress

[Contour](https://projectcontour.io/) is an advanced open source ingress system supported in part by VMware.

Create Contour ingress:

```
kubectl apply -f https://projectcontour.io/quickstart/contour.yaml
```

Patch it:

```
kubectl patch daemonsets -n projectcontour envoy -p '{"spec":{"template":{"spec":{"nodeSelector":{"ingress-ready":"true"},"tolerations":[{"key":"node-role.kubernetes.io/master","operator":"Equal","effect":"NoSchedule"}]}}}}'
```

Contour should be running.

*Note: kubectl is provided by Docker for Desktop*

```
$ kubectl get pods -n projectcontour
NAME                       READY   STATUS      RESTARTS   AGE
contour-54df6b8854-dlsnr   1/1     Running     0          83s
contour-54df6b8854-m2w8k   1/1     Running     0          83s
contour-certgen-n78dz      0/1     Completed   0          83s
envoy-kwr8x                2/2     Running     0          10s
```

## Install Helm

Getting helm is quite easy:

```
brew install helm
```

## Install Harbor

Now that we have Kubernetes and Helm, installing Harbor is straight forward, though there are many options available in the Helm chart. We will not be making any changes and use the defaults provided.

Add the Harbor Helm repository.

```
helm repo add harbor https://helm.goharbor.io
```

And install Harbor:

```
helm install local-harbor harbor/harbor
```

After a few minutes, there should be several Harbor k8s objects, such as pods.

```
$ k get pods
NAME                                                 READY   STATUS    RESTARTS   AGE
local-harbor-harbor-chartmuseum-bd9c45cbc-gwkbj      1/1     Running   0          58s
local-harbor-harbor-clair-865c9bc5db-cvbk8           1/2     Running   2          58s
local-harbor-harbor-core-64479f8d85-rkqm2            1/1     Running   0          58s
local-harbor-harbor-database-0                       1/1     Running   0          58s
local-harbor-harbor-jobservice-8448b58df7-pgknp      1/1     Running   0          58s
local-harbor-harbor-notary-server-5bd9f5d966-56kk6   1/1     Running   0          58s
local-harbor-harbor-notary-signer-5fbfb48945-l2x54   1/1     Running   0          58s
local-harbor-harbor-portal-756d5d7d9d-xlv2g          1/1     Running   0          58s
local-harbor-harbor-redis-0                          1/1     Running   0          58s
local-harbor-harbor-registry-57989b6446-w8vd8        2/2     Running   0          58s
```

## Access Harbor

Add a hostname to your `/etc/hosts` file.

```
<IP_ADDRESS> core.harbor.domain
```

Now open a browser session to http://core.harbor.domain/harbor

```
login: admin
password: Harbor12345
```

At this point Harbor is available for local use.

## Delete Harbor and Kind

To remove everything added:

```
helm uninstall local-harbor
kind delete cluster
```

Then shutdown Docker for Desktop.


text:
---
layout: default
title: Inquire Bluetooth service record on Windows
tags: bluetooth service record windows utility
comments: true
---

Linux distros have excellent built-in support for inquiring characteristics of Bluetooth devices around you, using hcitool and sdptool. The closest thing on Windows is the [Bluetooth Inquiry Record Verifier](https://msdn.microsoft.com/windows/hardware/drivers/devtest/bluetooth-inquiry-record-verifier) tool (sdpverify.exe) that ships with [Windows Driver Kit](https://developer.microsoft.com/windows/hardware/windows-driver-kit) (WDK). Beware, WDK is a rather large download.

![Service Record Verifier](/assets/img/bt-service-record-utility-windows.png)


text:
# bittorrent vs HTTP

Here's a comparison between the use of bittorrent vs HTTP for data transfers.

## Basic Facts

Bittorrent is a way for a client to figure out what peers that have a piece of
a particular file so that it can get pieces from those machines instead of
getting the entire thing from a single (central) place.

## Transfer Speed

With **HTTP** a file is presented in a single stream by the HTTP server. The
transfer is then typically done the fastest way the remote server, the network
and the client manage. After the initial "request", HTTP reaches max speed
pretty quickly. A typical such transfer is limited by the narrowest network
condition along the way, or by the server being overloaded by requests from
many clients. Some network operators do funny things, so a client can actually
get higher transfer performance by connecting multiple times and transferring
parts of the data in several simultaneous connections.

**Bittorrent** on the other hand requests "random" parts of the file from N
number of peers and it can typically download several parts at once from
different sources. A client will also soon start to hand out parts of the file
that it has already downloaded, to other peers that want to download that same
file. Bittorrent downloads tend to start slow, and increase in speed during
the transfer and slow down again towards the end when it only gets a few
remaining pieces to get.

## Streaming

Things that must be sent and received in a specific order, such as a live
audio or video stream, is problematic to distribute via bittorrent given the
current design.

While clients (probably) could ask for chunks in a chronological order and
then get the data in a sequential manner that is not how clients typically
work, and it would greaty defeat some of the primary purposes of bittorrent as
it will not at all distribute the load as evenly among the peers as the
"random access" method does.

## Uplink

Due to the nature of these protocols. A **bittorrent** transfer to you is very
likely to reach you over other users' uplinks. Your client also hands out data
to other users over your Internet connection. With bittorrent you're getting
each individual part limited by the uplink speed of that user who has that
part. Your client also hands out data so you use your uplink at lot (as much
as you allow it basically).

With **HTTP**, all the uplink is used for basically, is sending TCP ACKs to
the server. That's only a small fraction of the bandwidth you use in the
downlink.

## Firewalls

**Bittorrent** needs to go out and connect to multiple remote machines. For
your client to be able to hand out stuff properly it also needs to allow
remote clients to connect back to you (even on multiple inbound ports) and
that requires that you have a firewall setup that allows this.

**HTTP** is a traditional client so it only connects to a server, which
firewalls tend to be setup to allow with no extra fuzz needed.

Related, is the fact that bittorrent uses a lot more TCP connections in any
typical use case which might be troublesome for OSes or intermediate routers
etc with fixed limits.

 Bittorrent typically runs on separate TCP ports (6881-6999) which are easily
blocked by firewall admins.

## Redundancy

A bittorrent client can survive that the primary server (tracker) goes away
after it has gotten the primary torrent off it and found one or more peers to
request file parts from, while a HTTP solution is depending on the server to
stick around and to keep feeding the TCP stream. Bittorrent also has
techniques to work in "trackerless" mode (DHT and Mainline DHT being two)
which makes it even more robust.

The HTTP server can in fact go silent for a long time and the connection will
then just continue again when the server re-appears, but both HTTP and
bittorrent use TCP so that's pretty much the same for both protocols. It's
just that even if one connection stalls with bittorrent, chances are the
others still strive.

## Server Load

One of the primary purposes of bittorrent is to ease the burden to
provide data for download, and as such it is certainly way better than
HTTP as you can distribute a particular file to a very large amount of
clients with only a fraction of the load and bandwidth requirements on the
server/tracker.

## Encryption

HTTP has no encryption but the standard way is to do HTTP over TLS, called
HTTPS. That provides what is generally accepted a secure data connection.

bittorrent offers a protocol extension called Message Stream Encryption (MPE)
which provides a *"message stream obfuscation by the application of fairly
simple cryptographic techniques, not a full blown transport level security
mechanism like SSL"* ([quote referece](http://www.azureuswiki.com/index.php/Message_Stream_Encryption)).

## Protocol Standards

[HTTP](http://www.ietf.org/rfc/rfc7230.txt) is an established and formalized
protocol standard by the IETF.

[Bittorrent](http://www.bittorrent.org/beps/bep_0003.html) is a protocol
designed by the company named Bittorrent and there is a large amount of
variations and extensions in implementations and clients.

## Further Reading

The [wikipedia article on
bittorrent](http://en.wikipedia.org/wiki/BitTorrent_%28protocol%29) is very
detailed and a good read.

## Thanks

Feedback and improvements by: Austin Appel, Dave Chapman

repository: bagder/docs

repo_name: bagder/docs


text:
### Python Installation & Django Workflow

#### Installing Python

Installing Python on Windows is easy. Just find the Windows Executable Installer on the [Python downloads page](https://www.python.org/downloads/release/python-352/), run it, and you're good to go. When the Installation Wizard pops up, be sure to check the `Add python to PATH` option, and at the end of install `allow python to bypass PATH limit`. This will do any manual work involved in adding Python to your PATH automatically.

Mac users should install [Homebrew](http://brew.sh), and then run `brew install python3`.

If you're on Linux, you're probably already running Python 3.4.x+. Users of Ubuntu 12.10+ already have Python 3.4.x: Just use `python3` and `pip3` instead of `python` and `pip`. Users of other distributions presumably know what they're doing.

#### Installing Virtualenv

You _can_ install Django globally. But you shouldn't. It's better to maintain the environments of projects that rely on particular versions of packages separately. In Python-land, we use [virtualenv](http://docs.python-guide.org/en/latest/dev/virtualenvs/) for this, and our package manager is called [pip](https://pypi.python.org/pypi/pip).

Virtualenv effectively allows us to create an isolated environment in which we can use a _specific_ Python version and install _specific_ versions of the packages we want. What you do elsewhere won't interfere at all with this isolated environment.

We'll be using Django 1.10.x, which requires Python 3.4.x+. Since most of you will have both Python 2.7 _and_ 3.4/5 on your system, you need to make sure you're using the right version of pip, since there's one for each.

First, run: `pip --version`. This will print the version of pip you have, and the version of Python it's using.

_pip --version output._

If you see `Python 3.4.3` or higher to the right, keep using just use the `pip` command.

If you see `Python 2.7`, as I do, try again with `pip3`.

_pip3 --version output._

If that works, use `pip3` instead. If it doesn't, Slack a TA or instructor—it should.

Next, we'll install virtualenv. This is a package you _do_ want to install globally, since it's an environment manager.

Run:

Open `GitBash` as Adminstrator if using windows. Use `sudo` command on Mac. I.E `sudo pip install virtualenv --user`.

    # Or pip3 install virtualenv --user, if appropriate.
    pip install virtualenv --user

That should install virtualenv globally.

#### Using Virtualenv

You'll mostly be doing three things with virtualenv: **Creating** virtual environments; **sourcing** them; and **deactivating** them. It's all quite straightforward.

##### Creating a virtualenv

To create a new virtualenvironment, run:

    virtualenv $ENVIRONMENT_NAME

... Where $ENVIRONMENT_NAME can be anything. I generally use `virtualenv env`.

Note that this will use your system's _default_ Python as the version for the virtual environment. If typing `python --version` prints `Python 3.4.x` or higher, this is fine. If you have to use `pip3` or `python3` explicitly, though, you may need to tell virtualenv to use Python 3 explicitly.

There are two steps.

1.  Figure out where your Python 3 installation lives. Write: `which python3`. I'll call the output of this command $PYTHON_3.

2.  Run: `virtualenv -p $PYTHON_3 $ENVIRONMENT_NAME`, where $PYTHON_3 is the path to your Python 3 installation.

_Output of which python3._

_Creating a virtualenv with Python 3._

##### Sourcing a virtualenv

To actually _use_ your sandbox, you need to "source" the virtualenv. This is straightforward:

For Windows, run:
`source $ENVIRONMENT/Scripts/activate`.
For Mac, run
`source $ENVIRONMENT/bin/activate`.

Again, I usually use `env` as my $ENVIRONMENT_NAME, so I write:

    source env/Scripts/activate

or

    source env/Scripts/activate

_Sourcing a virtualenv._

You'll notice an `(env)` marker pop up to the left of your command prompt. This simply indicates that you're running in a virtualenv, not your normal system environment.

At this point, you can install packages with pip just like you normally would. The only difference is that, if you created your virtualenv with Python 3, you can just write `pip` instead of `pip3`.

For example, to install the version of Django we'll use this week, run:

    pip install Django==1.10.1

This installs Django 1.10.1, but _only_ in your sandboxed virtual environment. Once you deactivate it, the rest of your system won't know anything about it.

##### Deactivating

To exit your virtualenv sandbox and return to your normal system environment, just use `deactivate`.

_Deactivating a virtualenv._

#### Workflow

Everyone settles on their own workflows, but the following cycle is common in Django.

-   Write unit tests for your models.

-   Define your models.

-   Migrate your database.

-   Write functional tests for your user stories.

-   Define views corresponding to your models.

-   Wire your URLs to respond to the views.

-   Write templates to "decorate" your views.

repository: risatino/django-app

repo_name: risatino/django-app


text:
# About

balance-tree.lua was a self-balancing Binary Search Tree implement.

# Usage

```lua

local tree = require("balance-tree").new(function(a, b)
   return a - b
end)

-- insert
tree:insert(666, 6)
tree:insert(555, 5)

-- replace 5 to 55
tree:insert(555, 55, tree)

-- find, got 6
local a1 = tree:find(666)

-- remove, got 55
local a2 = tree:remove(555)

print("tree count: " .. tree:count())

-- minimal key, value
local minkey, minvalue = tree:first()

-- maximal key, value
local maxkey, maxvalue = tree:last()

-- loop from first to last
local n = tree:first()
while n ~= nil do
   n = tree:next(n)
end

-- loop from last to first
local p = tree:last()
while p ~= nil do
   p = tree:prev(p)
end

-- walk from first to last
for k, v in tree:walk() do
   print(k, v)
end

-- walk from last to first
for k, v in tree:walk(false) do
   print(k, v)
end

-- range 2 to 3
for i, k in ipairs(tree:range(2, 3)) do
   print(i, k)
end

-- range 5 to 3
for i, k in ipairs(tree:range(5, 3)) do
   print(i, k)
end
```

# Performance

3.29 GHz Intel Core i5 GHz Intel Core i5

```
14) test performance, every round 1,000,000, then clear
round 1: 0.990936s, avg: 0.990936s
round 2: 0.986641s, avg: 0.9887885s
round 3: 0.988772s, avg: 0.988783s
round 4: 0.994742s, avg: 0.99027275s
round 5: 0.989145s, avg: 0.9900472s
```


text:
# SBTickerView
## Features
* Easy to use (see the demo app, just assign a front & back view and tick it)
* Perspective ("3D")
* Shadows (masked by the alpha channel)
* This project is written using ARC

## Future features
* Support for gestures
* Better perspective calculations
* More Flipboard like shadows

## License
SBTickerView is released under the MIT-license (see the LICENSE file)

## Screenshots
![Screenshot](https://github.com/blommegard/SBTickerView/raw/master/SBTickerViewDemo/Screenshots/timeticker.png "Time ticker")

repository: phongleq/SBTickerView

extension: markdown

repo_name: phongleq/SBTickerView


text:
# 🥞 Macaron UIkit

[![Version](https://img.shields.io/npm/v/@macaronswap-libs/uikit)](https://www.npmjs.com/package/@macaronswap-libs/uikit) [![Size](https://img.shields.io/bundlephobia/min/@macaronswap-libs/uikit)](https://www.npmjs.com/package/@macaronswap-libs/uikit)

Macaron UIkit is a set of React components and hooks used to build pages on Macaron's apps. It also contains a theme file for dark and light mode.

## Install

`yarn add @macaronswap-libs/uikit`

## Setup

### Theme

Before using Macaron UIkit, you need to provide the theme file to styled-component.

```
import { ThemeProvider } from 'styled-components'
import { light, dark } from '@macaronswap-libs/uikit'
...
<ThemeProvider theme={isDark}>...</ThemeProvider>
```

### Reset

A reset CSS is available as a global styled component.

```
import { ResetCSS } from '@macaronswap-libs/uikit'
...
<ResetCSS />
```

### Types

This project is built with Typescript and export all the relevant types.

## How to use the UIkit

If you want to use components from the UIkit, check the [Storybook documentation](https://macaronswap.github.io/macaron-uikit/)

repository: macaronswap/macaron-toolkit

gha_language: TypeScript

repo_name: macaronswap/macaron-toolkit


text:
---
title: Frequently Asked Questions
---

**I'm getting 'version GLIBCXX_3.4.21 not defined in file libstdc++.so.6 with link time reference' error**

If you are getting this error:

    ImportError: /opensim-rl/lib/python2.7/site-packages/opensim/libSimTKcommon.so.3.6:
      symbol _ZTVNSt7__cxx1119basic_istringstreamIcSt11char_traitsIcESaIcEEE, version
      GLIBCXX_3.4.21 not defined in file libstdc++.so.6 with link time reference

Try `conda install libgcc`.

**Can I use languages other than python?**

Yes, you just need to set up your own python grader and interact with it
[https://github.com/kidzik/osim-rl-grader](https://github.com/kidzik/osim-rl-grader). Find more details here [OpenAI http client](https://github.com/openai/gym-http-api)

**Some libraries are missing. What is required to run the environment?**

Most of the libraries by default exist in major distributions of operating systems or are automatically downloaded by the conda environment. Yet, sometimes things are still missing. The minimal set of dependencies under Linux can be installed with

    sudo apt install libquadmath0 libglu1-mesa libglu1-mesa-dev libsm6 libxi-dev libxmu-dev liblapack-dev

Please, try to find equivalent libraries for your OS and let us know -- we will put them here.

**Why there are no energy constraints?**

Please refer to the [issue #34](https://github.com/stanfordnmbl/osim-rl/issues/34).

**I have some memory leaks, what can I do?**

Please refer to
[issue #10](https://github.com/stanfordnmbl/osim-rl/issues/10)
and to
[issue #58](https://github.com/stanfordnmbl/osim-rl/issues/58)

**I see only python3 environment for Linux. How to install Windows environment?**

Please refer to
[issue #29](https://github.com/stanfordnmbl/osim-rl/issues/29)

**How to visualize observations when running simulations on the server?**

Please refer to
[issue #59](https://github.com/stanfordnmbl/osim-rl/issues/59)

**I still have more questions, how can I contact you?**

For questions related to the challenge please use [the challenge forum](https://www.crowdai.org/challenges/nips-2018-ai-for-prosthetics-challenge/topics).
For issues and problems related to installation process or to the implementation of the simulation environment feel free to create an [issue on GitHub](https://github.com/stanfordnmbl/osim-rl/issues).

repository: amir-abdi/osim-rl

repo_name: amir-abdi/osim-rl


text:
# Functionality

In the application there are different functionality. This document describes the most relevant ones and how they are used and how they flow through the system.

## Adding tags

The first thing one needs to start off with is to actually add tags into the system. Otherwise there is nothing to tag messages coming in with. The tags are unique per users mailbox.

Enter the tag name in the "Tagname" input:

![Enter Tag](images/EnterTag.png)

Then click the plus button:

![Enter Tag](images/InsertTag.png)

## Compose Message

To train the text analytics model, we will have to start tagging messages. In order to create a message that will be possible to tag, you can navigate to the compose page:

![Navigate to compose](images/ComposeNavigation.png)

Fill out all the fields and then click send.

![Compose and send message](images/ComposeMessage.png)

Navigate back to the reading list:

![Navigate to read](images/ReadNavigation.png)

## Tagging messages

From the inbox list you will be able to see the message you put in and be able to tag it.

![Tag Message](images/TagMessage.png)

## Receiving messages

The goal when receiving messages is to be able to automatically tag them according to the trained model. The Flow below describes the steps it goes through with the [architecture](Architecture.md) its based on.

![Message Ingress Flow](images/Message_Ingress_Flow.png)

## Tagging

In the UI

![Message Ingress Flow](images/Message_Tagging_Flow.png)

repository: msdevno/enirkesto

repo_name: msdevno/enirkesto


text:
# Laravel Docker

[![Build Status][travis-badge]][travis-link] [![Docker Automated Build Status][docker-build-badge]][docker-hub-link]

A customised Docker image meant for Laravel applications

## Usage
`docker pull jasonheecs/laravel-docker`

## Testing
Testing is done via Rspec and [Hadolint](https://github.com/hadolint/hadolint).

To run Rspec tests:
```bash
gem install bundler
bundle install
bundle exec rspec
```

To run linting tests on the Dockerfiles, make sure Hadolint installed and:
```bash
hadolint ./7.4/Dockerfile
```

Refer to the [travis.yml](.travis.yml) file and [Travis build logs][travis-link] for details on the automated tests and expected outputs.

## License
MIT

[docker-build-badge]: https://img.shields.io/docker/cloud/build/jasonheecs/laravel-docker.svg
[docker-hub-link]: https://hub.docker.com/r/jasonheecs/laravel-docker/
[travis-badge]: https://travis-ci.com/jasonheecs/laravel-docker.svg?branch=master
[travis-link]: https://travis-ci.com/jasonheecs/laravel-docker

repository: jasonheecs/laravel-docker

gha_language: Ruby

repo_name: jasonheecs/laravel-docker


text:
Generate PDF for Stripe invoice using AWS Lambda
================================================

This is a lambda function that takes an stripe invoice object (JSON) and customer related info to generate a PDF. The PDF will be saved to a S3 bucket where it could then be distributed (email, download, etc)

### Requirements

1. [Serverless framework](https://www.serverless.com)
2. NodeJS 8.10
3. An AWS account

### Configuration

1. Fill out your company information on handler.js configuration variables:

```
const COMPANY_NAME = 'Arena.im'
const COMPANY_ADDRESS = '2443 Fillmore St #380-5512'
const COMPANY_ZIPCODE = '94115'
const COMPANY_CITY = 'San Francisco'
const COMPANY_COUNTRY = 'United States'
const COMPANY_LOGO_PATH = './arena-logo-purple.png'
const COLOR = '#2C75FF'
const S3_BUCKET = 'arena-billing-invoices' //where the PDF generated will be saved
```

2. Change serverless.yml configuration

Change line 12 to your specific S3 bucket ARN

Change line 32 to include your logo file to the package

### Build and Deploy

1. npm install
2. serverless deploy (https://serverless.com/framework/docs/providers/aws/guide/deploying/)

### Usage

The lambda function receives an `event` parameter that is a JSON object with the following structure:

```
{
  invoice, //actual invoice object from Stripe, see https://stripe.com/docs/api#invoice_object
  clientInfo : { //customer being invoiced info
    client_company_name,
    client_company_address,
    client_company_zipcode,
    client_company_city,
    client_company_country,
    receipt_number
  }
}
```

The function will then generate a PDF and save it to the S3 Bucket defined.

### Credits

- Thanks to https://github.com/jonathanasquier/stripe-pdf-invoice for the work generating the PDF using pug templates.


text:
**Project 47:** Fill out this [form](https://forms.office.com/Pages/ResponsePage.aspx?id=ETrdmUhDaESb3eUHKx3B5lOTzSa_A6lPqq2LJKzvpM5UMTBZRkc4UTRETjFERVRDWllQRE40OUFSQS4u) to  register your intent to complete this project and learn about the rewards

Rotor-Flying Manipulator Simulation

Rotor-flying manipulation will change the future of aerial transportation and manipulation in construction and hazardous environments. Take robotics manipulation to the next level with an autonomous UAV

## Motivation

Rotor-flying manipulators are Unmanned Aerial Vehicles (UAVs) equipped
with a lightweight manipulator and have the potential to transform major
industries thanks to their unconstrained 3D motion making them ideal for deployent
in cluttered environments. Rotor-flying manipulation is a natural evolution
of mobile manipulation and a popular research area in robotics that
attracts the interest of many companies and public institutions. Its
applications range from aerial transportation in construction,
manipulations in hazard places, inspections and installations on sites
with a difficult access, to search and rescue.

Autonomous aerial manipulation is challenging problem because of the
coupled dynamics between the two systems.

## Project Description

Develop an autonomous aerial manipulation simulation including a UAV equipped with a multi-DoF manipulator to pick an object and place it into a goal location. Pose estimation and perception of the environment will be developed using a visual system. Global motion planning with obstacle avoidance will allow the system to reach the target location to approach and pick an object and eventually place it into a goal location.
Model the UAV and the manipulator and couple them together. The coupled system will be the plant for the controller you will need to design and implement in order to stabilize and fly the system.
For this project we can neglect aerodynamic effects, assuming low-speed flight, and external disturbances.

Suggested steps:

1.	Create a Simulink or MATLAB model of the coupled system of UAV + manipulator. Simscape multibody is a physical modeling tool that you can use for modeling the system and import the model in the environment of your choice (Simulink or MATLAB)
2.	Design and implement a controller to control the orientation and position of the coupled system
3.	Build your environment as an open space to start with (without obstacles), and then if you have enough time, add obstacles and use an obstacle avoidance algorithm to fly around them.
4.	Use the position of the objects and the target locations as waypoints to the flying manipulator (using a waypoint follower algorithm from the UAV Toolbox) to get close to the objects to pick.
5.	Once the UAV is above the object, plan the manipulator motion using a path planner algorithm.

Advanced project work:

1. Implement a visual-based pose estimation algorithm
    -   Use Lidar scans to estimate the system’s pose (ego-motion)
    -	Use Computer Vision and Deep Learning (for example the YOLOv2 neural network) to detect and locate the object to pick and place.

## Background Material

- [UAV Toolbox](https://www.mathworks.com/products/uav.html)
- [Robotics System Toolbox](https://www.mathworks.com/products/robotics.html)
- [Navigation Toolbox](https://www.mathworks.com/help/nav/getting-started-with-navigation-toolbox.html)
- [Simscape Multibody](https://www.mathworks.com/products/simmechanics.html)
- [Quadcopter programming in Simulink](https://www.mathworks.com/videos/programming-drones-with-simulink-1513024653640.html)
- [Quadcopter modelling and Control with Simscape and Simulink](https://www.mathworks.com/matlabcentral/fileexchange/44902-quadrotor-modelling-and-control-with-simmechanics?s_tid=srchtitle)
- [Pick-and-place example](https://www.mathworks.com/help/robotics/examples/pick-and-place-workflow-using-stateflow.html)

## Impact

Transform the field of robot manipulation.

## Expertise Gained

Drones, Robotics, Manipulators, Modeling and Simulation, UAV

## Project Difficulty

Master’s level

## Project Discussion

[Dedicated discussion forum](https://github.com/mathworks/MathWorks-Excellence-in-Innovation/discussions/12) to ask/answer questions, comment, or share your ideas for solutions for this project.

## Project Number

47


text:
# Appium

### Note (need refactor)
* android studio (sdk inside)
* appium
* ANDROID HOME
* uiautomatorviewer
* XCode
* CocoaPods
  * https://notcodingwilldie.blogspot.com/2018/10/cocoapods.html
* brew install carthage
* sudo xcode-select --switch /Applications/Xcode.app (Appium Error: Could not get Xcode version)
  * restart

repository: CommonMarvel/full-stack-testing-starter

repo_name: CommonMarvel/full-stack-testing-starter


text:
lightning-listfunds -- Command showing all funds currently managed by the c-lightning node
==========================================================================================

SYNOPSIS
--------

**listfunds**

DESCRIPTION
-----------

The **listfunds** RPC command displays all funds available, either in
unspent outputs (UTXOs) in the internal wallet or funds locked in
currently open channels.

RETURN VALUE
------------

On success two arrays will be returned: *outputs* with funds currently
locked onchain in UTXOs and *channels* with funds readily spendable in
channels.

Each entry in *outputs* will include:
-   *txid*
-   *output* (the index of the output in the transaction)
-   *value* (the output value in satoshis)
-   *amount\_msat* (the same as *value*, but in millisatoshi with *msat*
    appended)
-   *address*
-   *status* (whether *unconfirmed*, *confirmed*, or *spent*)

Each entry in *channels* will include:
-   *peer\_id* - the peer with which the channel is opened.
-   *short\_channel\_id* - as per BOLT 7 (representing the block,
    transaction number and output index of the channel funding
    transaction).
-   *channel\_sat* - available satoshis on our node’s end of the channel
    (values rounded down to satoshis as internal storage is in
    millisatoshi).
-   *our\_amount\_msat* - same as above, but in millisatoshis with
    *msat* appended.
-   *channel\_total\_sat* - total channel value in satoshi
-   *amount\_msat* - same as above, but in millisatoshis with *msat*
    appended.
-   *funding\_txid* - funding transaction id.
-   *funding\_output* - the index of the output in the funding
    transaction.
-   *connected* - whether the channel peer is connected.
-   *state* - the channel state, in particular *CHANNELD_NORMAL* means the
    channel can be used normally.

AUTHOR
------

Felix<EMAIL_ADDRESS>is mainly responsible.

SEE ALSO
--------

lightning-newaddr(7), lightning-fundchannel(7), lightning-withdraw(7)

RESOURCES
---------

Main web site: <https://github.com/ElementsProject/lightning>

repository: sugarchain-project/lightning

repo_name: sugarchain-project/lightning


text:
# ~$ Honeypot
Simple honeypot writen in python with scapy.

* Proof: https://www.youtube.com/watch?v=QFwL5EOFNCQ
* Writeup: https://csi-blog.com/honeypot/

# ~$ Description
The script will detect your mac address (manual sellection coming soon),

and will sniff all incoming TCP data for all 65535 ports,

and will respond as Syn/Ack on all ports.

# ~$ Usage
$ python honeypot.py