text:
# ReactTodo

This is a Todo demo built with React & TypeScript & [UmiJS](https://umijs.org/).

## Getting Started

Install dependencies,

```shell
npm install
```

Start the dev server,

```shell
npm run start
```

### Backend

[DjangoTodo](https://github.com/OceanOver/DjangoTodo)

repository: OceanOver/ReactTodo

repo_name: OceanOver/ReactTodo


text:
# Awesome Reinforcement Learning

  Click here to see icon descriptions.

- :rocket: - state-of-the-art agent/technique at the moment of paper publication.
- :star: - valuable paper.
- ![model-based] - Model-based RL.
- ![multi-agent-rl] - Multi-Agent RL.
- ![self-play] - Self-Play.
- ![evolution] - Evolutionary & Genetic Algorithms.
- ![generalization] - Generalization on unseen environments.
- ![auto-ml] - Auto ML - Architecture search.
- ![manipulation] - Manipulation tasks.
- ![locomotion] - Locomotion: MuJoCo, Roboschool, etc.
- ![navigation] - Navigation tasks.
- ![plan] - Strategy Planning Problems.
- ![transfer] - Transfer learning.
- ![inverse-rl] - Inverse Reinforcement Learning.
- ![meta-learning] - Meta-Learning.
- ![exploration] - Curiosity Learning, Advanced Exploration.
- ![table] - Table games (Table).
- ![atari] - Atari game (Atari).
- ![doom] - Doom game (Doom).
- ![sc] - Starcraft game (Starcraft).
- ![go] - Go game (Go).

## Table of Contents
  - [Frameworks](#frameworks)
  - [Benchmarks](#benchmarks)
  - [Policy-Based Generic Agents](#policy-agents)
  - [Value-Based Generic Agents](#value-agents)
  - [![model-based] Model-Based Generic Agents](#model-based)
  - [![evolution] Evolutionary & Genetic Algorithms](#evolution)
  - [![exploration] Exploration](#exploration)
  - [![self-play] Self-Play](#self-play)
  - [![meta-learning] Meta-Learning](#meta-learning)
  - [![multi-agent-rl] Multi-Agent RL](#multi-agent-rl)
  - [![inverse-rl] Inverse RL](#inverse-rl)
  - [![navigation] Navigation](#navigation)
  - [![manipulation] Manipulation](#manipulation)
  - [![locomotion] Locomotion](#locomotion)
  - [![auto-ml] Auto ML](#auto-ml)
  - [Other Domains](#other-domains)
  - [Books](#books)
  - [Search for new Papers](#search-for-new-papers)
  - [Misc](#misc)

## RL Frameworks & Implementations
[[Baselines @ OpenAI](https://github.com/openai/baselines)] TensorFlow: PPO, A2C, DQN, TRPO, ACKTR, DDPG, HER, GAIL, etc

[[Dopamine @ Google](https://github.com/google/dopamine)] TensorFlow: Rainbow, c51, IQN, DQN, etc

[[TensorForce](https://github.com/reinforceio/tensorforce)] TensorFlow: A3C, PPO, TRPO, DQN, etc

[[pytorch-a2c-ppo-acktr](https://github.com/ikostrikov/pytorch-a2c-ppo-acktr-gail)] PyTorch: A2C, ACKTR, PPO, GAIL, etc

## RL Benchmarks
[[OpenAI Benchmarks for PPO, A2C, ACKTR, ACER](https://github.com/openai/baselines-results/blob/master/acktr_ppo_acer_a2c_atari.ipynb)]

[[OpenAI Benchmarks for DQN, Double DQN, Dueling DQN, Prioritized DQN](https://github.com/openai/baselines-results/blob/master/dqn_results.ipynb)]

[[Google Benchmarks for Rainbow, c51, IQN, DQN](https://google.github.io/dopamine/baselines/plots.html)]

## Policy-Based Generic Agents
:rocket: [[Soft Actor Critic](https://arxiv.org/abs/1812.05905)] [[blog](https://ai.googleblog.com/2019/01/soft-actor-critic-deep-reinforcement.html)] [[code](https://github.com/rail-berkeley/softlearning/)] 2018 @ Google Brain, UC Berkeley

:rocket: [[IMPALA](https://arxiv.org/abs/1802.01561v2)] 2018 @ Uber AI Labs

:rocket: [[Scalable trust-region method for deep reinforcement learning using Kronecker-factored approximation (ACKTR, A2C)](https://arxiv.org/abs/1708.05144)] 2018; Univ. of Toronto, New York Univ.

:rocket: [[Proximal Policy Optimization Algorithms (PPO)](https://arxiv.org/abs/1707.06347)] [[blog](https://blog.openai.com/openai-baselines-ppo/)] 2017 @ OpenAI

:rocket: [:pencil: Notes](./notes/a3c-agent.md) [[Asynchronous Methods for Deep Reinforcement Learning (A3C)](https://arxiv.org/abs/1602.01783v2)] 2016 @ Google Deepmind

[[High-dimensional continuous control using generalized advantage estimation (GAE)](https://arxiv.org/abs/1506.02438)] 2015 @ Berkeley

:star: [[Trust Region Policy Optimization (TRPO)](https://arxiv.org/abs/1502.05477)] 2015 @ UC Berkeley

:star: [[Actor-Critic Algorithms, pdf](https://papers.nips.cc/paper/1786-actor-critic-algorithms.pdf)] Konda and Tsitsiklis, 2003

:star: [[Simple Statistical Gradient-Following Algorithms for Connectionist Reinforcement Learning (REINFORCE), pdf](http://www-anw.cs.umass.edu/~barto/courses/cs687/williams92simple.pdf)] Ronald J. Williams, 1992 @ Northeastern Univ.

## Value-Based Generic Agents
:rocket: [[Implicit Quantile Networks for Distributional Reinforcement Learning (IQN)](https://arxiv.org/abs/1806.06923)] Dabney et al., 2018 @ Google Deepmind

:rocket: [[A Distributional Perspective on Reinforcement Learning (c51)](https://arxiv.org/abs/1707.06887)] Bellemare et al., 2018 @ Google Deepmind

:rocket: [[Rainbow: Combining Improvements in Deep Reinforcement Learning](https://arxiv.org/abs/1710.02298)] Hessel et al., 2017 @ Google Deepmind

:rocket: [[Dueling Network Architectures for Deep Reinforcement Learning (Dueling DQN)](https://arxiv.org/abs/1511.06581)] Wang et al., 2015 @ Google Deepmind

:rocket: [:pencil: Notes](./notes/prioritized-exp-replay.md) [[Prioritized Experience Replay](https://arxiv.org/abs/1511.05952v4)] Schaul et al., 2015 @ Google Deepmind

:rocket: [[Deep Reinforcement Learning with Double Q-learning (Double DQN)](https://arxiv.org/abs/1509.06461)] Hasselt et al., 2015 @ Google Deepmind

:rocket: [:pencil: Notes](./notes/dqn-agent.md) [[Human-level control through deep reinforcement learning (DQN)](http://www.nature.com/nature/journal/v518/n7540/full/nature14236.html)]
[[pdf](hhttp://www.readcube.com/articles/10.1038/nature14236?shared_access_token=Lo_2hFdW4MuqEcF3CVBZm9RgN0jAjWel9jnR3ZoTv0P5kedCCNjz3FJ2FhQCgXkApOr3ZSsJAldp-tw3IWgTseRnLpAc9xQq-vTA2Z5Ji9lg16_WvCy4SaOgpK5XXA6ecqo8d8J7l4EJsdjwai53GqKt-7JuioG0r3iV67MQIro74l6IxvmcVNKBgOwiMGi8U0izJStLpmQp6Vmi_8Lw_A%3D%3D)]
Mnih et al., 2015 @ Google Deepmind

:rocket: [[Playing Atari with Deep Reinforcement Learning** (DQN)](https://arxiv.org/abs/1312.5602)] Mnih et al., 2013 @ DeepMind Technologies

:star: [[Temporal Difference Learning and TD-Gammon, pdf](http://cling.csd.uwo.ca/cs346a/extra/tdgammon.pdf)] Gerald Tesauro, 1995

## ![model-based] Model-Based Generic Agents
[[Model-Based Reinforcement Learning for Atari](https://arxiv.org/abs/1903.00374)] 2019 @ Google Brain, etc

:star: ![navigation] [[World Models](https://arxiv.org/abs/1803.10122)] [[blog](https://worldmodels.github.io/)] 2018 @ IDSIA, Google Brain, NNAISENSE

![locomotion] [[Neural Network Dynamics for Model-Based Deep Reinforcement Learning with Model-Free Fine-Tuning](https://arxiv.org/abs/1708.02596)] [[blog](http://bair.berkeley.edu/blog/2017/11/30/model-based-rl/)] [[code](https://github.com/nagaban2/nn_dynamics)] 2017 @ Berkeley

![locomotion] [[Learning model-based planning from scratch](https://arxiv.org/abs/1707.06170)], [[blog](https://deepmind.com/blog/agents-imagine-and-plan/)] 2017 @ Google DeepMind

![navigation] [[The Predictron: End-To-End Learning and Planning](https://arxiv.org/abs/1612.08810v2)] 2016 @ Google Deepmind

## ![evolution] Evolutionary Algorithms
[[Back to Basics: Benchmarking Canonical Evolution Strategies for Playing Atari](https://arxiv.org/abs/1802.08842)] 2018 @ Univ. of Freiburg

:star: ![locomotion] [[Deep Neuroevolution](https://arxiv.org/abs/1712.06567)] 2017 @ Uber AI Labs

:star: [[Evolution Strategies as a Scalable Alternative to Reinforcement Learning](https://arxiv.org/abs/1703.03864v1)] 2017 @ OpenAI

[[Evolving Large-Scale Neural Networks for Vision-Based Reinforcement Learning, pdf](http://people.idsia.ch/~juergen/gecco2013torcs.pdf)] 2013 @ IDSIA, USI-SUPSI

## ![exploration] Exploration
:rocket: [[Go-Explore](https://arxiv.org/abs/1901.10995)] 2019 @ Uber AI Labs

[[Exploration by Random Network Distillation (RND)](https://arxiv.org/abs/1810.12894)] [[blog](https://blog.openai.com/reinforcement-learning-with-prediction-based-rewards/)] [[code](https://github.com/openai/random-network-distillation)] 2018 @ OpenAI

![navigation] [[Large-Scale Study of Curiosity-Driven Learning](https://arxiv.org/abs/1808.04355)] [[blog](https://pathak22.github.io/large-scale-curiosity/)] 2018 @ OpenAI, Berkeley, Univ. of Edinburgh

:star: [[RUDDER: Return Decomposition for Delayed Rewards](https://arxiv.org/abs/1806.07857)] [[code](https://github.com/ml-jku/baselines-rudder)] 2018 @ Johannes Kepler Univ. Linz

[[Deep Curiosity Search](https://arxiv.org/abs/1806.00553)] 2018 @ Univ. of Wyoming

![locomotion] [[Parameter Space Noise for Exploration](https://arxiv.org/abs/1706.01905)] 2017 @ OpenAI, Karlsruhe Inst. of Tech.

:star: ![transfer] [[Imagination-Augmented Agents for Deep Reinforcement Learning (I2As)](https://arxiv.org/abs/1707.06203)] [[blog](https://deepmind.com/blog/agents-imagine-and-plan/)] 2017 @ DeepMind

## ![self-play] Self-Play
:star: ![table] [[Mastering Chess and Shogi by Self-Play with a General Reinforcement Learning Algorithm](https://arxiv.org/abs/1712.01815)] Silver et al., 2017 @ Google Deepmind

:star: ![table] [[Mastering the Game of Go without Human Knowledge (AlphaGo Zero), pdf](https://deepmind.com/documents/119/agz_unformatted_nature.pdf)], [[blog](https://deepmind.com/blog/alphago-zero-learning-scratch/)] Silver et al., 2017 @ Deepmind

![table] [[Mastering the game of Go with deep neural networks and tree search (AlphaGo Master)](https://www.nature.com/nature/journal/v529/n7587/full/nature16961.html)], [[reddit](https://www.reddit.com/r/MachineLearning/comments/42ytdx/pdf_mastering_the_game_of_go_with_deep_neural/)] Silver et al., 2017 @ Deepmind, Google

## ![meta-learning] Meta-Learning
![locomotion] [[Meta Learning Shared Hierarchies](https://arxiv.org/abs/1710.09767)] [[blog](https://blog.openai.com/learning-a-hierarchy/)] Frans et al., 2017 @ OpenAI, Berkeley.

license: MIT

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
A Simple Example of Require.js with Bower
=========================================

Install bower with

    npm install -g bower

Install the dependencies with

    bower install

Finally open index.html to see it in action.

repository: ojjs/oj-examples

repo_name: ojjs/oj-examples


text:
# Poolboy - A hunky Erlang worker pool factory

[![Erlang CI](https://github.com/comtihon/poolboy/actions/workflows/erlang.yml/badge.svg)](https://github.com/comtihon/poolboy/actions/workflows/erlang.yml)

Poolboy is a **lightweight**, **generic** pooling library for Erlang with a
focus on **simplicity**, **performance**, and **rock-solid** disaster recovery.

## Usage
The most basic use case is to check out a worker, make a call and manually
return it to the pool when done
```erl-sh
1> Worker = poolboy:checkout(PoolName).
<0.9001.0>
2> gen_server:call(Worker, Request).
ok
3> poolboy:checkin(PoolName, Worker).
ok
```
Alternatively you can use a transaction which will return the worker to the
pool when the call is finished.
```erl-sh
poolboy:transaction(
    PoolName,
    fun(Worker) -> gen_server:call(Worker, Request) end,
    TransactionTimeout
)
```
## Example

This is an example application showcasing database connection pools using
Poolboy and [epgsql](https://github.com/epgsql/epgsql).

### example.app

```erlang
{application, example, [
    {description, "An example application"},
    {vsn, "0.1"},
    {applications, [kernel, stdlib, sasl, crypto, ssl]},
    {modules, [example, example_worker]},
    {registered, [example]},
    {mod, {example, []}},
    {env, [
        {pools, [
            {pool1, [
                {size, 10},
                {max_overflow, 20}
			], [
                {hostname, "<IP_ADDRESS>"},
                {database, "db1"},
                {username, "db1"},
                {password, "abc123"}
            ]},
            {pool2, [
                {size, 5},
                {max_overflow, 10}
			], [
                {hostname, "<IP_ADDRESS>"},
                {database, "db2"},
                {username, "db2"},
                {password, "abc123"}
            ]}
        ]}
    ]}
]}.
```

### example.erl

```erlang
-module(example).
-behaviour(application).
-behaviour(supervisor).

-export([start/0, stop/0, squery/2, equery/3]).
-export([start/2, stop/1]).
-export([init/1]).

start() ->
    application:start(?MODULE).

stop() ->
    application:stop(?MODULE).

start(_Type, _Args) ->
    supervisor:start_link({local, example_sup}, ?MODULE, []).

stop(_State) ->
    ok.

init([]) ->
    {ok, Pools} = application:get_env(example, pools),
    PoolSpecs = lists:map(fun({Name, SizeArgs, WorkerArgs}) ->
        PoolArgs = [{name, {local, Name}},
            		{worker_module, example_worker}] ++ SizeArgs,
        poolboy:child_spec(Name, PoolArgs, WorkerArgs)
    end, Pools),
    {ok, {{one_for_one, 10, 10}, PoolSpecs}}.

squery(PoolName, Sql) ->
    poolboy:transaction(PoolName, fun(Worker) ->
        gen_server:call(Worker, {squery, Sql})
    end).

equery(PoolName, Stmt, Params) ->
    poolboy:transaction(PoolName, fun(Worker) ->
        gen_server:call(Worker, {equery, Stmt, Params})
    end).
```

### example_worker.erl

```erlang
-module(example_worker).
-behaviour(gen_server).
-behaviour(poolboy_worker).

-export([start_link/1]).
-export([init/1, handle_call/3, handle_cast/2, handle_info/2, terminate/2,
         code_change/3]).

-record(state, {conn}).

start_link(Args) ->
    gen_server:start_link(?MODULE, Args, []).

init(Args) ->
    process_flag(trap_exit, true),
    Hostname = proplists:get_value(hostname, Args),
    Database = proplists:get_value(database, Args),
    Username = proplists:get_value(username, Args),
    Password = proplists:get_value(password, Args),
    {ok, Conn} = epgsql:connect(Hostname, Username, Password, [
        {database, Database}
    ]),
    {ok, #state{conn=Conn}}.

handle_call({squery, Sql}, _From, #state{conn=Conn}=State) ->
    {reply, epgsql:squery(Conn, Sql), State};
handle_call({equery, Stmt, Params}, _From, #state{conn=Conn}=State) ->
    {reply, epgsql:equery(Conn, Stmt, Params), State};
handle_call(_Request, _From, State) ->
    {reply, ok, State}.

handle_cast(_Msg, State) ->
    {noreply, State}.

handle_info(_Info, State) ->
    {noreply, State}.

terminate(_Reason, #state{conn=Conn}) ->
    ok = epgsql:close(Conn),
    ok.

code_change(_OldVsn, State, _Extra) ->
    {ok, State}.
```

## Pool Options

- `name`: the pool name - optional
- `worker_module`: worker module. Can be either a `module` or `{module, function}`.
Example:
```
start_pool(SizeArgs, WorkerArgs) ->
  PoolArgs = [{worker_module, {mc_worker_api, connect}}] ++ SizeArgs,
  supervisor:start_child(?MODULE, [PoolArgs, WorkerArgs]).
```
In case of just atom `start_link` will be called.
- `size`: maximum pool size - optional
- `max_overflow`: maximum number of workers created if pool is empty - optional
- `strategy`: `lifo` or `fifo`, determines whether checked in workers should be
  placed first or last in the line of available workers. Default is `lifo`.
- `overflow_ttl`: time in milliseconds you want to wait before removing overflow
  workers. Useful when it's expensive to start workers. Default is 0.
- `overflow_check_period`: time in milliseconds for checking overflow workers to rip.
  Default is min(1 sec, overflow_ttl). Cheking job will not be started, if overflow_ttl is 0.

## Pool Status
Returns : {Status, Workers, Overflow, InUse}
- `Status`: ready | full | overflow
            The ready atom indicates there are workers that are not checked out
            ready. The full atom indicates all workers including overflow are
            checked out. The overflow atom is used to describe the condition
            when all permanent workers are in use but there is overflow capacity
            available.
- `Workers`: Number of workers ready for use.
- `Overflow`: Number of overflow workers started, should never exceed number
              specified by MaxOverflow when starting pool
- `InUse`: Number of workers currently busy/checked out

license: Unlicense,ISC

repository: comtihon/poolboy

detected_licenses: Unlicense ISC

gha_language: Erlang

repo_name: comtihon/poolboy


text:
# ActionsDemo.v3
A demo to show how to use GitHub Actions and PowerShell to deploy ARM templates on all available scopes for Azure (Tenant, MG, Subscription, RG)

The PowerShell Script expects a certain folder structure, use **FolderStructure.7z** to have an empty structure set up.

You can also adjust the names of expected files and folders in the upper part of **DeployARMtoAzure.ps1**.

Be aware, that you need to either set a **GitHub Secret** for AZURE_CREDENTIALS when using GitHub Actions or use Connect-AzAccount when using the script without GitHub Actions

When deploying to **Tenant level**, you need to set **proper permission**. To do so, use

`New-AzRoleAssignment -SignInName "[userId]" -Scope "/" -RoleDefinitionName "Owner"`

or

`az role assignment create --role "Owner" --assignee "[userId]" --scope "/"`

For a detailed explanation on how to use the script and stuff, visit https://www.hertes.net/2020/06/deploy-multiple-arm-templates-to-azure-using-powershell-and-github-actions/

**Copyright 2020 Haiko Hertes**

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

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

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


text:
# Research Notes

ResearchNote is an ultra minimalistic open-source simple note taking app developed using Python, Flask, React and Ant Design.

Following are the highlilghts of Research Notes:
  1. Ultra minimalistic and super clean UI
  2. Provides an rich editor with supports like advanced formating, emijis, etc
  3. Supports a handy search method to search notes
  2. Open-Source
  3. 100% Free and always will be

repository: imdeepmind/ResearchNote

gha_language: JavaScript

gha_license_id: MIT

repo_name: imdeepmind/ResearchNote


text:
[![Build Status](https://travis-ci.org/sidd-hiver/codathon-team-c.svg?branch=master)](https://travis-ci.org/sidd-hiver/codathon-team-c)
[![Coverage Status](https://coveralls.io/repos/github/sidd-hiver/codathon-team-c/badge.svg?branch=master)](https://coveralls.io/github/sidd-hiver/codathon-team-c?branch=master)

# my-first-app

> A GitHub App built with [Probot](https://github.com/probot/probot) that A Probot app

## Setup

```sh
# Install dependencies
npm install

# Run the bot
npm start
```

## Contributing

If you have suggestions for how my-first-app could be improved, or want to report a bug, open an issue! We'd love all and any contributions.

For more, check out the [Contributing Guide](CONTRIBUTING.md).

## License

[ISC](LICENSE) © 2018 sidd-hiver<EMAIL_ADDRESS>

license: ISC

repository: sidd-hiver/codathon-team-c

repo_name: sidd-hiver/codathon-team-c


text:
# GSiP 4-Channel WDM Ring Modulator - Ring Filter Transceiver

This example is based on the publication "Ring resonator based polarization diversity WDM receiver", https://doi.org/10.1364/OE.27.006147, by Anthony Park.

Note: GDS files are saved in "text GDS" format. Useful for version control tracking of changes.

## Ring Modulator Analysis

### Layout: GSiP_1_RingMod_gds.txt

* Open the layout using KLayout, with the SiEPIC-Tools package installed

	*

* menu SiEPIC | Simulation | Setup Lumerical INTERCONNECT Compact Model Library

	* ensure that the GSiP Compact Model Library is correctly loaded in INTERCONNECT.

* menu SiEPIC | Verification | Graphical Layout Check

	* Check that the layout is correct (ignore DFT error opt_in label missing).

### Frequency domain analysis

* menu SiEPIC | Simulation | Circuit Simulation: Lumerical INTERCONNECT

	* Observe the transmission spectrum of the chip, with the modulator at 0 V.

	*

* Characterize the modulator PN junction and heater:

	* In INTERCONNECT, open the LSF file: GSiP_1_RingMod_Analysis_DC.lsf
	* Edit the file to turn on the PN junction sweep: SIM_PN = 1.
	* Choose the voltages, e.g., -0.5 V to 4 V, in amplitude_values.
	* Run the LSF file

	*

	* Determine the appropriate wavelength for the continuous wave (CW) laser, e.g., 1547.4 nm.
	* Perform additional sweeps to explore the heater and PN junction performance.

### Time domain analysis

* Characterize the ring modulator in the time domain:

	* In INTERCONNECT, open the LSF file: GSiP_1_RingMod_Analysis_TimeDomain.lsf
	* Configure the CW laser wavelength as per above
	* Configure the modulation parameters: bit rate and sequence length
	* Run the LSF file
	* Observe the time domain oscilloscope measurement:

	*

	* Find the eye diagram element in the design. Observe the Extinction Ratio.
	* Right-click on EYE_1 and select Display Results.

	*

	* Observe the eye diagram

	*

## Ring Filter Analysis

### Layout: GSiP_4_RingFilter_gds.txt

* Open the layout using KLayout, with the SiEPIC-Tools package installed. Note that there are four ring resonator filters, each with slightly different radii so that they have different resonance frequencies.

	*
	*

* menu SiEPIC | Verification | Graphical Layout Check

	* Check that the layout is correct (ignore DFT error opt_in label missing).

### Frequency domain analysis

* menu SiEPIC | Simulation | Circuit Simulation: Lumerical INTERCONNECT

	* Observe the transmission spectrum of the chip. Note that there are now 4 times more resonances, owning to the four rings.

	*

* The ring resonator peaks should match the wavelengths set on the transmitter and the CW laser.

* If the receiver doesn't match the transmitter, we need to characterize the filters versus the heater current:

	* In INTERCONNECT, open the LSF file: GSiP_4_RingFilter_Analysis_DC.lsf
	* Choose the voltages in amplitude_values.
	* Run the LSF file
	* Determine the appropriate heater voltage so that the ring modulator matches the ring filter

## Transceiver Analysis

### Layout: GSiP_RingMod_Transceiver_gds.txt

* Open the layout using KLayout, with the SiEPIC-Tools package installed

	* The layout consists of a transmitter (left) and a receiver (right):

	*

	* The transmitter begins with an edge coupler for the laser input. Next are DC monitor detectors to measure the modulator performance using DC electrical pads, as well as DC pads for thermal tuning of the ring modulator:

	*

	* Next the ring modulators are connected to RF pads. Each modulator is manually assigned a unique Component_ID so we can identify it in the schematic.

	*

	* And the receiver, consists of 4 ring filters, each connected to a high-speed photodetector and RF electrical pads. The filters are connected to DC pads for tuning.

	*

### Frequency domain analysis

* menu SiEPIC | Simulation | Circuit Simulation: Lumerical INTERCONNECT

	* Observe the transmission spectrum of the chip

	*

### Time domain analysis

* Characterize the transceiver in the time domain:

	* In INTERCONNECT, open the LSF file: GSiP_RingMod_Transceiver_Analysis_TimeDomain.lsf
	* This file adds voltage sources, four pattern generators, four lasers combined into a single input, and oscilloscopes.
	* Run the LSF file
	*

repository: SiEPIC/SiEPIC-Tools

gha_language: Python

gha_license_id: NOASSERTION

repo_name: SiEPIC/SiEPIC-Tools


text:
# Operations on Objects

The requests that are sent by users to OBS \(compatible with OpenStack Swift\) must comply with REST specifications and contain required header parameters. If a request is successfully processed, OBS \(compatible with OpenStack Swift\) returns a success response. If the request fails to be processed, OBS \(compatible with OpenStack Swift\) returns a message that contains the cause of the error. This chapter describes REST operations on objects. Authentication is implemented based on IAM.

>![](public_sys-resources/icon-note.gif) **NOTE:**
>In the event of invoking OBS APIs, if the value of  **Content-Length**  in a request is not a correct digital text, OBS \(compatible with OpenStack Swift\) will attempt to parse the content text and use it as the value of  **Content-Length**. For example,  **-H"Content-Length:26abc"**  is equivalent to  **-H"Content-Length:26"**. OpenStack Swift, however, returns the error code 400 \(Bad Request\).

-   **[Get Object Content and Metadata](get-object-content-and-metadata.md)**

-   **[Create or Replace Object](create-or-replace-object.md)**

-   **[Copy Object](copy-object.md)**

-   **[Delete Object](delete-object.md)**

-   **[Show Object Metadata](show-object-metadata.md)**

-   **[Create/Update/Delete Object Metadata](create-update-delete-object-metadata.md)**

repository: Polina-Gubina/docs

repo_name: Polina-Gubina/docs


text:
# Repo Monitor

## Open suggestion:
We will build a (HTML based) widget that shows information about a repository that is being worked on. This will help developers to see activity in the repository without having to browse to GitHhub and refresh the page all the time. We will use the GitHub REST API. The widget will be generic to be applied for any repository that a developer has access to and want to see information about. We will apply CI/CD practices and document everything in a README.md file.

## Members:
Simon Jäger, Fredrik Flovén

## Link to repo:
https://github.com/fredrikfloven/repo-monitor

repository: Agriad/devops-course

branch_name: refs/heads/test

repo_name: Agriad/devops-course


text:
+++
title = "OPSEC"
chapter = false
weight = 10
pre = "<b>1. </b>"
+++

## Considerations
`atlas` was designed to be as OPSEC friendly as possible, which in turn subjects the agnet to limited functionality. Currently, all commands for `atlas` use direct .NET methods or P/Invoke signatures where needed, while attempting to not require any third-party dependencies.

To prevent defensive telemetry into the operations of an `atlas` agent, two bypasses are included to attempt to limit this visibility.

- The first is an AMSI bypass to allow safer loading and execution of .NET assemblies. This technique is describe in [this post](https://rastamouse.me/blog/asb-bypass-pt3/) by [@_rastamouse](https://twitter.com/_rastamouse) and is part of the [SharpSploit](https://github.com/cobbr/SharpSploit/blob/master/SharpSploit/Evasion/Amsi.cs) project.

- The second method is a bypass to the `ETWEventWrite` function outlined by [@_xpn_](https://twitter.com/_xpn_) [here](https://www.mdsec.co.uk/2020/03/hiding-your-net-etw/).

### Post-Exploitation Jobs
All post-expoitation jobs ran by `atlas` are executed within the agent's process memory space. This limits agent exposure to defensive telemetry by reducing interactions with remote processes. This comes with a risk of jobs crashing an agent's process. To combat this risk, `atlas` uses a multi-thread approach with error handling to minimize the impact of a crashed job to the agent's main executing thread.

### Remote Process Injection
There is no built in process injection technique available for `atlas`. However, with the ability to load and execute arbitary assemblies, there is room to create your own .NET assembly to execute any form of process injection.

### Process Execution
There is currently no built in process execution method available in `atlas`. This was to reduce the urge for operators to immediatly execute commands without need. Process execution can be achieved through the use of a custom .NET assembly loaded and executed through `atlas`.

repository: NotoriousRebel/Mythic

repo_name: NotoriousRebel/Mythic


text:
# BTLabel

[![Version](https://img.shields.io/cocoapods/v/BTLabel.svg?style=flat)](http://cocoadocs.org/docsets/BTLabel)
[![License](https://img.shields.io/cocoapods/l/BTLabel.svg?style=flat)](http://cocoadocs.org/docsets/BTLabel)
[![Platform](https://img.shields.io/cocoapods/p/BTLabel.svg?style=flat)](http://cocoadocs.org/docsets/BTLabel)

UILabel subclass with vertical text alignment, insets and height calculation.

![screenshot](http://i.imgur.com/h9YfnlC.png)

## Usage

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

## Installation

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

    pod "BTLabel"

## Author

Денис Либит<EMAIL_ADDRESS>
## License

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

repository: KarimEbrahemAbdelaziz/Soundrocket

branch_name: refs/heads/main

repo_name: KarimEbrahemAbdelaziz/Soundrocket


text:
# Toggle
Simple Bash scripts for toggling camera and mic on/off.

# Using
Just execute `camera-toggle.sh` to toggle any connected usb camera on/off, or execute `mic-toggle.sh` to toggle the default pulse-audio sink on/off.

For more options see `--help`.

# Optional requirements
For improved user notification of the current camera/mic state, the script can use `notify-send`¹ utility, if available, for displaying a desktop notification,
or it can use the `mktrayicon`² utility for displaying a tray icon in the notification area.

1. https://developer.gnome.org/libnotify/

2. https://github.com/jonhoo/mktrayicon

# Installation (Arch Linux)
A PKGBUILD is provided at the root of the repository.

repository: HeavenVolkoff/toggle

repo_name: HeavenVolkoff/toggle


text:
### Redis

[Redis](https://redis.io/) transporter implements the publish/subscribe messaging paradigm and leverages [Pub/Sub](https://redis.io/topics/pubsub) feature of Redis. Published messages are categorized in channels, without knowing what subscribers (if any) will eventually receive the message. Each microservice can subscribe to any number of channels. In addition, more than one channel can be subscribed to at a time. Messages exchanged through channels are **fire-and-forget**, which means that if a message is published and there are no subscribers interested in it, the message is removed and cannot be recovered. Thus, you don't have a guarantee that either messages or events will be handled by at least one service. A single message can be subscribed to (and received) by multiple subscribers.

#### Installation

To start building Redis-based microservices, first install the required package:

```bash
$ npm i --save redis
```

#### Overview

To use the Redis transporter, pass the following options object to the `createMicroservice()` method:

```typescript
@@filename(main)
const app = await NestFactory.createMicroservice(ApplicationModule, {
  transport: Transport.REDIS,
  options: {
    url: 'redis://localhost:6379',
  },
});
```

> info **Hint** The `Transport` enum is imported from the `@nestjs/microservices` package.

Likewise, to create a client instance, we need to pass an options object with the same properties we saw above in the `createMicroservice()` method.

```typescript
ClientsModule.register([
  {
    name: 'MATH_SERVICE',
    transport: Transport.REDIS,
    options: {
      url: 'redis://localhost:6379',
    }
  },
]),
```

Other options to create a client (either `ClientProxyFactory` or `@Client()`) can be used as well. You can read about them [here](/microservices/basics#client).

#### Context

In more sophisticated scenarios, you may want to access more information about the incoming request. In Redis, you can access the `RedisContext` object.

```typescript
@@filename()
@MessagePattern('notifications')
getDate(@Payload() data: number[], @Ctx() context: RedisContext) {
  console.log(`Channel: ${context.getChannel()}`);
}
@@switch
@Bind(Payload(), Ctx())
@MessagePattern('notifications')
getDate(data, context) {
  console.log(`Channel: ${context.getChannel()}`);
}
```

> info **Hint** `@Payload()`, `@Ctx()` and `RedisContext` are imported from `@nestjs/microservices`.

#### Options

The `options` object is specific to the chosen transporter. The REDIS transporter exposes the properties described below.

    url
    Connection url

    retryAttempts
    Number of times to retry message

    retryDelay
    Delay between message retry attempts (ms)


text:
---
layout: post
title: 'PowerShell: Change Shortcut Target'
subtitle: A PowerShell script to change the target of a .url/.lnk file on multiple PCs.
share-img: /img/posts/shortcut_target_0.png
tags: [PowerShell, automation, desktop management, shortcuts]
---
Recently, as a part of retiring legacy Windows Server OS(s), I had to find a quick and dirty way to change the target location for a certain file in the Public desktop folder on all the machines in my environment. Yes, I know...any shortcuts should be deployed via Group Policy...I get it. At the time, this was the most efficient way to deploy given the access and timelines when these were deployed. I am slowly but surely utilizing GPOs to manage shared printers, mapped drives, and desktop shortcuts and settings.

So here was the task at hand:

_Search through a list of PCs and modify the target address on a specific web shortcut that pointed to an intranet page that resides on the C:\Users\Public\Desktop._

Seems simple enough, right? _grin._ Of course, the more I dug into the task, the more I wanted to add. Which has definitely helped with challenging myself in creating custom scripts for my environment. I have recently set out to dig in with PowerShell, and though I do watch some videos and read my go-to book, [Learn Windows PowerShell in a Month of Lunches](https://www.manning.com/books/learn-windows-powershell-in-a-month-of-lunches-second-edition){:target="_blank"}, there's honestly been no better learning than just starting with a simple, mundane task and work at automating it!

## Mass-changing the target address for a .url/.lnk on a list of PCs:

The beginning variables are short and sweet:

~~~
$LogFile = "C:\Path2Logfile\Log.txt"
$Computers = Get-Content -Path C:\Scripts\computers.csv
$Shell = New-Object -ComObject WScript.Shell
$NewTarget = "https://geeklifenow.com/"
~~~

I won't cover logging in depth, but you should use your preferred method of logging to get detailed feedback on this task. I have a pre-made .csv file with a list of my targeted computers inside. The _$Shell_ variable is the key to getting into manipulate the shortcut file. Finally, _$NewTarget_ is the address we want to set on the shortcut.

I place the workload inside a foreach loop and the task is as follows:

1. Check to see if the PC is online using the _[Test-Connection cmdlet](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.management/test-connection?view=powershell-6){:target="_blank"}_. This will return either a _True_ or _False_ result.)

2. If it is online, check for the shortcut file in the _C:\Users\Public\Desktop_ folder. I am using two conditions to make sure I grab the appropriate shortcut: The file ends with .url **AND** the file has the string
"web" in the name. This is where I know my environment enough that I know I will grab the right file. You will need to use the necessary conditions to grab the file you want in your environment.

3. _$ShortcutToChange_ will be populated with either the object information or it will be $null (It will not error if it doesn't find anything!), so then I check to see if I have anything by simply looking to see if the length of the variable is not 0: ***if ($ShortcutToChange.Length -ne 0)***

4. Then the magic happens! Which, when you see it, it's quite anti-climactic in the fact that it's a few lines to make the change.

5. I have been working a lot lately with the try/catch structure to get a better handle on error handling and logging, so I'm trying to catch any errors that may arise. I'm just logging any error that comes up, rather than catching a specific one. Catching specific errors will be something that I would like to work toward.

~~~
foreach ($Computer in $Computers) {
    $Online = Test-Connection -BufferSize 16 -Count 2 -ComputerName $Computer -Quiet
    try {
        if ($Online -eq $true) {
            try {
                $ShortcutToChange = Get-ChildItem -Path \\$Computer\C$\Users\Public\Desktop -ErrorAction Stop | Where-Object { $_.Extension -eq ".url" -and $_.Name -like '*web*' }
            }
            catch {
                $ErrorMessage = $_.Exception.Message
                Write-Log -Text "WARNING: $Computer is online, but error getting to the Public\Desktop! Error: $ErrorMessage"
                Continue
            }
            if ($ShortcutToChange.Length -ne 0) {
                try {
                    $url = $shell.CreateShortcut($ShortcutToChange.FullName)
                    $url.TargetPath = $NewTarget
                    $url.Save()
                    Write-Log -Text "SUCCESS: $Computer's GeekLifeNow link was successfully modified!"
                }
                catch {
                    $ErrorMessage = $_.Exception.Message
                    Write-Log -Text "WARNING: Error saving new GeekLifeNow link: $ErrorMessage"
                }
            }
            else {
                Write-Log -Text "$Computer does NOT have a GeekLifeNow link. Nothing to see here..."
            }
        }
        else {
            Write-Log -Text "WARNING: $Computer is offline."
        }
        }
    catch {
        $ErrorMessage = $_.Exception.Message
        Write-Log -Text "ERROR: Error connecting to $Computer : $ErrorMessage"
    }
}
~~~

So I tried to catch anywhere in which there would be an issue, and log the error. I also built in logging if the computer was offline. This is good in case you want to run another pass to get any PCs that were sleeping or powered off in the future. I'm also playing around with the text in logging with the SUCCESS/WARNING/ERROR designations on each line.

**BOOM!** I now have _x_ number of shortcuts modified so that they are no longer pointing to our legacy webserver without having to trot to each machine and have 3 meaningless conversations in passing, 12 extra fly-by IT requests, and a big waste of my life doing such a mundane task. My current environment consists of ~450 desktops, so I surely will be using GPOs to place these types of things on the desktop fleet, but it was nice to learn this task as it has given me a better understanding of PowerShell.

You can see this script in its entirety in my [GitHub](https://github.com/GeekLifeNow/PowerShell-Automation){:target="_blank"} repo.


text:
# await Meetup.get("9")
#### February 20, 2019 @ Cowork Funchal

## ⭐ Cloudflare Workers: Deploying serverless applications at the Edge (~165 Cloudflare datacenters), that efficiently scale and are geographic agnostic, at little cost.
[Hugo Romano](https://github.com/adaptive) [@adaptive](https://twitter.com/adaptive)

_workers, serverless, edge, cloudflare_

### Sponsors
🏢 [Cowork Funchal](http://www.coworkfunchal.pt/)
🍕 [Cloudflare](https://www.cloudflare.com/)

repository: madeiratech/talks

repo_name: madeiratech/talks


text:
# Coyote Badger

![Coyote Badger Home Screen](./coyote_badger/static/home.png)

#### Table of Contents
1. [Getting Started](#getting-started)
2. [Install](#install)
3. [Run](#run)
4. [Development](#development)
5. [Making or Requesting Changes](#making-or-requesting-changes)
6. [Videos](#videos)
7. [FAQ](#faq)

## Getting Started
Coyote Badger is designed to take a spreadsheet of accurately bluebooked
citations and search for them. Basically, it opens and controls a web
browser in the background to do what an editor would be doing manually.

When it runs, it will pull the sources for a particular project, and output
a list of the sources that were found, along with the actual PDF files
of the sources.

To get started with Coyote Badger, first follow the
[instructions to install](#install) the software, then follow the
[instructions to run](#run) the software. Once Coyote Badger is up and running,
you may find the short [tutorial videos](#videos) helpful to understand
how it works.

## Install
To install Coyote Badger:
1. Install Docker for your operating system by selecting the appropriate
   version [here](https://docs.docker.com/get-docker/) and following the
   installation instructions.
2. Once Docker is installed, you shouldn't have to change any of the default
   preferences, but make sure you have it running (see install instructions).
3. Download the latest "Source code (zip)" of Coyote Badger from
   [here](https://github.com/alexsands/coyote-badger/releases/latest).
   Then unzip the file and move it to somewhere on your computer that you'll
   remember (e.g., `Documents` folder). You can rename the containing folder
   if you'd like.
4. That's it! Now you can [run Coyote Badger](#run).

## Run
To run Coyote Badger, follow the instructions for your particular operating
system:

#### Mac
1. Make sure Docker is started on your computer
2. Navigate to your Coyote Badger folder
3. Right click on the `_start-mac.command` file, then select "Open". Accept
   the warning about the unidentified developer if it asks (you should only
   have to do this step once).
4. A Terminal window will open and you'll see it printing out information. Wait
   until you see `Running on http://<IP_ADDRESS>:5000/`.
   Once you see this, you can close the Terminal window. If it's your first
   time running, a lot of stuff will install and this will take
   several minutes (but you shouldn't have to wait this long again!).
5. Open your browser and go to [http://localhost:5000](http://localhost:5000)
6. You should see Coyote Badger!
7. When you're done using the program, right click on the `_stop-mac.command`
   file in the Coyote Badger folder, then select "Open". Accept
   the warning about the unidentified developer if it asks (you should only
   have to do this step once).

#### Windows
1. Navigate to your Coyote Badger folder
2. While holding Shift, right-click anywhere in the folder window
   and select "Open command window here"
3. Copy and paste the following into Command Prompt and press Enter
```sh
docker build . -t coyotebadger:latest
docker run -it --rm --name coyotebadger --memory="2g" --cpus="2" -v %cd%/_projects:/opt/coyotebadger/_projects -p 5000:5000 coyotebadger:latest
```
4. You'll start to see it printing out information. Wait
   until you see `Running on http://<IP_ADDRESS>:5000/`. If it's your first
   time running, a lot of stuff will install and this will take
   several minutes (but you shouldn't have to wait this long again!).
5. Open your browser and go to [http://localhost:5000](http://localhost:5000)
6. You should see Coyote Badger!
7. When you're done using the program, go back to the Command Prompt that was
   running and press Ctrl + C.

## Development
Coyote Badger uses Flask as the web server and Microsoft Playwright as the
automated browser. To improve or debug Coyote Badger, it's easiest to run
it directly from source with Python, instead of in the Docker container,
because you can view the `headless=False` Chromium browser.

First, create a virtual environment in the root and install the project
dependencies with:
```sh
virtualenv -p python3 venv
source venv/bin/activate
pip3 install -r requirements.txt
```

Then run the project with:
```sh
FLASK_ENV=development python3 -m coyote_badger.app
```

The project is generally structured as follows:
1. `/_projects`: holds the project data and is mounted to the Docker container
   as a volume.
2. `/coyote_badger/extensions`: these are the Chrome extensions that get added
   to the browser instance. They are slightly modified, with the description
   of the changes in the `README.md` in that directory.
3. `/coyote_badger/static`: holds the static files. In this case it's just the
   sources template file `Soruces.xlsx`.
4. `/coyote_badger/templates`: the frontend Jinja files for Flask.
5. `/coyote_badger/usr`: a user data folder for the Chromium browser instance.
6. `/coyote_badger/app.py`: the main routes and app logic for Flask.
7. `/coyote_badger/puller.py`: the main file for the web scraper and pulling
   sources. If Hein, Westlaw, or SSRN ever changes, this is where you should
   start.
8. `/coyote_badger/converter.py`: the main logic for turning an article/note
   Word document into the source inventory Excel sheet.
9. Everything else: these files shouldn't need to change too much in the
   future. The main thing that might break is likely in `puller.py` since
   that's where all the scraping logic happens.

To make it easier to see what is happening with Playwright, you can
increase the `slow_mo` argument to something higher in
`coyote_badger.puller.Puller.create_context()`.

In the event Hein, Westlaw, or SSRN ever changes their website, the logic for
actually pulling sources on the web is in `coyote_badger.puller.Puller.pull()`.
You can also contact me directly, just open an
[issue](https://github.com/alexsands/coyote-badger/issues), and I will get
an email about it. I'll happily take a look and try to help.

**Note:** As of 3/27/2021, it is not possible to download
Original Image files from Westlaw due to
[a bug in Chrome](https://bugs.chromium.org/p/chromium/issues/detail?id=761295)
that prevents the browser from being able to load PDF content-types in
`headless=False` mode. As a workaround, we use Firefox in `headless=False`
mode to grab sources from Hein, Westlaw, and SSRN. Unfortunately, Playwright
[does not support loading extensions in Firefox easily](https://github.com/microsoft/playwright/issues/2644),
so now we have to use a mix of Chrome (to load extensions for clean website
screenshots) and Firefox (to pull Hein, Westlaw, SSRN). Eventually, when either
issue is resolved, the code can be simplified by just using one browser.

## Making or Requesting Changes

If the project stops working as expected, please open up an
[issue](https://github.com/alexsands/coyote-badger/issues) with details on what
is failing. I will get an email about it and happily take a look. If you're
familiar with programming and would like to try fixing it yourself, you can
(1) open a pull request with your fix or (2) just upload the file/changes
you think should be made on the issue itself.

## Videos
- [Starting & Stopping](https://youtu.be/Pzyfdr_b198)
- [Creating a Source Inventory Template](https://youtu.be/p2cW8tUTOHU)
- [Pulling Sources](https://youtu.be/ypmY4Hfn5Rg)

## FAQ
**When I try to run the application, I get a message about not being
able to connect to the Docker daemon. What do I do?**

Make sure you open the Docker application and click Start before trying
to run Coyote Badger. You may need to do this after you restart your computer
if Docker does not start automatically.

**Everything is installed, it's running, but the actual Coyote Badger
application isn't pulling sources properly. What do I do?**

It's likely that Hein, Westlaw, or SSRN changed their website code and it
broke the automated puller. If you are familiar with programming, you can try
to fix this on your own with the [Development](#development) instructions and
then make an issue/pull request on GitHub. Otherwise, please read the
[Making or Requesting Changes](#making-or-requesting-changes) section.

**Hein login seems to always fail because my Duo isn't working. What do I do?**
The program works by attempting to log you in (using the username and password
you provide) to Hein, Westlaw, and SSRN in the background. To do so, Hein
may use Duo for two-factor authentication when you log in with your university
or organization email address. In order for the program to pass this step, you
must set your Duo two-factor authentication settings to use "Push Notifications"
by default. If you use text message codes the program has no way of entering
the pin while its running in the background (since it can't access your text
messages). You can change this preference to use "Push Notifications" by
default on your organization's Duo settings page. You'll also need to download
the Duo smartphone app.

**Why use `headless=False` with `xvfb` if you can't even see the browser?**

The program uses a few Chrome extensions to block ads and paywalls,
which unfortunately do not work in headless Chrome. The Chrome team does
not presently have this on their radar for development.

**Why is git ignoring some files when I make changes?**

The `_projects/Example` folder is being ignored so that it can be run as a
test set, without pushing new pull results to GitHub on each commit. It's a bit
deceiving though, because this doesn't happen in the `.gitignore` file. Instead,
these files are ignored via:
```sh
git update-index --skip-worktree <file>
```
To show which files are ignored, run:
```sh
git ls-files -v . | grep ^S
```

**Something else?**

Open up an [issue](https://github.com/alexsands/coyote-badger/issues) with your
question, and I will get an email about it. I'll happily take a look and try
to help.

## Maintenance
This code was written by Alex Sands and Warner Scott. Both authors, as well
the current research editor, have access to this repository and will receive
emails when new issues are submitted. If you'd like to improve this code,
please submit a PR rather than making changes offline. Keep this source
up to date!


text:
# Project Name

> Project description

## Related Projects

- https://github.com/viamis/similar-products
- https://github.com/viamis/photo-gallery-module
- https://github.com/viamis/amazon-service-tk
- https://github.com/viamis/review-module

## Table of Contents

1. [Usage](#Usage)
1. [Requirements](#requirements)
1. [Development](#development)

## Usage

> Some usage instructions

## Requirements

An `nvmrc` file is included if using [nvm](https://github.com/creationix/nvm).

- Node 6.13.0
- etc

## Development

## CRUD API

- /products/add (POST)
  - creates a new item record and returns modification results from the database
- /products/:id (GET)
  - serves the page of the product with id
- /products/:id/related (GET)
  - returns the similar products of the Product with ID id.
- /products/:id/update (PUT)
  - updates an item in its entirety on the database and returns the results of said operation from the database
- /products/:id/delete (DELETE)
  - removes a record from the database and returns the sucess message from the database.

### Installing Dependencies

From within the root directory:

```sh
npm install -g webpack
npm install
```

repository: Shopr-sf/similar-products

repo_name: Shopr-sf/similar-products


text:
# 正则匹配
## 数字开头
```JavaScript
const rule = /^[0-9]/
```
## 字母开头
```JavaScript
const rule =/^[A-Za-z]/
```

repository: browniu/note

repo_name: browniu/note


text:
# React & TailwindCSS Portfolio - With Dark Mode

A simple portfolio starter theme built with React and Tailwind CSS. This is the React version of [vuejs-tailwindcss-portfolio](https://github.com/realstoman/vuejs-tailwindcss-portfolio).

![React-TailwindCSS-Portfolio](https://user-images.githubusercontent.com/16396664/146666086-28e88beb-c2f0-431f-adfb-2396d8f64c80.png)

## Demo URL

[https://react-tailwindcss-portfolio.netlify.app](https://react-tailwindcss-portfolio.netlify.app)

## Coming features

-   Press features
-   Story telling approach to portfolio website
-   Testimonials from friends
-   Cursor changing
-   Animations and flowy background
-   Live clock
-   World happiness index
-   Projects pop up on hover
-   Workout heatmap
-   Animated I love ....
-   Auto dark mode when its night time in client time zone
-   Spotify API, playlist,
-   iPod inbuilt.
-   Dark mode changes my photo to sb else

## Features

-   [React v18](https://reactjs.org) with [React Router v6](https://reactrouter.com)
-   [Tailwind CSS v3](https://tailwindcss.com)
-   Context API For State Management
-   Custom Hooks
-   Unit Testing
-   Framer Motion transitions & animations
-   Reusable components
-   Dark mode
-   Projects filter by category
-   Projects filter by search
-   Smooth scroll
-   Counter
-   Dynamic forms
-   Back to top button
-   Download file button
-   Simple and responsive design

### To Contribute to this project, read the [Contribution Guidlines](https://github.com/realstoman/react-tailwindcss-portfolio/blob/main/CONTRIBUTING.md)

## Setup

1. Make sure you have Node JS installed. If you don't have it:

-   [Download it from nodejs.org](https://nodejs.org)
-   [Install it using NVM ](https://github.com/nvm-sh/nvm)
-   If you're on Mac, Homebrew is a good option too:

```
brew install node
```

2. Clone the repo:

```
git clone https://github.com/realstoman/react-tailwindcss-portfolio.git
```

3. Open the project folder:

```
cd react-tailwindcss-portfolio
```

4. Install packages and dependencies:

```
yarn
```

4. NOTE: If you don't have yarn installed, you can install it globally using npm:

```
npm install --global yarn
```

5. Start a local dev server at `http://localhost:3000`:

```
yarn start
```

6. ##### Run tests:

```
yarn test
```

## Notes

-   Always run `yarn install` after pulling new changes
-   I'll be constantly updating this repo as I'll be adding more sections to it, so please always check the projects section of this repo to see what tasks are under todo and in progress
-   Coming Soon [I'll be doing a screencast](https://www.youtube.com/realstoman). Soon I'll be uploading a video to my YouTube channel where I'll be going through the process of creating this portoflio
-   Illustrations from [unDraw](https://undraw.co) and [Freepik](https://freepik.com)
-   Images from [Unsplash](https://unsplash.com)
-   Feel free to use it as your own portfolio
-   Contributions are welcome

### License

[MIT](https://github.com/realstoman/react-tailwindcss-portfolio/blob/main/LICENSE)

repository: belligerentbeagle/portfolio-site

repo_name: belligerentbeagle/portfolio-site


text:
# Docker config container

## Why this project

In the context of big or distributed application, we use configurations manager like Zookeeper to easily deploy our configurations ... Why not do the same for containers? There are many aspects to manage as memory, cpu and others network configurations...

## What is this project

This project is a Proof of Concept (PoC) about execute container configured by centralized configuration service.

I never work with powerful system like Zookeeper. I know I can spend some time to implement it so I use a substitution solution, redis, to realise this PoC in hackday time.

## How to use

This project is base on python script an docker client. To be easier to test I include a container to use it.

The first step is get configuration from centralized service and build docker command to run container.

In first we need a redis instance:
```bash
$ docker run -p 6379:6379 --name redis -d redis
```

```bash
$ docker run --rm -it -v /var/run/docker.sock:/var/run/docker.sock <image_name> -h
```

Example
```bash
$ docker run --rm -it -v /var/run/docker.sock:/var/run/docker.sock hackday3 --host=<IP_ADDRESS> --port=6379 config -n nginx -e qlf -i nginx:1.9.4 -d true -m 300M -s 300M
$ docker run --rm -it -v /var/run/docker.sock:/var/run/docker.sock hackday3 --host=<IP_ADDRESS> --port=6379 run -n nginx -e qlf
```

## What next

* Improve error management
* Improve log
* Refactor code to be able to use different configuration manager service
* Use configuration manager service like Zookeeper
* Add feature to manage configuration and environment
* Work with common docker tools like docker-compose and swarm


text:
# me343-cme216-winter-2021

GitHub page for ME 343 / CME 216, Winter 2021

You can find the site at https://ericdarve.github.io/me343-cme216-winter-2021/.

If you find errors and want some changes to this material, please use the [Issues](https://github.com/EricDarve/me343-cme216-winter-2021/issues) tab above.


text:
You can send HipChat messages during your build.

You can, for example, send a HipChat message with the Build's bitrise.io URL,
the build's status (at the point where you include the HipChat step - usually it's best to
make it the very last step of the Workflow) and with the Public Install Page for the app.

To do this all you have to do is:

add a Send HipChat message step to your app's Workflow, after the Deploy to Bitrise.io step,

fill out the required inputs (authentication token, the room's ID you want to send the message to,
color of the message, ...),

and in the Message input field you can include environment variables
defined by Bitrise and by the steps which run before the HipChat Message step.

!!! note
If you click into any Step input field, an Insert Variable button will appear.
With this you can insert environment variables defined by Bitrise
(for example the App's title, the Build's unique ID or the Build's URL on Bitrise)
and environment variables exported by Steps which ran before this step
(for example an Xcode Build's status or the generated IPA path).

Fill out the HipChat steps' required input fields, and for the HipChat Message
step's Message input include the build's url with the $BITRISE_BUILD_URL environment variable,
the build's status at that point with the $BITRISE_BUILD_STATUS variable,
and the related Public Install Page URL with $BITRISE_PUBLIC_INSTALL_PAGE_URL.

An example Message input:

Your build's details can be found at: $BITRISE_BUILD_URL,
and the Public Install page at: $BITRISE_PUBLIC_INSTALL_PAGE_URL

Build status: $BITRISE_BUILD_STATUS

That's all. Once you configure your Workflow this way and start a new build,
you'll be notified about the build and deploy on HipChat,
including both the build's details url and the app's Public Install Page url.

repository: dbreuer/devcenter

gha_language: HTML

repo_name: dbreuer/devcenter


text:
# NewCoPho | New Context Photos

Replace anything that's not a 'person' in your photo with a new Background Image.
Uses PyTorch, Deeplabv3, ResNet101
Requires CUDA!

## Examples
|  |  |
|--|--|
|  |  |

## Windows Quickstart
1. Install [Python 3.6](https://www.python.org/downloads/)
2. Create Virtual Environment
 `python -m venv env`
3. Activate the Environment
 `"env/Scripts/activate"`
4. Install Requirements
`pip install -r requirements.txt -f https://download.pytorch.org/whl/torch_stable.html`
5. Run the Server
`flask run --host <IP_ADDRESS>`
6. Visit on Mobile Device
    http://your.ip.address:5000

## Quickstart Breakdown

#### Create Virtual Environment

This keeps all the dependencies for this project separate from other Python projects you may work on.

On Windows, run:

`python -m venv env`, which will create a virtual environment in a folder named 'env'.

You then 'activate' this environment by running this in a command prompt: `"env/Scripts/activate"`, which runs the activate.bat script. You need the double quotes for Windows to understand the command. Once you run this, your prompt should update to show `(env)` instead of `C:\FolderName` or wherever you saved the project.

#### Install Requirements.

The requirements have been saved into the requirements.txt file, so you can install this file with this command:

`pip install -r requirements.txt -f https://download.pytorch.org/whl/torch_stable.html`

The -f argument points pip towards the right place to download the torch and torchvision dependencies. This command fails for me without this argument.

If you have issues with PyTorch, you can install it for a specific Python + Cuda version using the instructions [here](https://pytorch.org/get-started/locally/).

## Execution

#### Run the Server.

I do it this way: `flask run --host <IP_ADDRESS>`, which will start the server in a way that other machines on your local network can access the host.

#### Visit the page in a browser (mobile browsers best).
Get your ip and visit it in a browser on port 5000. It will be something like http://<IP_ADDRESS>:5000

## Customization

Change the BGPortrait.jpg and BGLandscape.jpg files in the /media folder to use your own background images.

## Credits

Loading Icon and Backgrounds from [loading.io](https://loading.io)
Image Segmentation based on [this colab notebook](https://colab.research.google.com/github/pytorch/pytorch.github.io/blob/master/assets/hub/pytorch_vision_deeplabv3_resnet101.ipynb) from the Pytorch team.


text:
[![Appcelerator Titanium](http://www-static.appcelerator.com/badges/titanium-git-badge-sq.png)](http://appcelerator.com/titanium/) [![Appcelerator Alloy](http://www-static.appcelerator.com/badges/alloy-git-badge-sq.png)](http://appcelerator.com/alloy/)
____
#Appcelerator Titanium Alloy Mobile Project Supporting Beginner's Video Series

[Beginning Appcelerator Titanium Alloy - Video Channel](https://www.youtube.com/channel/UCMCcqbJpyL3LAv3PJeYz2bg)

1. sample tableView application
2. sample tableView app with complex row
3. sample tableView app with http client integration of nutrition api
4. sample tableView app with data-binding and intro to Alloy Models/Collections [tbd]
5. sample tableView app with data-binding, models/collection and intro to sync adapters [tbd]

----------------------------------

Appcelerator, Appcelerator Titanium and associated marks and logos are
trademarks of Appcelerator, Inc.

Titanium is Copyright (c) 2008-2015 by Appcelerator, Inc. All Rights Reserved.

Titanium is licensed under the Apache Public License (Version 2). Please
see the LICENSE file for the full license.

repository: aaronksaunders/nutritionAPIAdapter

repo_name: aaronksaunders/nutritionAPIAdapter


text:
# Chaotic Trading Card Game API

A repository of Chaotic Trading Card Game assets and out-of-the-box api solution for aggregating card data.

## Getting Started

To set up the API, begin by cloning the repository and installing dependencies.

```sh
$ git clone https://github.com/unitehenry/chaotic-api

$ cd chaotic-api

$ npm install
```

## Importing Data

This API uses MongoDB to store card data. Create an environment variable ```DATABASE_URL``` and add the url to the mongoDB server. Then run the import script.

```sh
$ echo "DATABASE_URL=mongodb://localhost/chaotic" > .env

$ npm run import
```

## Starting the Server

After the card data has been imported, you can begin serving data with the API server.

```sh
$ npm run serve
```

repository: unitehenry/chaotic-api

repo_name: unitehenry/chaotic-api


text:
# Local Setup

Please follow the following instruction to setup the necessary E2E Testing environment:
> Assumes Helm + kubectl are correctly setup & configured

1. Get [K3D](https://k3d.io/) following [this instructions](https://github.com/rancher/k3d#get).
2. Install [arkade](https://github.com/alexellis/arkade), **Important** for _windows user_ is to leverage Git Bash or another Bash.
3. Start a new k8s cluster `$ k3d cluster create openfaas`.
4. Install OpenFaaS to newly created Cluster `$ ark install openfaas --basic-auth=false`, make sure to update your kubectl config prior to use the k3d cluster.
5. Add Helm Repo for Rabbit MQ `$ helm repo add bitnami https://charts.bitnami.com/bitnami` & `$ helm repo update`.
6. Deploy RabbitMQ using helm `$ helm install rabbit -f ./hack/rabbit-values.yaml bitnami/rabbitmq`.
7. Now you can forward the relevant ports from openfaas (8080) & rabbitmq (5672).
8. Deploy Function listening under the relevant Topics `$ faas-cli store deploy figlet --annotation topic="Foo,Bar,Dead,Beef"`
9. You can use the HTTP Api exposed via 15672 to publish messages (*Username:* user *Password:* pass)

repository: Templum/rabbitmq-connector

branch_name: refs/heads/develop

gha_language: Go

repo_name: Templum/rabbitmq-connector


text:
Chemical.=[G/Agt-MasterService-CmA/Sec/Environment/Chemical/0.md]

Ti=Environmental Health and Safety

0.sec={_Supplier} represents, warrants and certifies that:

xlist=

{Safe.sec}

{Chemical.Good.sec}

{Chemical.Bad.sec}

{Chemical.Hazardous.sec}

NB Environ=there is a work-around in the list punctuation.

Safe.sec=It will take appropriate actions necessary to protect health, safety and the environment, including, without limitation, in the workplace and during transport;

=[G/Z/Base]

repository: CommonAccord/Cmacc-Org

gha_language: CSS

repo_name: CommonAccord/Cmacc-Org


text:
SonarQube License-Check
===================

[![Build Status](https://travis-ci.org/porscheinformatik/sonarqube-licensecheck.png?branch=master)](https://travis-ci.org/porscheinformatik/sonarqube-licensecheck)

This [SonarQube](http://www.sonarqube.org/) plugin ensures that projects in an organization adhere to a set of
standard libraries and versions. This enables the governance of the used libraries and licences.

## License

This software is licensed under the [Apache Software License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)

## Compatibility

### SonarQube
The plugin is compatible with SonarQube >= 5.3 and <= 5.6.

## Installation

Put the pre-built jar-file (from release downloads) in the directory `$SONARQUBE_HOME/extensions/plugins` and
restart the server to install the plugin.

## Execution

When a project is analyzed using the `mvn sonar:sonar` in command line the extension is started automatically.

## Configuration

After booting the SonarQube Server with the License-Check Plugin two new options can be found in the tab
Administration.

* Within the general settings the plugin can be manually enabled or disabled. By default it is enabled. ![General
configuration](docs/licensecheck_general_configuration.png)
* All other configuration is under License-Check specific settings (Configuration > License Check) ![License
configuration](docs/licensecheck_configuration.png)
* If you want to create issues on license violation or unknown licences, enabled the rules "License is not allowed"
and "Dependency has unknown license"

## Features

### Analysis

The plugin scans for dependencies defined in your project including all transitive dependencies.

Currently supported formats are:
* Maven POM files - all dependencies with scope "compile" and "runtime" are checked
* NPM package.json files - all dependencies (except "devDependencies") are checked

### Dashboard widgets

The plugin contains two dashboard widgets - the first ("License data") showing a list of dependencies with version and
license, the second ("Used Licenses") a list of all used licences. Each widget shows the status of the license
(allowed, not allowed, not found).

Example for "License data":

Status	Name	Version	Status

Allowed	org.springframework.boot:spring-boot	1.4.0.RELEASE	Apache-2.0

Allowed	core-js	2.4.0	MIT

Not Allowed	dk.brics.automaton:automaton	1.11-8	BSD-3-Clause

Not Found	saxon:saxon	<IP_ADDRESS>j

Example for "Used Licenses":

Identifier	Name	Status

Apache-2.0	Apache License 2.0	Allowed

MIT	MIT License	Allowed

BSD-3-Clause	BSD 3-clause New or Revised License	Not Allowed

repository: pombredanne/sonarqube-licensecheck

repo_name: pombredanne/sonarqube-licensecheck


text:
# Html5Video Plugin #

This plugin allows playback of local video files using embedded html 5 video tags. This repository contains both the plugin files and a sample Android application that uses the plugin. Tested on Android API 15 - 17

# Source #
https://github.com/jaeger25/Html5Video

repository: njtman/phonegap-plugins

repo_name: njtman/phonegap-plugins


text:
# _meta.main

The main run method allows you to execute logic when the
extension has been applied.

	var foo = Nux.NS('foo');

	foo._meta.main = function(nux) {
		Nux.slog('SUP!', 'foo')
	}

Alternatively, you may pass a string reference to a method of which you would like to call.

	var myExt = Nux.NS('example')

	myExt.metaRun = function(config){
		Nux.log('metaRun. Optionally run another method name at load')
	}

	myExt._meta.main = 'metaRun'

Finally, if the _meta.main method is not implemented, a root method `run()` will be called. This is mostly a legacy supported feature and will be removed.

	var foo = Nux.NS('foo');

	foo.run = function(config){
	    Nux.slog("Hi :)", 'foo')
	}

or finally:

	foo._meta.run = function(){
		// run method.
	}

repository: TheGlycerine/Nux

repo_name: TheGlycerine/Nux


text:
1. Name
# Lab02 Unit Testing

2. One-Liner
This program is a C# Console application replicating an imaginary ATM with 4 choices: deposit, withdraw, check balance and exit.

3. Usage

a. First install appropriate programs. Refer to Step 5 in this README.
b. You will be given 4 numbered choices: deposit, withdraw, check balance and exit.
c. If you type in 1, you get to deposit. Put in a numbered amount pertaining to a decimal and you will then be shown how much you deposited and be returned.
d. If you type in 2, you get to withdraw. Put in a numbered amount pertaining to a decimal and you will then withdraw the amount in the balance. If you put in more than what is in the balance, you will be kicked out.
e. If you type in 3, you will get to see your balance. Depending on what you did when you deposited or withdrew, the balance will show the result. You will then be sent back to the main menu.
f. If you type in 4, you will then be exited of the program.
e. Rule of thumb is if you type anything besides any of the choices, you will be either kicked out of the program or given a message saying "Problem occurred."

Visual
![startupImage](assets/ATMApp.JPG)

4. API
No API's were harmed in the making of this.

5. Installation
Install Visual Studio 2017 and .NET Core SDK.

6. License
This program's License is MIT.


text:
# Ping Pong in Ruby

#### By Meaghan Jones & Rony Nasr, June 27th, 2016

## Description
A Ruby app that takes a number from the user and returns a list of numbers and strings that corresponds to the Ping-Pong solution.

## Specs
1)It can count up to the provided number.
* Example Input: 2
* Example Output: [1,2]

2)It can replace multiples of 3 with the word "ping".
* Example Input: 3
* Example Output: [1,2,"ping"]

3)It can replace multiples of 5 with the word "pong".
* Example Input: 5
* Example Output: [1,2,"ping",4,"pong"]

4)It can replace multiples of 15 with the word "pingpong".
* Example Input: 15
* Example Output: [..."ping",13,14,"pingpong"]

### License

*This software is licensed under the MIT license.*

Copyright (c) 2016 **Meaghan and Rony**


text:
Adafruit Ultimate GPS Sensor Library
---------------------------------------

Library for asynchronouse use of Adafruit Ulitmate GPS
(MTK3339 Version 3)

---------------------------------------

This library allows for asynchronous use of the sensor. Data from the sensor
is typically generated every second or so. This library checks to see if the sensor
has fresh data available to read and immediately returns if not.  Once data is
available, it is read and parsed. Only NMEA GGA and RMC sentence types are
supported at this time. All other sentence types are ignored.

The calling process starts by calling into the Read() method. This library
initiates a fresh read then immediately returns to the calling process if no
data is available. Each subsequent call into the read() method causes the library
to resume where it last left off. A return value is passed back to the caller to
indicate the state of the machine (reading, success or error).

GPS_STATUS_NODATA:          GPS reports no new data available to parse.

GPS_STATUS_READING:         A read is in progress.

GPS_STATUS_SUCCESS_GGA:     A read has been successfully completed and values have
GPS_STATUS_SUCCESS_RMC:     been processed. The status code reflects the sentence
                            type that was processed on this read.

GPS_STATUS_SUCCESS_OTH:     A read has been successfully completed but the sentence
                            type is not supported.

GPS_ERROR_CHECKSUM:         A unexpected error occurred. The library has abandoned
GPS_ERROR_PARSE_ERR:        the current read operation and is ready to start a new
GPS_ERROR_TIMEOUT:          read. The values have not be updated.

SAMPLE USAGE:
---------------------------------------

```cpp

#include <GPS_MTK3339.h>
#include <SoftwareSerial.h>

SoftwareSerial Serial1(2, 3);
GPS_MTK3339 gps(&Serial1);

void setup() {
    Serial.begin(115200);
    Serial1.begin(9600);
}

void loop(){
    uint8_t r = gps.Read();
    bool r2 = false;

    switch(r){
        case GPS_STATUS_SUCCESS_GGA:
            Serial.println("  GGA:");
            r2 = true;
            break;
        case GPS_STATUS_SUCCESS_RMC:
            Serial.println("  RMC:");
            r2 = true;
            break;
        case GPS_STATUS_SUCCESS_OTH:
            Serial.println("  Other sentence type read:");
            break;
    }

    if(r2){
        Serial.print("\tSTATUS:    ");Serial.println(gps.StatusChar);
        Serial.print("\tLATITUDE:  ");Serial.println(gps.Latitude, 2);
        Serial.print("\tLONGITUDE: ");Serial.println(gps.Longitude, 2);
        Serial.print("\tALTITUDE:  ");Serial.println(gps.Altitude, 2);
        Serial.println();
    }

    Serial.print(".");
    delay(50);
}

```

Repository Contents
---------------------------------------

* **/examples** - Example sketches for the library (.ino). Run these from the Arduino IDE.
* **/src** - Source files for the library (.cpp, .h).
* **keywords.txt** - Keywords from this library that will be highlighted in the Arduino IDE.
* **library.properties** - General library properties for the Arduino package manager.
* **LICENSE.md** - Licence information.
* **README.md** - This file.

Version History
---------------------------------------

* V_1.0.0 - Initial Release

License Information
---------------------------------------

Software License Agreement (BSD License)

Copyright (c) 2017, Ralf Thompson
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.

2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.

3. Neither the name of the copyright holders nor the
names of its contributors may be used to endorse or promote products
derived from this software without specific prior written permission.

This library draws heavily on the work by the folks at adafruit.
The original license text of that work follows:

    // **************************************************************************
    //  This is a library for the BNO055 orientation sensor
    //
    //  Designed specifically to work with the Adafruit BNO055 Breakout.
    //
    //  Pick one up today in the adafruit shop!
    //  ------> http://www.adafruit.com/products
    //
    //  These sensors use I2C to communicate, 2 pins are required to interface.
    //
    //  Adafruit invests time and resources providing this open source code,
    //  please support Adafruit andopen-source hardware by purchasing products
    //  from Adafruit!
    //
    //  Written by KTOWN for Adafruit Industries.
    //
    //  MIT license, all text above must be included in any redistribution
    // **************************************************************************

repository: secavian/arduino

repo_name: secavian/arduino


text:
---
title: Configuration
weight: 3
pre: "<b>3. </b>"
---

### JSON configuration

__Version 2__

```json
{
  "version": 2,
  // Remote DNS servers to be asked when can not solve from docker or local storage
  // If no one server was specified then the <IP_ADDRESS> will be used
  "remoteDnsServers": [ "<IP_ADDRESS>", "<IP_ADDRESS>:54" ],

  // all existent environments
  "envs": [
    {
      "name": "", // empty string is the default enviroment
      "hostnames": [ // all local hostnames entries
        {
          // (optional) used to control it will be automatically generated if not passed
          "id": 1,
          "hostname": "github.com",
          "ip": "<IP_ADDRESS>",
          "ttl": 255 // how many seconds cache this entry
        }
      ]
    }
  ],
  "activeEnv": "", // the current environment keyname
  "webServerPort": 0, // web admin port, when 0 the default value is used, see --help option
  "dnsServerPort": 8980, // dns server port, when 0 the default value is used
  "logLevel": "DEBUG",
  "logFile": "console" // where the log will be written,
  "registerContainerNames": false, // if should register container name / service name as a hostname
  "domain": "", // The container names domain
  "dpsNetwork": false, // if should create a bridge network for dps container
  "dpsNetworkAutoConnect": false // if should connect all containers to dps container
}
```

__Version 1__

```json
{
  "remoteDnsServers": [ [8,8,8,8], [4,4,4,4] ], // Remote DNS servers to be asked when can not solve from docker or local storage
                                                // If no one server was specified then the <IP_ADDRESS> will be used
  "envs": [ // all existent environments
    {
      "name": "", // empty string is the default
      "hostnames": [ // all local hostnames entries
        {
          "id": 1,
          "hostname": "github.com",
          "ip": [192, 168, 0, 1],
          "ttl": 255
        }
      ]
    }
  ],
  "activeEnv": "", // the default env keyname
  "lastId": 1, // hostnames sequence, don't touch here
  "webServerPort": 0, // web admin port, when 0 the default value is used, see --help option
  "dnsServerPort": 8980, // dns server port, when 0 the default value is used
  "logLevel": "DEBUG",
  "logFile": "console" // where the log will be written,
  "registerContainerNames": false // if should register container name / service name as a hostname
}
```

### Environment variable configuration

| VARIBLE                     	| DESCRIPTION                                                                 	| DEFAULT VALUE    	|
|-----------------------------	|-----------------------------------------------------------------------------	|------------------	|
| MG_RESOLVCONF               	| Linux resolvconf path to set DPS as default DNS                             	| /etc/resolv.conf 	|
| MG_LOG_LEVEL                	|                                                                             	| INFO             	|
| MG_LOG_FILE                 	| Path where to logs will be stored                                           	| console          	|
| MG_REGISTER_CONTAINER_NAMES 	| if should register container name / service name as a hostname              	| false            	|
| MG_HOST_MACHINE_HOSTNAME    	| hostname to solve host machine IP                                           	| host.docker      	|
| MG_DOMAIN                   	| The container names domain (requires MG_REGISTER_CONTINER_NAMES=TRUE) 	| .docker          	|

### Terminal configuration

```
  -compress
    	compress replies
  -conf-path string
    	The config file path  (default "conf/config.json")
  -cpuprofile string
    	write cpu profile to file
  -default-dns
    	This DNS server will be the default server for this machine (default true)
  -domain string
    	Domain utilized to solver containers and services hostnames (default "docker")
  -dps-network
    	Create a bridge network for DPS increasing compatibility
  -dps-network-auto-connect
    	Connect all running and new containers to the DPS network, this way you will probably not have resolution issues by acl (implies dps-network=true)
  -help
    	This message
  -host-machine-hostname string
    	The hostname to get host machine IP (default "host.docker")
  -log-file string
    	Log to file instead of console, (true=log to default log file, /tmp/log.log=log to custom log location) (default "console")
  -log-level string
    	Log Level ERROR, WARNING, INFO, DEBUG (default "INFO")
  -register-container-names
    	If must register container name / service name as host in DNS server
  -server-port int
    	The DNS server to start into (default 53)
  -service string
    	Setup as service, starting with machine at boot
    			docker = start as docker service,
    			normal = start as normal service,
    			uninstall = uninstall the service from machine
  -service-publish-web-port
    	Publish web port when running as service in docker mode (default true)
  -tsig string
    	use MD5 hmac tsig: keyname:base64
  -version
    	Current version
  -web-server-port int
    	The web server port (default 5380)
```

repository: logward/dns-proxy-server

repo_name: logward/dns-proxy-server


text:
# IP: `amdc_adc_1.0`

This IP core is a driver for the ADC device used on the AMDC hardware ([LTC2320-14](https://www.analog.com/media/en/technical-documentation/data-sheets/232014fa.pdf)).

## Features

- Supports configurable SPI clock rates (100 MHz [buggy], 50 MHz [recommended], 25 MHz, 12.5 MHz)
- ADC acquisition is free-running at maximum sample rate (much higher than expected PWM)
- Eight channel data is transfered synchronously from ADC
- Valid incoming ADC data is copied to user data registers at configurable times:
    - Synchronous to PWM carrier high point
    - Synchronous to PWM carrier low point
    - Synchronous to PWM carrier high and low point
    - Asynchronous to PWM carrier

## IP Interface

The IP is accessed via the AXI4-Lite register-based interface from the DSP. This interface can read the raw ADC data and update the control register.

## Configuration

This IP has no build-time configuration parameters. It expects a 200 MHz clock input from the AXI interconnect.

## Register Map

| Offset | Name | R/W | Description |
| -- | -- | -- | -- |
| 0x00 | ANALOG_CHANNEL1 | R | Raw ADC channel 1 data register |
| 0x04 | ANALOG_CHANNEL2 | R | Raw ADC channel 2 data register |
| 0x08 | ANALOG_CHANNEL3 | R | Raw ADC channel 3 data register |
| 0x0C | ANALOG_CHANNEL4 | R |Raw ADC channel 4 data register |
| 0x10 | ANALOG_CHANNEL5 | R | Raw ADC channel 5 data register |
| 0x14 | ANALOG_CHANNEL6 | R | Raw ADC channel 6 data register |
| 0x18 | ANALOG_CHANNEL7 | R | Raw ADC channel 7 data register |
| 0x1C | ANALOG_CHANNEL8 | R | Raw ADC channel 8 data register |
| 0x20 | ANALOG_CONTROL | RW | Configuration register |
| 0x24 | ANALOG_UNUSED1 | RW | Unused register |

### Register: `ANALOG_CHANNEL*`

| Bits | Name | Description |
| -- | -- | -- |
| 31:0 | DATA | Sign-extended, 2's complement, 14-bit raw data from ADC |

### Register: `ANALOG_CONTROL`

| Bits | Name | Description |
| -- | -- | -- |
| 3 | PWM_SYNC_LOW | Enables sync of ADC samples to PWM carrier low point |
| 2 | PWM_SYNC_HIGH | Enables sync of ADC samples to PWM carrier high point |
| 1:0 | CLKDIV | Clock divisor for SCLK generation from 200 MHz main clock (0: DIV2, 1: DIV4, 2: DIV8, 3: DIV16) |

## Testing

This IP has been tested on the AMDC REV D hardware target and works when SCLK = 50 MHz (`CLKDIV` = DIV4). At 100 MHz, data bits start to be missed -- it looks like off-by-one issues with timing in the RTL.

repository: Severson-Group/AMDC-Firmware

gha_language: C

repo_name: Severson-Group/AMDC-Firmware


text:
# Using Playground

## Description

- Demo how to use Playground in production
- [Carthage](https://github.com/Carthage/Carthage) as dependency manager
- Inspired by [Playground driven development in Swift](https://medium.com/flawless-app-stories/playground-driven-development-in-swift-cf167489fe7b) article

## Author

Artem Novichkov<EMAIL_ADDRESS>
[![Get help on Codementor](https://cdn.codementor.io/badges/get_help_github.svg)](https://www.codementor.io/artemnovichkov?utm_source=github&utm_medium=button&utm_term=artemnovichkov&utm_campaign=github)

## License

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

repository: artemnovichkov/UsingPlayground

repo_name: artemnovichkov/UsingPlayground


text:
# Microsoft Azure IoT Device Provisioning Service SDK for C

## End of active development for service SDK

The Azure IoT Device Provisioning Service SDK for C is no longer under active development.

We will continue to fix critical bugs such as crashes, data corruption, and security vulnerabilities.  We will **NOT** add any new feature or fix bugs that are not critical, however.

Azure IoT Service SDK support is available in higher-level languages ([C#](https://github.com/Azure/azure-iot-sdk-csharp), [Java](https://github.com/Azure/azure-iot-sdk-java), [Node](https://github.com/Azure/azure-iot-sdk-node), [Python](https://github.com/Azure/azure-iot-sdk-python)).

The rest of this repo - for instance the [the provisioning code that runs on devices themselves](../provisioning_client) for deploying code to devices - continues to be under active development.  This ending of new features only applies to code under this subfolder.

repository: Azure/azure-iot-sdk-c

repo_name: Azure/azure-iot-sdk-c


text:
# 0.0.7 (11 March 2021)
- [#9](https://github.com/StefH/Matroska/pull/9) - Remove signing from Matroska and Matroska.Muxer projects [enhancement] contributed by [StefH](https://github.com/StefH)
- [#8](https://github.com/StefH/Matroska/issues/8) - A strongly-named assembly is required. (Exception from HRESULT: 0x80131044) [bug]

# 0.0.6 (19 January 2021)
- [#7](https://github.com/StefH/Matroska/pull/7) - Use Ebml.xml to generate classes + use Span.ReaderWriter version 0.0.3 contributed by [StefH](https://github.com/StefH)

# 0.0.5 (12 January 2021)
- [#5](https://github.com/StefH/Matroska/pull/5) - Generate models based on Matroska specification contributed by [StefH](https://github.com/StefH)
- [#6](https://github.com/StefH/Matroska/pull/6) - Use SpanReader + SpanWriter contributed by [StefH](https://github.com/StefH)

# 0.0.4 (07 January 2021)
- [#4](https://github.com/StefH/Matroska/pull/4) - Add Tags element + improve OggCRC32 contributed by [StefH](https://github.com/StefH)

# 0.0.3 (06 January 2021)
- [#3](https://github.com/StefH/Matroska/pull/3) - Replace System.Runtime.Caching by a Dictionary [enhancement] contributed by [StefH](https://github.com/StefH)

# 0.0.2 (06 January 2021)
- [#2](https://github.com/StefH/Matroska/pull/2) - Add more properties [enhancement] contributed by [StefH](https://github.com/StefH)

# 0.0.1 (05 January 2021)
- [#1](https://github.com/StefH/Matroska/pull/1) - Add OggOpus Demuxer [enhancement] contributed by [StefH](https://github.com/StefH)

repository: robmikh/Matroska

repo_name: robmikh/Matroska


text:
LastPass Confluence SAML Plugin
===============================

The LastPass Confluence SAML Plugin enables SAML 2.0 single-sign-on to
hosted Confluence applications.  This implements the Service Provider
interface for SAML Authentication.

What do I need to use it?
-------------------------

You will need a recent hosted Atlassian Confluence installation.  This
has been tested with version 6.10.

You will also need a SAML IdP provider.  If you do not have one,
we suggest our own IdP service, part of LastPass Enterprise,
at https://lastpass.com/.

Building the Plugin from Source
-------------------------------

You must first install Atlassian Confluence, and set the confluence.home.dir
in the build.xml to match its location.

To install:

    $ ant && sudo ant install

See the INSTALL file for additional details.

repository: max-allan-surevine/confluence-saml

repo_name: max-allan-surevine/confluence-saml


text:
![BattleArena](http://dev.bukkit.org/media/images/44/472/BattleArena_Large.png)
==========

A complete Event system for minecraft.
* Comes default with several Match and Event Types
* Huge amounts of customization through the configs and in game commands
* Framework and API for easily creating custom matches/events.

Default Match Types:
---------
* Arena : You fight with what is given to you in the config. You can't bring items in or out.

* Colloseum : 4 teams against each other, last man standing wins.
* BattleGround : 1 minute match where the winner is the one with the highest kills after 1 minute. 4 teams of 1 player each compete.

Default Event Types:
---------
* Free For All : last player/team left standing wins
* DeathMatch : 2 minute event where if you die you respawn. Highest kills wins
* Tournament : ( bracket tournament for any number of teams )

Adding to BattleArena
------------
I will gladly accept any code contributions through github.
If you need help with the API or writing a plugin for BattleArena I will help as well.

Links
------------
* [IRC](http://www.esper.net/publicirc.php) (#alkarin on irc.esper.net, join channel BattlePlugins)
* [Bukkit Page](http://dev.bukkit.org/server-mods/battlearena/) (BattleArena on Bukkit)

repository: ntakouris/RFS

repo_name: ntakouris/RFS


text:
# FRITZ!Box Upnp statistics exporter for Prometheus

This exporter exports some variables from an [AVM Fritzbox](https://avm.de/produkte/fritzbox/) to Prometheus.

[![Docker Build Status](https://img.shields.io/docker/build/mxschmitt/fritzbox_exporter.svg)](https://store.docker.com/community/images/mxschmitt/fritzbox_exporter)
[![GoDoc](https://godoc.org/github.com/mxschmitt/fritzbox_exporter/pkg/fritzboxmetrics?status.svg)](https://godoc.org/github.com/mxschmitt/fritzbox_exporter/pkg/fritzboxmetrics)

![FRITZ!Box Prometheus Exporter](./docs/logo.svg)

## Compatibility

This exporter is known to work with the following models:

| Model          | Firmware |
|----------------|----------|
| FRITZ!Box 4040 | 06.83    |
| FRITZ!Box 7390 | 06.51    |
| FRITZ!Box 7490 | 06.51    |
| FRITZ!Box 6490 | 06.52    |
| FRITZ!Box 7560 | 06.92    |

**FRITZ!OS 7 is not fully supported!**

## FRITZ!OS 7.00+

`Heimnetz` > `Netzwerk` > `Netwerkeinstellungen` > `Statusinformationen über UPnP übertragen`

## FRITZ!OS 6

`Heimnetz` > `Heimnetzübersicht` > `Netzwerkeinstellungen` > `Statusinformationen über UPnP übertragen`

## Usage

```bash
$GOPATH/src/github.com/mxschmitt/fritzbox_exporter/cmd/exporter/exporter -h
Usage $GOPATH/src/github.com/mxschmitt/fritzbox_exporter/cmd/exporter/exporter:
  -gateway-address string
      The hostname or IP of the FRITZ!Box (default "fritz.box")
  -gateway-port int
      The port of the FRITZ!Box UPnP service (default 49000)
  -listen-address string
      The address to listen on for HTTP requests. (default ":9133")
  -test
      print all available metrics to stdout
```

### With Docker

```shell
docker run -d --name fritzbox-exporter -p "9133:9133" mxschmitt/fritzbox_exporter
```

Then call the metrics endpoint on http://localhost:9133/metrics

## Exported metrics

These metrics are exported:

```bash
# HELP fritzbox_exporter_collect_errors Number of collection errors.
# TYPE fritzbox_exporter_collect_errors counter
fritzbox_exporter_collect_errors 0
# HELP gateway_wan_bytes_received bytes received on gateway WAN interface
# TYPE gateway_wan_bytes_received counter
gateway_wan_bytes_received{gateway="fritz.box"} 5.037749914e+09
# HELP gateway_wan_bytes_sent bytes sent on gateway WAN interface
# TYPE gateway_wan_bytes_sent counter
gateway_wan_bytes_sent{gateway="fritz.box"} 2.55707479e+08
# HELP gateway_wan_connection_status WAN connection status (Connected = 1)
# TYPE gateway_wan_connection_status gauge
gateway_wan_connection_status{gateway="fritz.box"} 1
# HELP gateway_wan_connection_uptime_seconds WAN connection uptime
# TYPE gateway_wan_connection_uptime_seconds gauge
gateway_wan_connection_uptime_seconds{gateway="fritz.box"} 65259
# HELP gateway_wan_layer1_downstream_max_bitrate Layer1 downstream max bitrate
# TYPE gateway_wan_layer1_downstream_max_bitrate gauge
gateway_wan_layer1_downstream_max_bitrate{gateway="fritz.box"} 1.286e+07
# HELP gateway_wan_layer1_link_status Status of physical link (Up = 1)
# TYPE gateway_wan_layer1_link_status gauge
gateway_wan_layer1_link_status{gateway="fritz.box"} 1
# HELP gateway_wan_layer1_upstream_max_bitrate Layer1 upstream max bitrate
# TYPE gateway_wan_layer1_upstream_max_bitrate gauge
gateway_wan_layer1_upstream_max_bitrate{gateway="fritz.box"} 1.148e+06
# HELP gateway_wan_packets_received packets received on gateway WAN interface
# TYPE gateway_wan_packets_received counter
gateway_wan_packets_received{gateway="fritz.box"} 1.346625e+06
# HELP gateway_wan_packets_sent packets sent on gateway WAN interface
# TYPE gateway_wan_packets_sent counter
gateway_wan_packets_sent{gateway="fritz.box"} 3.05051e+06
```

## Output of -test

The exporter prints all available Variables to stdout when called with the -test option.
These values are determined by parsing all services from http://fritz.box:49000/igddesc.xml

    Name: urn:schemas-any-com:service:Any:1
    WANDevice - FRITZ!Box 7490: urn:schemas-upnp-org:service:WANCommonInterfaceConfig:1
      GetCommonLinkProperties
        WANAccessType: DSL
        Layer1UpstreamMaxBitRate: 1148000
        Layer1DownstreamMaxBitRate: 12860000
        PhysicalLinkStatus: Up
      GetTotalBytesSent
        TotalBytesSent: 255710914
      GetTotalBytesReceived
        TotalBytesReceived:<PHONE_NUMBER>
      GetTotalPacketsSent
        TotalPacketsSent: 3050536
      GetTotalPacketsReceived
        TotalPacketsReceived: 1346651
      GetAddonInfos
        ByteSendRate: 0
        ByteReceiveRate: 0
        PacketSendRate: 0
        PacketReceiveRate: 0
        TotalBytesSent: 255710914
        TotalBytesReceived:<PHONE_NUMBER>
        AutoDisconnectTime: 0
        IdleDisconnectTime: 10
        DNSServer1: <IP_ADDRESS>
        DNSServer2: <IP_ADDRESS>
        VoipDNSServer1: <IP_ADDRESS>
        VoipDNSServer2: <IP_ADDRESS>
        UpnpControlEnabled: false
        RoutedBridgedModeBoth: 1
    WANConnectionDevice - FRITZ!Box 7490: urn:schemas-upnp-org:service:WANDSLLinkConfig:1
      GetDSLLinkInfo
        LinkType: PPPoE
        LinkStatus: Up
      GetModulationType
        ModulationType: ADSL G.lite
      GetDestinationAddress
        DestinationAddress: NONE
      GetATMEncapsulation
        ATMEncapsulation: LLC
      GetFCSPreserved
        FCSPreserved: true
      GetAutoConfig
        AutoConfig: true
    WANConnectionDevice - FRITZ!Box 7490: urn:schemas-upnp-org:service:WANIPConnection:1
      X_AVM_DE_GetDNSServer
        IPv4DNSServer1: <IP_ADDRESS>
        IPv4DNSServer2: <IP_ADDRESS>
      GetAutoDisconnectTime
        AutoDisconnectTime: 0
      GetIdleDisconnectTime
        IdleDisconnectTime: 0
      X_AVM_DE_GetExternalIPv6Address
        ExternalIPv6Address:
        PrefixLength: 0
        ValidLifetime: 0
        PreferedLifetime: 0
      GetNATRSIPStatus
        RSIPAvailable: false
        NATEnabled: true
      GetExternalIPAddress
        ExternalIPAddress: <IP_ADDRESS>
      X_AVM_DE_GetIPv6Prefix
        IPv6Prefix:
        PrefixLength: 0
        ValidLifetime: 0
        PreferedLifetime: 0
      X_AVM_DE_GetIPv6DNSServer
        IPv6DNSServer1:
        ValidLifetime1:<PHONE_NUMBER>
        IPv6DNSServer2:
        ValidLifetime2: 199800000
      GetConnectionTypeInfo
        ConnectionType: IP_Routed
        PossibleConnectionTypes: IP_Routed
      GetStatusInfo
        ConnectionStatus: Connected
        LastConnectionError: ERROR_NONE
        Uptime: 65386
    WANConnectionDevice - FRITZ!Box 7490: urn:schemas-upnp-org:service:WANIPv6FirewallControl:1
      GetFirewallStatus
        FirewallEnabled: true
        InboundPinholeAllowed: false