text:
---
id: intro
title: Overview
sidebar_label: Introduction
---

Many things in Hydra can be customized, this includes:
* Logging configuration
* Run and Multirun output directory patterns
* Application help (--help and --hydra-help)

Hydra can be customized using the same methods you are already familiar with from the tutorial.
You can include some Hydra config snippet in your own config to override it directly, or compose in different
configurations provided by plugins or by your own code. You can also override everything in Hydra from the command
line just like with your own configuration.

The Hydra configuration actually lives in the same config object as your configuration, but is removed prior to running
your function to reduce confusion.
You can view the configuration with `--cfg hydra|job|all`

The Hydra configuration itself is composed from multiple config files. here is a partial list:
```yaml
defaults:
  - hydra/job_logging : default     # Job's logging config
  - hydra/launcher: basic           # Launcher config
  - hydra/sweeper: basic            # Sweeper config
  - hydra/output: default           # Output directory
```
You can view the Hydra config structure [here](https://github.com/facebookresearch/hydra/tree/0.11_branch/hydra/conf).

This is a subset of the composed Hydra configuration node:

```yaml
hydra:
  run:
    # Output directory for normal runs
    dir: ./outputs/${now:%Y-%m-%d_%H-%M-%S}
  sweep:
    # Output directory for sweep runs
    dir: /checkpoint/${env:USER}/outputs/${now:%Y-%m-%d_%H-%M-%S}
    # Output sub directory for sweep runs.
    subdir: ${hydra.job.num}_${hydra.job.id}
```

## Runtime variables
The following variables are populated at runtime.
You can access them as config variables.

`hydra.job`:
- *hydra.job.name* : Job name, defaults to python file name without suffix. can be overridden.
- *hydra.job.override_dirname* : Pathname derived from the overrides for this job
- *hydra.job.num* : job serial number in sweep
- *hydra.job.id* : Job ID in the underlying jobs system (Slurm etc)

`hydra.runtime`:
- *hydra.runtime.version*: Hydra's version
- *hydra.runtime.cwd*: Original working directory the app was executed from

repository: facebookresearch/hydra

repo_name: facebookresearch/hydra


text:
Fortune server
===

A tiny "microservice" that serves content from the `fortune` program.

Written as a first [golang](https://golang.org/) project, as well as an experiment at learning [Amazon ECS](http://docs.aws.amazon.com/AmazonECS/latest/developerguide/Welcome.html).

[![Build Status](https://travis-ci.org/nmeyerhans/fortune-server.svg?branch=master)](https://travis-ci.org/nmeyerhans/fortune-server)

repository: airbr/fortune-server

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: airbr/fortune-server


text:
# What is this?
This is a Spaceflight Simulator BP editor in browser or (planned) for desktop
# Todo
 - [ ] fix the resources
 - [x] get BP generating working
 - [ ] package as desktop app
 - [ ] package for android?
# Credits
 - Code: Peter Stelmaszek (@pitust on github, u/pitust)
 - Resource hunting: (@FourCinnamon0 on github, u/FourCinnamon0)
# Contributing
You can send a PR.
# License
In this program I used resources from the game Spaceflight Simulator. These files are (c) Stefo Mai Morojna. The software code is (c) Piotr Stelamszek and distributed with MIT license.

license: MIT

repository: pitust/sfs-bp-space

repo_name: pitust/sfs-bp-space


text:
Docker Utility Containers

# Setup
1. Pre-Requsites
  - Windows
    - First Time Only - Do the `First Time Windows Setup` step below
    - Start PowerShell as a normal user
  - Linux
    - Assume git and curl are already installed and running cmds from Bash

1. Clone this `dockerfiles` repo
```
git clone https://github.com/andylytical/dockerfiles.git
cd dockerfiles
```
Note: All `docker-compose` commands should be run from within this directory.

# Python 3
```
docker-compose run --rm py3 bash
```

Run python code (from inside Python3 container)

:information_source: NOTE: Your Windows user directory (`C:\Users\<username>`) will be mounted at `/home` in the Docker container.
```
# Create venv (installing things as root always throws warnings)
python3 -m venv /root/venv

# Add venv to path
export PATH=/root/venv/bin:$PATH

# navigate to the directory containing your Python code
cd /home/path_to_my_project

# Install any python libraries you require
python3 -m pip install -r requirements.txt

# run your code
#replace "run.py" with the actual name of the python file you wish to run
python3 run.py
```

# CentOS7 (DEPRECATED)
```
docker-compose run --rm c7 bash
```

# First Time Windows Setup
- Start PowerShell as Administrator
- Install chocolatey
```PowerShell
Set-ExecutionPolicy Bypass -Scope Process -Force; iex ((New-Object System.Net.WebClient).DownloadString('https://chocolatey.org/install.ps1'))
```
- Install git (using chocolatey)
```PowerShell
cinst git -y
```

- Install Docker
  - https://docs.docker.com/docker-for-windows/install/
  - When prompted, enable Hyper-V
  - Docker Settings
    - Shared Drives
      - Add checkbox for drives to export
    - Advanced
      - (OPTIONAL) Adjust Images and volumes VHD location

## Develop Code
Write code in Windows using whatever process, editor, IDE you prefer.

repository: andylytical/dockerfiles

branch_name: refs/heads/main

repo_name: andylytical/dockerfiles


text:
# DeniBudget

A simple personal financial app developed mostly in React. You can see it [hosted on EvenNode](http://denibudget.us-1.evennode.com) and in a [video demo](https://www.youtube.com/watch?v=lNcZQd2ef2k)

This app was implemented just to show as a portfolio. It wasn't a complex web application, but it can give us an idea of how I have worked, knowledges, best practices, patterns and so on.

TODO: In the future I will implement the tests, CI and the User Experiences as well, including a resposive layout.

![alt text](http://denibudget.us-1.evennode.com/budget.png)

## Table of Contents
1. [Features](#features)
1. [Requirements](#requirements)
1. [Getting Started](#getting-started)
1. [Application Structure](#application-structure)
1. [Development](#development)
  1. [Developer Tools](#developer-tools)
  1. [Routing](#routing)
1. [Deployment](#deployment)
1. [Build System](#build-system)
  1. [Configuration](#configuration)
  1. [Globals](#globals)
  1. [Server](#server)
  1. [Production Optimization](#production-optimization)
1. [Author](#author)

## Features
* [react](https://github.com/facebook/react)
* [redux](https://github.com/rackt/redux)
* [react-router](https://github.com/rackt/react-router)
* [webpack](https://github.com/webpack/webpack)
* [babel](https://github.com/babel/babel)
* [express](https://github.com/expressjs/express)
* [eslint](http://eslint.org)

## Requirements
* node `^4.5.0`
* npm `^3.0.0`

## Getting Started

### Cloning

```bash
$ git clone https://github.com/denimar/denibudget.git
$ cd denibudget
```

```bash
$ npm install    # Install project dependencies
```
While developing, you will probably rely mostly on `npm start`; however, there are additional scripts at your disposal:

|`npm run <script>`|Description|
|------------------|-----------|
|`start`|Serves your app at `localhost:3000`. HMR will be enabled in development.|
|`compile`|Compiles the application to disk (`~/dist` by default).|
|`dev`|Same as `npm start`, but enables nodemon for the server as well.|
|`deploy`|Runs linter, tests, and then, on success, compiles your application to disk.|
|`deploy:dev`|Same as `deploy` but overrides `NODE_ENV` to "development".|
|`deploy:prod`|Same as `deploy` but overrides `NODE_ENV` to "production".|
|`lint`|Lint all `.js` files.|
|`lint:fix`|Lint and fix all `.js` files. [Read more on this](http://eslint.org/docs/user-guide/command-line-interface.html#fix).

## Application Structure

The application structure presented in this app is **fractal**, where functionality is grouped primarily by feature rather than file type.

```
.
├── bin                      # Build/Start scripts
├── config                   # Project and build configurations
├── public                   # Static public assets (not imported anywhere in source code)
├── server                   # Express application that provides webpack middleware
│   └── main.js              # Server application entry point
├── src                      # Application source code
│   ├── index.html           # Main HTML page container for app
│   ├── main.js              # Application bootstrap and rendering
│   ├── components           # Global Reusable Presentational Components
│   ├── containers           # Global Reusable Container Components
│   ├── layouts              # Components that dictate major page structure
│   │   └── CoreLayout.js    # CoreLayout which receives children for each route
│   │   └── CoreLayout.scss  # Styles related to the CoreLayout
│   │   └── index.js         # Main file for layout
│   ├── routes               # Main route definitions and async split points
TODO: ...inform the route here
│   ├── store                # Redux-specific pieces
│   │   ├── createStore.js   # Create and instrument redux store
│   │   └── location.js      # ..
│   │   └── reducers.js      # Reducer registry and injection
│   └── styles               # Application-wide styles (generally settings)
```

## Development

### Routing
I used `react-router` [route definitions](https://github.com/reactjs/react-router/blob/master/docs/API.md#plainroute) (`<route>/index.js`) to define units of logic within our application. See the [application structure](#application-structure) section for more information.

## Deployment

The deployment happens by run the command `npm run deploy` which will throw the files in `~/dist` folder

## Build System

### Configuration

Default project configuration can be found in `~/config/project.config.js`. Here you'll be able to redefine your `src` and `dist` directories, adjust compilation settings, tweak your vendor dependencies, and more. For the most part, you should be able to make changes in here **without ever having to touch the actual webpack build configuration**.

If you need environment-specific overrides (useful for dynamically setting API endpoints, for example), you can edit `~/config/environments.config.js` and `~/config/project.config.js` and define overrides.

|Key|Description|
|---|-----------|
|`dir_src`|application source code base path|
|`dir_dist`|path to build compiled application to|
|`server_host`|hostname for the Express server|
|`server_port`|port for the Express server|
|`compiler_devtool`|what type of source-maps to generate (set to `false`/`null` to disable)|
|`compiler_vendor`|packages to separate into to the vendor bundle|

### Globals

These are global variables available to you anywhere in your source code. If you wish to modify them, they can be found as the `globals` key in `~/config/project.config.js`. When adding new globals, make sure you also add them to `~/.eslintrc`.

|Variable|Description|
|---|---|
|`process.env.NODE_ENV`|the active `NODE_ENV` when the build started|
|`__DEV__`|True when `process.env.NODE_ENV` is `development`|
|`__PROD__`|True when `process.env.NODE_ENV` is `production`|

### Server

This starter kit comes packaged with an Express server. It's important to note that the purpose of this server is to provide `webpack-dev-middleware` and `webpack-hot-middleware` for hot module replacement and serve the node application as a server side together with the mongodb stuffs. Using a custom Express app in place of [webpack-dev-server](https://github.com/webpack/webpack-dev-server).

### Production Optimization

Babel is configured to use [babel-plugin-transform-runtime](https://www.npmjs.com/package/babel-plugin-transform-runtime) so transforms aren't inlined. In production, webpack will extract styles to a `.css` file, minify your JavaScript, and perform additional optimizations.

## Author

[Denimar de Moraes](http://github.com/denimar<EMAIL_ADDRESS>is a full-stack developper at the HBSis IT Solutions, Blumenau, Santa Catarina, Brazil.

repository: easella/denibudget

repo_name: easella/denibudget


text:
django-steam-tc-api
===================

A steam trading card api

This project is currently separated into two parts
the Django database and api backend and a web based
front end.

The website is published at http://www.steamcardsheet.com/

The Django project has the following dependencies:
* Django Rest Framework
* django-cors-headers by Otto Yiu
* Requests - for http calls

The website front end has the following dependencies:
* Bootstrap
* Jquery
* JS-Spinner
* datatables
* JS-NaturalSort
* money.js

On 27 Sep 2015: The Steam Card Sheet Shut Down:

It’s been two years since I created the SteamCardSheet and the Steam trading cards have proliferated prodigiously since then. With this ever expanding card collection came numerous bugs, inconsistences, and performance concerns which have diminished the card sheet’s usability; moreover, tools such as SteamCardExchange and the Enhanced Steam browser plugin have largely supplanted the need for a spreadsheet such as mine as they are faster and more powerful. With that being said, I have decided to deprecate and discontinue the SteamCardSheet, domain, and this group page. The site is closed as of 27 September 2015.

repository: chpwner/django-steam-tc-api

gha_language: Python

repo_name: chpwner/django-steam-tc-api


text:
# gbv
Original Gameboy video render library

## Changelog
### 1.2.0
* LCD interrupt support (HBLANK, VBLANK, OAM, TRANSFER)
* access to LY, LYC and STAT registers
* sprites not available yet (planned for future release)
### 1.2.1
* Fix LYC interrupt bug
### 1.3.0
* Re-implemented sprites
### 1.3.1
* Implemented H/V flip attribute for sprites

## What is it?
GBV emulates the original GB video hardware to draw tiles to the screen. It tries to act as close to what the real hardware would display as possible.

### Supported Features:
* memory mapped registers LCDC (lcd control), SCX and SCY (scroll x and y)
* background map rendering (map1 & map2)

### Supported LCDC flags
* GBV_LCDC_BG_ENABLE
* GBV_LCDC_BG_MAP_SELECT
* GBV_LCDC_BG_DATA_SELECT

### Upcoming Features
* window support (WND)
* sprite support (OAM) (8x8 and 16x8)
* additional LCDC flag support
* more render modes (F32, RGBA)

## API design
The API was designed in a lightweight way, it will not allocate any memory. The library is initialized by calling gbv_init and providing 64k of backing memory.

When you're finished setting up all your data, call gbv_render with a 8bpp framebuffer of size **GBV_SCREEN_SIZE**. The image will be rendered row by row, starting at the top left.
You also have to provide a grayscale palette, to map the pixel values 00, 01, 10 and 11 to their respective output color values.

A linearly spaced (non-gamma corrected) palette is
```cpp
gbv_palette palette = { 0xFF, 0xAA, 0x55, 0x00 };
```
where 00 (color index 0) is mapped to white, 11 (color index 3) to black.

### Compiling and linking
Just include gbv.h and gbv.cpp files into your project, or compile to a library and link against it.

## Usage
A usage example can be found in test_sdl.cpp, using [libSDL2](https://www.libsdl.org/) to draw to the screen.

![test1](https://github.com/Bl00drav3n/gbv/raw/master/test1.png "Test 1")


text:
# Policies

Terrascan policies are written using the [Rego policy language](https://www.openpolicyagent.org/docs/latest/policy-language/). With each rego policy a JSON "rule" file is included which defines metadata for the policy. Policies included within Terrascan are stored in the [pkg/policies/opa/rego](https://github.com/accurics/terrascan/tree/master/pkg/policies/opa/rego) directory.

## Rule JSON file

The rule files follow this naming convention: `<cloud-provider>.<resource-type>.<rule-category>.<severity>.<next-available-rule-number>.json`

Here's an example of the contents of a rule file:

``` json
{
    "name": "unrestrictedIngressAccess",
    "file": "unrestrictedIngressAccess.rego",
    "template_args": {
        "prefix": ""
    },
    "severity": "HIGH",
    "description": " It is recommended that no security group allows unrestricted ingress access",
    "reference_id": "AWS.SecurityGroup.NetworkSecurity.High.0094",
    "category": "Network Ports Security",
    "version": 2
}
```

| Key                  | Value                                         |
| -------------------- | --------------------------------------------- |
| name                 | Short name for the rule                       |
| file                 | File name of the Rego policy                  |
| template_args.prefix | Used for making rego policies unique          |
| severity             | Likelihood * impact of issue                  |
| description          | Description of the issue found with this rule |
| ruleReferenceId      | Unique ID of the rule in the format `<cloud-provider>.<resource-type>.<rule-category>.<severity>.<next-available-rule-number>` |
| category            | Descriptive category for this rule    |
| version             | Version number for the rule/rego      |

--8<-- "docs/policies/aws.md"

--8<-- "docs/policies/azure.md"

--8<-- "docs/policies/gcp.md"


text:
# Maven / Spring Web Application Demo

This project is the *template* for a demonstration that shows how to:

1. Create a Servlet (webapp) project with Maven's archetype:generate
2. Import that project into Eclipse (w/ m2e)
3. Add dependencies, including spring-webmvc
4. Plumb the web.xml to Spring's DispacherServlet named 'example'
5. Create a set of Spring bean definitions for example-servlet
6. Add a Spring MVC @Controller that returns a simple view (Hello View)

The above can all be accomplished by hand, this maven project is simply
the result of the exercise and can be used as a basis to cut/paste sections
of code that would be otherwise timely to re-type by hand.

repository: egustafson/sandbox

gha_language: Java

repo_name: egustafson/sandbox


text:
# ![nf-core/modules](docs/images/nfcore-modules_logo.png)

[![Nextflow](https://img.shields.io/badge/nextflow%20DSL2-%E2%89%A520.11.0--edge-23aa62.svg?labelColor=000000)](https://www.nextflow.io/)
[![run with conda](http://img.shields.io/badge/run%20with-conda-3EB049?labelColor=000000&logo=anaconda)](https://docs.conda.io/en/latest/)
[![run with docker](https://img.shields.io/badge/run%20with-docker-0db7ed?labelColor=000000&logo=docker)](https://www.docker.com/)
[![run with singularity](https://img.shields.io/badge/run%20with-singularity-1d355c.svg?labelColor=000000)](https://sylabs.io/docs/)

![GitHub Actions Coda Linting](https://github.com/nf-core/modules/workflows/Code%20Linting/badge.svg)
[![Get help on Slack](http://img.shields.io/badge/slack-nf--core%20%23modules-4A154B?labelColor=000000&logo=slack)](https://nfcore.slack.com/channels/modules)

[![Follow on Twitter](http://img.shields.io/badge/twitter-%40nf__core-1DA1F2?labelColor=000000&logo=twitter)](https://twitter.com/nf_core)
[![Watch on YouTube](http://img.shields.io/badge/youtube-nf--core-FF0000?labelColor=000000&logo=youtube)](https://www.youtube.com/c/nf-core)

> THIS REPOSITORY IS UNDER ACTIVE DEVELOPMENT. SYNTAX, ORGANISATION AND LAYOUT MAY CHANGE WITHOUT NOTICE!

A repository for hosting [Nextflow DSL2](https://www.nextflow.io/docs/latest/dsl2.html) module files containing tool-specific process definitions and their associated documentation.

## Table of contents

- [Using existing modules](#using-existing-modules)
- [Adding a new module file](#adding-a-new-module-file)
    - [Module template](#module-template)
    - [Guidelines](#guidelines)
    - [Testing](#testing)
    - [Documentation](#documentation)
    - [Uploading to `nf-core/modules`](#uploading-to-nf-coremodules)
- [Terminology](#terminology)
- [Help](#help)
- [Citation](#citation)

## Using existing modules

The module files hosted in this repository define a set of processes for software tools such as `fastqc`, `bwa`, `samtools` etc. This allows you to share and add common functionality across multiple pipelines in a modular fashion.

We have written a helper command in the `nf-core/tools` package that uses the GitHub API to obtain the relevant information for the module files present in the [`software/`](software/) directory of this repository. This includes using `git` commit hashes to track changes for reproducibility purposes, and to download and install all of the relevant module files.

1. [Install](https://github.com/nf-core/tools#installation) the latest version of `nf-core/tools` (`>=1.10.2`)
2. List the available modules:

    ```console
    $ nf-core modules list

                                              ,--./,-.
              ___     __   __   __   ___     /,-._.--~\
        |\ | |__  __ /  ` /  \ |__) |__         }  {
        | \| |       \__, \__/ |  \ |___     \`-._,-`-,
                                              `._,._,'

        nf-core/tools version 1.10.2

    INFO      Modules available from nf-core/modules (master):                                                                                modules.py:51

    bwa/index
    bwa/mem
    deeptools/computematrix
    deeptools/plotfingerprint
    deeptools/plotheatmap
    deeptools/plotprofile
    fastqc
    ..truncated..
    ```

3. Install the module in your pipeline directory:

    ```console
    $ nf-core modules install . fastqc

                                              ,--./,-.
              ___     __   __   __   ___     /,-._.--~\
        |\ | |__  __ /  ` /  \ |__) |__         }  {
        | \| |       \__, \__/ |  \ |___     \`-._,-`-,
                                              `._,._,'

        nf-core/tools version 1.10.2

    INFO      Installing fastqc                                                                                modules.py:62
    INFO      Downloaded 3 files to ./modules/nf-core/software/fastqc                                                                                modules.py:97
    ```

4. Import the module in your Nextflow script:

    ```nextflow
    #!/usr/bin/env nextflow

    nextflow.enable.dsl = 2

    include { FASTQC } from './modules/nf-core/software/fastqc/main' addParams( options: [:] )
    ```

5. We have plans to add other utility commands to help developers install and maintain modules downloaded from this repository so watch this space!

    ```console
    $ nf-core modules --help

    ...truncated...

    Commands:
      list     List available software modules.
      install  Add a DSL2 software wrapper module to a pipeline.
      update   Update one or all software wrapper modules.             (NOT YET IMPLEMENTED)
      remove   Remove a software wrapper from a pipeline.              (NOT YET IMPLEMENTED)
      check    Check that imported module code has not been modified.  (NOT YET IMPLEMENTED)
    ```

## Adding a new module file

> **NB:** The definition and standards for module files are still under discussion
but we are now gladly accepting submissions :)

If you decide to upload a module to `nf-core/modules` then this will
ensure that it will become available to all nf-core pipelines,
and to everyone within the Nextflow community! See
[`software/`](software)
for examples.

### Module template

We have added a directory called [`software/SOFTWARE/TOOL/`](software/SOFTWARE/TOOL/) that serves as a template with which to create your own module submission. Where applicable, we have added extensive `TODO` statements to the files in this directory for general information, to help guide you as to where to make the appropriate changes, and how to make them. If in doubt, have a look at how we have done things for other modules.

```console
.
├── software
│   ├── SOFTWARE
│   │   └── TOOL
│   │       ├── functions.nf          ## Utility functions imported in main module script
│   │       ├── main.nf               ## Main module script
│   │       ├── meta.yml              ## Documentation for module, input, output, params, author
│   │       └── test
│   │           ├── input             ## Soft-link input test data from "tests/"
│   │           ├── main.nf           ## Minimal workflow to test module
│   │           ├── nextflow.config   ## Minimal config to test module
│   │           └── output            ## Upload output files from test for unit testing
```

### Guidelines

The key words "MUST", "MUST NOT", "SHOULD", etc. are to be interpreted as described in [RFC 2119](https://tools.ietf.org/html/rfc2119).

#### General

- Software that can be piped together SHOULD be added to separate module files
unless there is a run-time, storage advantage in implementing in this way. For example,
using a combination of `bwa` and `samtools` to output a BAM file instead of a SAM file:

    ```bash
    bwa mem | samtools view -B -T ref.fasta
    ```

- Where applicable, the usage and generation of compressed files SHOULD be enforced as input and output, respectively:
    - `*.fastq.gz` and NOT `*.fastq`
    - `*.bam` and NOT `*.sam`

- Where applicable, each module command MUST emit a file `<SOFTWARE>.version.txt` containing a single line with the software's version in the format `<VERSION_NUMBER>` or `0.7.17` e.g.

    ```bash
    echo \$(bwa 2>&1) | sed 's/^.*Version: //; s/Contact:.*\$//' > ${software}.version.txt
    ```

    If the software is unable to output a version number on the command-line then a variable called `VERSION` can be manually specified to create this file e.g. [homer/annotatepeaks module](https://github.com/nf-core/modules/blob/master/software/homer/annotatepeaks/main.nf).

- The process definition MUST NOT contain a `when` statement.

#### Naming conventions

- The directory structure for the module name must be all lowercase e.g. [`software/bwa/mem/`](software/bwa/mem/). The name of the software (i.e. `bwa`) and tool (i.e. `mem`) MUST be all one word.

- The process name in the module file MUST be all uppercase e.g. `process BWA_MEM {`. The name of the software (i.e. `BWA`) and tool (i.e. `MEM`) MUST be all one word separated by an underscore.

- All parameter names MUST follow the `snake_case` convention.

- All function names MUST follow the `camelCase` convention.

#### Module parameters

- A module file SHOULD only define input and output files as command-line parameters to be executed within the process.

- All other parameters MUST be provided as a string i.e. `options.args` where `options` is a Groovy Map that MUST be provided via the Nextflow `addParams` option when including the module via `include` in the parent workflow.

- If the tool supports multi-threading then you MUST provide the appropriate parameter using the Nextflow `task` variable e.g. `--threads $task.cpus`.

- Any parameters that need to be evaluated in the context of a particular sample e.g. single-end/paired-end data MUST also be defined within the process.

#### Input/output options

- Named file extensions MUST be emitted for ALL output channels e.g. `path "*.txt", emit: txt`.

- Optional inputs are not currently supported by Nextflow. However, "fake files" MAY be used to work around this issue.

#### Resource requirements

- An appropriate resource `label` MUST be provided for the module as listed in the [nf-core pipeline template](https://github.com/nf-core/tools/blob/master/nf_core/pipeline-template/%7B%7Bcookiecutter.name_noslash%7D%7D/conf/base.config#L29) e.g. `process_low`, `process_medium` or `process_high`.

- If the tool supports multi-threading then you MUST provide the appropriate parameter using the Nextflow `task` variable e.g. `--threads $task.cpus`.

#### Software requirements

[BioContainers](https://biocontainers.pro/#/) is a registry of Docker and Singularity containers automatically created from all of the software packages on [Bioconda](https://bioconda.github.io/). Where possible we will use BioContainers to fetch pre-built software containers and Bioconda to install software using Conda.

- Software requirements SHOULD be declared within the module file using the Nextflow `container` directive e.g. go to the [BWA BioContainers webpage](https://biocontainers.pro/#/tools/bwa), click on the `Pacakages and Containers` tab, sort by `Version` and get the portion of the link after the `docker pull` command where `Type` is Docker. You may need to double-check that you are using the latest version of the software because you may find that containers for older versions have been rebuilt more recently.

- If the software is available on Conda it MUST also be defined using the Nextflow `conda` directive. Software MUST be pinned to the channel (i.e. `bioconda`) and version (i.e. `0.7.17`) e.g. `bioconda::bwa=0.7.17`. Pinning the build too is not currently a requirement e.g. `bioconda::bwa=0.7.17=h9402c20_2`.

- If required, multi-tool containers may also be available on BioContainers e.g. [`bwa` and `samtools`](https://biocontainers.pro/#/tools/mulled-v2-fe8faa35dbf6dc65a0f7f5d4ea12e31a79f73e40). It is also possible for a multi-tool container to be built and added to BioContainers by submitting a pull request on their [`multi-package-containers`](https://github.com/BioContainers/multi-package-containers) repository.

- If the software is not available on Bioconda a `Dockerfile` MUST be provided within the module directory. We will use GitHub Actions to auto-build the containers on the [GitHub Packages registry](https://github.com/features/packages).

#### Publishing results

The [Nextflow `publishDir`](https://www.nextflow.io/docs/latest/process.html#publishdir) definition is currently quite limited in terms of parameter/option evaluation. To overcome this, the publishing logic we have implemented for use with DSL2 modules attempts to minimise changing the `publishDir` directive (default: `params.outdir`) in favour of constructing and appending the appropriate output directory paths via the `saveAs:` statement e.g.

```nextflow
    publishDir "${params.outdir}",
        mode: params.publish_dir_mode,
        saveAs: { filename -> saveFiles(filename:filename, options:params.options, publish_dir:getSoftwareName(task.process), publish_id:meta.id) }
```

The `saveFiles` function can be found in the [`functions.nf`](software/fastqc/functions.nf) file of utility functions that will be copied into all module directories. It uses the various publishing `options` specified as input to the module to construct and append the relevant output path to `params.outdir`.

We also use a standardised parameter called `params.publish_dir_mode` that can be used to alter the file publishing method (default: `copy`).

### Testing

- All test data for `nf-core/modules` MUST be added to [`tests/data/`](tests/data/) and organised by filename extension.

- Test files MUST be kept as tiny as possible.

- Every module MUST be tested by adding a test workflow with a toy dataset in the [`test/`](software/fastqc/test) directory of the module.

- Generic files from [`tests/data/`](tests/data/) MUST be reused by symlinking them into the [`test/input/`](software/fastqc/test/input/) directory of the module.

- Any outputs produced by the test workflow MUST be placed in a folder called [`test/output/`](software/fastqc/test/output/) so that they can be used for unit testing.

- If the appropriate test data doesn't exist for your module then it MUST be added to [`tests/data/`](tests/data/).

- A GitHub Actions workflow file MUST be added to [`.github/workflows/`](.github/workflows/) e.g. [`.github/workflows/fastqc.yml`](.github/workflows/fastqc.yml).

### Documentation

- A module MUST be documented in the [`meta.yml`](software/fastqc/meta.yml) file. It MUST document `params`, `input` and `output`. `input` and `output` MUST be a nested list.

### Uploading to `nf-core/modules`

[Fork](https://help.github.com/articles/fork-a-repo/) the `nf-core/modules` repository to your own GitHub account. Within the local clone of your fork add the module file to the [`software/`](software) directory.

Commit and push these changes to your local clone on GitHub, and then [create a pull request](https://help.github.com/articles/creating-a-pull-request-from-a-fork/) on the `nf-core/modules` GitHub repo with the appropriate information.

We will be notified automatically when you have created your pull request, and providing that everything adheres to nf-core guidelines we will endeavour to approve your pull request as soon as possible.

## Terminology

The features offered by Nextflow DSL2 can be used in various ways depending on the granularity with which you would like to write pipelines. Please see the listing below for the hierarchy and associated terminology we have decided to use when referring to DSL2 components:

- *Module*: A `process` that can be used within different pipelines and is as atomic as possible i.e. cannot be split into another module. An example of this would be a module file containing the process definition for a single tool such as `FastQC`. At present, this repository has been created to only host atomic module files that should be added to the [`software/`](software/) directory along with the required documentation and tests.

- *Sub-workflow*: A chain of multiple modules that offer a higher-level of functionality within the context of a pipeline. For example, a sub-workflow to run multiple QC tools with FastQ files as input. Sub-workflows should be shipped with the pipeline implementation and if required they should be shared amongst different pipelines directly from there. As it stands, this repository will not host sub-workflows although this may change in the future since well-written sub-workflows will be the most powerful aspect of DSL2.

- *Workflow*: What DSL1 users would consider an end-to-end pipeline. For example, from one or more inputs to a series of outputs. This can either be implemented using a large monolithic script as with DSL1, or by using a combination of DSL2 individual modules and sub-workflows.

## Help

For further information or help, don't hesitate to get in touch on [Slack `#modules` channel](https://nfcore.slack.com/channels/modules) (you can join with [this invite](https://nf-co.re/join/slack)).

## Citation

If you use the module files in this repository for your analysis please you can cite the `nf-core` publication as follows:

> **The nf-core framework for community-curated bioinformatics pipelines.**
>
> Philip Ewels, Alexander Peltzer, Sven Fillinger, Harshil Patel, Johannes Alneberg, Andreas Wilm, Maxime Ulysse Garcia, Paolo Di Tommaso & Sven Nahnsen.
>
> _Nat Biotechnol._ 2020 Feb 13. doi: [10.1038/s41587-020-0439-x](https://dx.doi.org/10.1038/s41587-020-0439-x).
> ReadCube: [Full Access Link](https://rdcu.be/b1GjZ)

<!---

- The module MUST accept a parameter `params.publish_results` accepting at least
    - `"none"`, to publish no files at all,
    - a glob pattern which is initalized to a sensible default value.

### Configuration and parameters

The module files hosted in this repository define a set of processes for software tools such as `fastqc`, `trimgalore`, `bwa` etc. This allows you to share and add common functionality across multiple pipelines in a modular fashion.

> The definition and standards for module files are still under discussion amongst the community but hopefully, a description should be added here soon!

### Offline usage

If you want to use an existing module file available in `nf-core/modules`, and you're running on a system that has no internet connection, you'll need to download the repository (e.g. `git clone https://github.com/nf-core/modules.git`) and place it in a location that is visible to the file system on which you are running the pipeline. Then run the pipeline by creating a custom config file called e.g. `custom_module.conf` containing the following information:

```bash
include /path/to/downloaded/modules/directory/
```

Then you can run the pipeline by directly passing the additional config file with the `-c` parameter:

```bash
nextflow run /path/to/pipeline/ -c /path/to/custom_module.conf
```

> Note that the nf-core/tools helper package has a `download` command to download all required pipeline
> files + singularity containers + institutional configs + modules in one go for you, to make this process easier.

-->

repository: anwarMZ/modules

repo_name: anwarMZ/modules


text:
# Home Assistant Add-on: Frigate NVR (For old x86_64 CPUs)

Please reference the [release notes](https://github.com/blakeblackshear/frigate/releases) for breaking changes.

![Supports amd64 Architecture][amd64-shield]

NVR with realtime local object detection for IP cameras.

You must create a config file as `frigate.yml` in the root of your Home Assistant configuration directory.

[Documentation](https://docs.frigate.video)

[Frigate]: https://github.com/blakeblackshear/frigate
[amd64-shield]: https://img.shields.io/badge/amd64-yes-green.svg

repository: lustefaniak/frigate-hass-addons

gha_license_id: MIT

repo_name: lustefaniak/frigate-hass-addons


text:
[header-image]: https://raw.githubusercontent.com/mgthomas99/easy-vg/develop/.github/assets/raspi-spiral.png
[git-repository-url]: https://github.com/mgthomas99/openvg
[license-shield-url]: https://img.shields.io/github/license/mgthomas99/easy-vg.svg?style=flat-square
[license-url]: https://github.com/mgthomas99/openvg/blob/master/LICENSE

# EasyVG

[![One][header-image]][git-repository-url]
[![LICENSE][license-shield-url]][license-url]

EasyVG provides an abstraction layer above native OpenVG, for quickly and easily
creating OpenVG contexts and drawing shapes, images, and text.

EasyVG follows standard C and EGL API naming conventions.

EasyVG is fully compatible with the Raspberry Pi.

*This project is a fork of [OpenVG by Anthony Starks <ajstarks>](https://github.com/ajstarks/openvg)*

### Text & Fonts

EasyVG is capable of rendering text.

To use custom TrueType fonts, developers should convert the font into C code use
the [font2openvg](https://github.com/mgthomas99/font2openvg) library, and then
load it the font using `loadfont()`.

*There are plans to support loading a font directly from a `.ttf` file*.

#### Using font2openvg

The `font2openvg` repository contains build instructions for building the
`font2openvg` source. Once the library is built, compile a TrueType font file.
For the below demonstrations, it will be assumed that you are using a source
font file named `DejaVuSans.ttf` and a compiled output named `DejaVuSans.inc`.

Once a font is compiled, it can be included in your code like so:

```c
    #include "DejaVuSans.inc"
    Fontinfo DejaFont

    loadfont(DejaVuSans_glyphPoints,
            DejaVuSans_glyphPointIndices,
            DejaVuSans_glyphInstructions,
            DejaVuSans_glyphInstructionIndices,
            DejaVuSans_glyphInstructionCounts,
            DejaVuSans_glyphAdvances,
            DejaVuSans_characterMap,
            DejaVuSans_glyphCount);

    // Unload the font when done
    unloadfont(DejaFont.Glyphs, DejaFont.Count);
```

## Build and Run Examples

*Note that you will need at least 64 MB of GPU RAM*. You will also need the
DejaVu fonts, and the jpeg and freetype libraries.

```shell
pi@raspberrypi ~ $ sudo apt-get install libfreetype6-dev libjpeg8-dev ttf-dejavu-core
```

Next, build the library:

```shell
pi@raspberrypi ~ $ git clone https://github.com/mgthomas99/easy-vg
pi@raspberrypi ~ $ cd easy-vg
pi@raspberrypi ~/easy-vg $ make
 g++ -I/usr/include/freetype2 fontutil/font2openvg.cpp -o font2openvg -lfreetype
 ./font2openvg /usr/share/fonts/truetype/ttf-dejavu/DejaVuSans.ttf DejaVuSans.inc DejaVuSans
 224 glyphs written
 gcc -O2 -Wall -I/opt/vc/include -I/opt/vc/include/interface/vmcs_host/linux -I/opt/vc/include/interface/vcos/pthreads -c libshapes.c
 gcc -O2 -Wall -I/opt/vc/include -I/opt/vc/include/interface/vmcs_host/linux -I/opt/vc/include/interface/vcos/pthreads -c oglinit.c
```

Next, build the examples:

```shell
pi@raspberrypi ~/easy-vg/client $ cd example
pi@raspberrypi ~/easy-vg/client $ make hello
 cc -Wall -I/opt/vc/include -I/opt/vc/include/interface/vcms_host/linux -I/opt/vc/include/interface/vcos/pthreads -I.. hello.c -o hello ../build/libshapes.o ../build/oglinit.o -L/opt/vc/lib -lEGL -lGLESv2 -lbcm_host -ljpeg -lpthread
pi@raspberrypi ~/easy-vg/client $ ./hello
```

### Installing as a Global Library

To install the library as a system-wide shared library:

```shell
pi@raspberrypi ~/easy-vg $ make library
pi@raspberrypi ~/easy-vg $ sudo make install
```

The EasyVG shapes library can now be used in C code by including `shapes.h` and
`fontinfo.h`, and linking with `libshapes.so`:

```c
#include <shapes.h>
#include <fontinfo.h>
```

```shell
pi@raspberrypi ~ $ gcc -I/opt/vc/include -I/opt/vc/include/interface/vmcs_host/linux -I/opt/vc/include/interface/vcos/pthreads anysource.c -o anysource -lshapes
pi@raspberrypi ~ $ ./anysource
```

## License

See the `LICENSE` file for license information.

gha_language: C


text:
## Overview

A fast algorithm to hash string or binary file inspired by the JSW hash.
Not likes md5 or sha1, the hash sum it creates is only about 6 chars (if you use base 70).

I used it in one of my company's node project.
It helps me peacefully distribute different versions of files to the CDN service.

Useful when using it in the **URL** hash or **table lookup**.

[![Build Status](https://travis-ci.org/ysmood/jhash.svg)](https://travis-ci.org/ysmood/jhash) [![Build status](https://ci.appveyor.com/api/projects/status/tsh8f5680c5esiqr)](https://ci.appveyor.com/project/ysmood/jhash)

## Features

* Easy to control the length of the result hash value.

* Lite and fast.

## Other Language Implementations

I have implemented the core algorithm into 7 commonly used languages:

* c
* coffeescript
* go
* lua
* php
* python
* ruby

Only the coffeescript one has full API. If you only want the minimal function, go for the `src/jhash.core.js` file,
Or `require('jhash/lib/jhash.core.js')`

### Node

* Install

 ```shell
 npm install jhash
 ```

* Usage

```javascript
var jhash = require('jhash');
jhash.hash('test'); // output => '349o'

var fs = require('fs');
jhash.hash(fs.readFileSync('a.jpg'));

// Control the hash char set.
jhash.setSymbols('abcdef');
jhash.hash('test'); // output => 'decfddfe'

// Control the max length of the result hash value. Unit is bit.
jhash.setMaskLen(10);
jhash.hash('test'); // output => 'ede'

// New jhash instance.
myJhash = new jhash.constructor
```

### Browser

Install it via [Bower][2]: `bower install jhash`.

Or download the js file from the release page: [Release][1].

```html
<script src='jhash.js'></script>
<script>
  jhash.hash('test'); // output => '349o'
</script>
```

### CLI Tool

* Install

  To use it as a command line tool, install it globally.

      npm install -g jhash

* Usage

  Here are some examples.

  Print help information:

        jhash -h

  Hash string `abc`, it outputs `2csX`:

        jhash abc

  Hash a jpg image file (it will automatically detect whether the passed in argument is a file or not):

        jhash a.jpg

#### Collision test for 10 seconds random data

    npm run no -- collision

#### Compare to some other hash algorithms

This is just a random test, you may need to test some real data before using it in project.

```
****** jhash *******
     sample: ["jg0ayq","nz9fb0","oa9iz1","4w5egf","dt7dsv","9wkm25","duu2j2","solh6y","z6rnbl","aa8ebp","g568a2"]
       time: 6.836s
 collisions: 0.000999999999995449%

****** rotating_hash *******
     sample: ["ahuz3","2hxrf3","k68zy","3cdf61","2857v2","fgua","3216o4","2i69dz","1ehpfn","1y46pv","3m1r0h"]
       time: 7.154s
 collisions: 48.626000000000005%

****** bjb2_hash *******
     sample: ["sdflvy","-g2j5ix","-1dsjyy","sezbl2","-wye5kw","-bdfy0t","-mudsaj","-4f3shn","-z1mxsl","-165mmr","q5oh58"]
       time: 16.718s
 collisions: 0.002000000000002%

****** fnv_hash *******
     sample: ["4ct07k","-pdrz0h","me11fv","t9px7i","-y120s","251qw7","h83axv","tob69f","eonk6","-6dkeny","elxam6"]
       time: 16.787s
 collisions: 0.000999999999995449%

****** oat_hash *******
     sample: ["-fg1gqa","-2k0tg","a391j2","1jd98xw","2dw8oj","-uldzx3","-t9m4me","-5z57og","6m0uqx","-17q8t0j","u8m0lo"]
       time: 19.028s
 collisions: 0.000999999999995449%

****** jsw_hash *******
     sample: ["-hm4rfv","vehfuu","jwf2v0","5c2oq3","-9xs2xt","p1ho2c","-ri84uf","op47br","-13wvwp","ek12tv","hrc6ki"]
       time: 15.702s
 collisions: 0.002999999999997449%
```

## Benchmark

Run `npm run no -- benchmark`.

Intel Core i7 2.3GHz SSD

    87174 ops/s.
    Avr. file size 6716B.

## Road Map

* Add more test cases.

## The MIT License (MIT)

Apr 2014 jhash

  [1]: https://github.com/ysmood/jhash/releases
  [2]: https://github.com/bower/bower

repository: ysmood/jhash

gha_language: CoffeeScript

repo_name: ysmood/jhash


text:
# TextSaliency
The provided piece of code, extracts text saliency from a given image by using the method described in [1]. If you find the saliency based text detection method useful, please consider citing [1].

@InProceedings{Karaoglu et. al.,
author="Karaoglu, Sezer and van Gemert, Jan C. and Gevers, Theo",
title="Object Reading: Text Recognition for Object Recognition",
booktitle="Computer Vision -- ECCV 2012. Workshops and Demonstrations",
year="2012",
publisher="Springer Berlin Heidelberg",
address="Berlin, Heidelberg",
pages="456--465",
}

repository: KaraogluSezer/TextSaliency

repo_name: KaraogluSezer/TextSaliency


text:
# image-convert-loader

A webpack loader to preprocess images.

## Install

    yarn add -D image-convert-loader

## Usage

This loader is typically used with other loaders such as file-loader or img-loader.

Exemple conf:

    {
        test: /\.(png|jpg|webp)$/,
        use: [
            'file-loader',
            'img-loader',
            'image-convert-loader'
        ]
    }

You can then pass query arguments when loading images:

    const url = require('./foo.png?w=512&format=webp');

## Options

The following options are accepted as query arguments:

**w** | **h**: Sets the width and/or the height of the resulting image. If one is missing, the aspect ratio will be preserved.
**format**: Sets the format of the resulting image. valid values are `png`, `jpg` and `webp`.

## License

MIT.

repository: Nax/image-convert-loader

gha_language: JavaScript

repo_name: Nax/image-convert-loader


text:
# ops-tools
DevOps tools written in Python
1. [cloudwatch_metrics](cloudwatch_metrics/)
2. [kms_encrypt](kms_encrypt/)
3. [add-tags.py](#add-tagspy)
4. [clone.py](#clonepy)
5. [instances-backup.py](#instances-backuppy)
6. [start-stop.py](#start-stoppy)
7. [wait.py](#waitpy)
8. [watchdog.py](#watchdogpy)

## cloudwatch_metrics
Service daemon for Ubuntu servers to post custom AWS CloudWatch metrics.

## kms_encrypt
A set of tools to work with AWS KMS encryption.

## add-tags.py
Adds tags to AWS EC2 instances by name or instance id

## clone.py
Creates a clone of the running AWS EC2 or RDS instance by name or instance id

## instances-backup.py
Multi-threaded AWS EC2 instances backup into AMIs by tag, instance id or name

## start-stop.py
Starts or stops AWS EC2 instances by name or instance id

## wait.py

Wait for remote SSH service to come back after a boot or reboot

## watchdog.py
TCP-port watchdog. Monitors availability of the TCP port, runs external process if port is unavailable.
```bash
./watchdog.py -a <IP_ADDRESS> -p 80 -c "echo port unavailable" -r 1
```

[![APACHE 2.0](https://img.shields.io/badge/License-Apache%202.0-brightgreen.svg?longCache=true&style=for-the-badge)](LICENSE)


text:
# Fr24feed, FlightAware and RadarBox with dump1090 as a Docker image for Raspberry Pi (armhf)

armhf-RPi docker image of Fr24feed, FlightAware, RadarBox and dump1090.

Feed FlightRadar24, FlightAware and RadarBox services and allow you to see the positions of aircrafts on a map.

---

![Image of dump1090 webapp](https://raw.githubusercontent.com/thomasreiser/flightfeeder/master/screenshot.png)

# Requirements

- Raspberry Pi with Raspbian (tested with V4 Model B)
- Docker
- RTL-SDR DVBT USB Dongle (RTL2832)

# Getting started

Run :
```
docker run -d -p 8080:8080 -p 8754:8754 \
	--device=/dev/bus/usb:/dev/bus/usb \
	-e "FR24FEED_FR24KEY=MY_SHARING_KEY" \
	-e "PIAWARE_FEEDER_DASH_ID=MY_FEEDER_ID" \
	-e "RBFEEDER_KEY=MY_SHARING_KEY" \
	-e "HTML_SITE_LAT=MY_SITE_LAT" \
	-e "HTML_SITE_LON=MY_SITE_LON" \
	-e "HTML_SITE_NAME=MY_SITE_NAME" \
	-e "PANORAMA_ID=MY_PANORAMA_ID" \
	thomasreiser/flightfeeder
```

Go to http://dockerhost:8080 to view a map of reveived data.
Go to http://dockerhost:8754 to view fr24feed configuration panel.

*Note : remove `-e "PANORAMA_ID=MY_PANORAMA_ID"` from the command line if you don't want to use this feature.*

# Configuration

## Common

To disable starting a service you can add an environment variable :

| Environment Variable                  | Value                    | Description               |
|---------------------------------------|--------------------------|---------------------------|
| `SERVICE_ENABLE_DUMP1090`             | `false`                  | Disable dump1090 service  |
| `SERVICE_ENABLE_PIAWARE`              | `false`                  | Disable piaware service   |
| `SERVICE_ENABLE_FR24FEED`             | `false`                  | Disable fr24feed service  |
| `SERVICE_ENABLE_RBFEEDER`             | `false`                  | Disable rbfeeder service  |
| `SERVICE_ENABLE_HTTP`                 | `false`                  | Disable http service      |

Ex : `-e "SERVICE_ENABLE_HTTP=false"`

## FlightAware

Register on https://flightaware.com/account/join/.

Run :
```
docker run -it --rm \
	-e "SERVICE_ENABLE_DUMP1090=false" \
	-e "SERVICE_ENABLE_HTTP=false" \
	-e "SERVICE_ENABLE_FR24FEED=false" \
	-e "SERVICE_ENABLE_RBFEEDER=false" \
	thomasreiser/flightfeeder /bin/bash
```
When the container starts you should see the feeder id, note it. Wait 5 minutes and you should see a new receiver at https://fr.flightaware.com/adsb/piaware/claim (use the same IP as your docker host), claim it and exit the container.

Add the environment variable `PIAWARE_FEEDER_DASH_ID` with your feeder id.

| Environment Variable                  | Configuration property   | Default value     |
|---------------------------------------|--------------------------|-------------------|
| `PIAWARE_FEEDER_DASH_ID`              | `feeder-id`              | `YOUR_FEEDER_ID`  |

Ex : `-e "PIAWARE_RECEIVER_DASH_TYPE=other"`

## FlightRadar24

Run :
```
docker run -it --rm \
	-e "SERVICE_ENABLE_DUMP1090=false" \
	-e "SERVICE_ENABLE_HTTP=false" \
	-e "SERVICE_ENABLE_PIAWARE=false" \
	-e "SERVICE_ENABLE_FR24FEED=false" \
	-e "SERVICE_ENABLE_RBFEEDER=false" \
	thomasreiser/flightfeeder /bin/bash
```
Then : `/opt/fr24feed/bin/fr24feed --signup` and follow the instructions, for technical steps, your answer doesn't matter we just need the sharing key at the end.

Finally to see the sharing key run `cat /etc/fr24feed.ini`, you can now exit the container.

Add the environment variable `FR24FEED_FR24KEY` with your sharing key.

| Environment Variable                  | Configuration property   | Default value     |
|---------------------------------------|--------------------------|-------------------|
| `FR24FEED_FR24KEY`                    | `fr24key`                | `YOUR_KEY_HERE`   |

Ex : `-e "FR24FEED_FR24KEY=0123456789"`

## RadarBox

Run :
```
docker run -it --rm \
	-e "SERVICE_ENABLE_DUMP1090=false" \
	-e "SERVICE_ENABLE_HTTP=false" \
	-e "SERVICE_ENABLE_PIAWARE=false" \
	-e "SERVICE_ENABLE_FR24FEED=false" \
	-e "SERVICE_ENABLE_RBFEEDER=false" \
	thomasreiser/flightfeeder /bin/bash
```

Then : `/opt/rbfeeder/bin/rbfeeder` to do an initial startup which will also create a new key for you. Use this key then to claim this station in your RadarBox account at https://www.radarbox.com/raspberry-pi/claim.

Add the environment variable `RBFEEDER_KEY` with your sharing key.

| Environment Variable                  | Configuration property   | Default value     |
|---------------------------------------|--------------------------|-------------------|
| `RBFEEDER_KEY`                        | `[client]` -> `key`        | ``                |

Ex : `-e "RBFEEDER_KEY=0123456789"`

## Terrain-limit rings (optional):
If you don't need this feature ignore this.

Create a panorama for your receiver location on http://www.heywhatsthat.com.

| Environment Variable                  | Default value            | Description                                 |
|---------------------------------------|--------------------------|---------------------------------------------|
| `PANORAMA_ID`                         |                          | Panorama id                                 |
| `PANORAMA_ALTS`                       | `1000,10000`             | Comma seperated list of altitudes in meter  |

*Note : the panorama id value correspond to the URL at the top of the panorama http://www.heywhatsthat.com/?view=XXXX, altitudes are in meters, you can specify a list of altitudes.*

Ex : `-e "PANORAMA_ID=FRUXK2G7"`

If you don't want to download the limit every time you bring up the container you can download `http://www.heywhatsthat.com/api/upintheair.json?id=${PANORAMA_ID}&refraction=0.25&alts=${PANORAMA_ALTS}` as upintheair.json and mount it in `/usr/lib/fr24/public_html/upintheair.json`.

# Build it yourself

Clone this repository into your Raspberry Pi.

```docker build . ```


text:
# GRAPHQL-SCHEMA-FROM-SWAGGER

Dynamically create your apollo ready graphql schema from one or many swagger enabled apis

## Installation

```bash
npm install graphql-schema-from-swagger
```

## Usage

### Single Api Example

```javascript
import { generate } from 'graphql-schema-from-swagger';

const apolloSchema = generate(accountApiSwaggerJson, {
  // This is a callback function for all the get requests made to this api.
  apiResolver: async ({
      parent,
      parentType,
      parameters,
      rawUrl,
      fieldName,
      type,
    }) => {
      // Come up with a strategy to set the variables on the raw url for things like nested urls
      var endpoint = setRawUrl({
        rawUrl,
        fieldName,
        parameters,
        parentType,
        parent,
      });

      // fetch data using your favorite http client
      return await restClient.get(endpoint.url, parameters);
    },
  }
});

/*
  apolloSchema looks like:
  {
    typeDefs: ``, // Your graphql schema as a string,
    resolvers: {}, // The resolvers for your graphql types
  }
*/

```

### Multiple Api Example

```javascript
import { schemaFromMultiple } from 'graphql-schema-from-swagger';

const apolloSchema = schemaFromMultiple([
  {
    swaggerJson: accountApiSwaggerJson,
    options: {
      apiResolver: async ({
        parent,
        parentType,
        parameters,
        rawUrl,
        fieldName,
        type,
        context,
      }) => {
        // Come up with a strategy to set the variables on the raw url for things like nested urls
        var endpoint = setRawUrl({
          rawUrl,
          fieldName,
          parameters,
          parentType,
          parent,
        });

        // fetch data using your favorite http client
        return await restClient.get(endpoint.url, parameters);
      }
    }
  },
  {
    swaggerJson: blogApiSwaggerJson,
    options: {
      apiResolver: async ({
        parent,
        parentType,
        parameters,
        rawUrl,
        fieldName,
        type,
        context,
      }) => {
        // Come up with a strategy to set the variables on the raw url for things like nested urls
        var endpoint = setRawUrl({
          rawUrl,
          fieldName,
          parameters,
          parentType,
          parent,
        });

        // fetch data using your favorite http client
        return await restClient.get(endpoint.url, parameters);
      }
    }
  }
]);
```

### apiResolver

This is where all the resolvers for you get requests funnel through.

As part of the callback you are given relevant information to help set variables on the raw url:

```parent```

  A hydrated parent object think blog when dealing with posts

```parentType```

  "Blog" when dealing with posts

```parameters```

  An object from what's sent from the client i.e. { take: 2, blogId: 1 }

```rawUrl```

  The url as defined by your swagger endpoint (it's up to you to set the variables in the curly braces)

```fieldName```

  i.e. "posts" or "blog"

```type```

  i.e "Post", "Comment", "Account"

```context```
  The apollo context object

### Things to note

To get a raw GraphQl Schema Object (graphqljs) you can call use:

```javascript

import { generateTypes } from 'graphql-schema-from-swagger';

const schema = generateTypes(accountSwaggerJson, { apiResolver });

```

- Only supports "GET" requests at the moment

Check out the tests for tinkering with example swagger json files (npm run test:watch)

repository: sbrigham/graphql-schema-from-swagger

repo_name: sbrigham/graphql-schema-from-swagger


text:
# UCLL Intranet RSS Feed

A RSS feed for the messages on [intranet.ucll.be](https://intranet.ucll.be).

## RSS Generator

### Command-line

```python
python rss.py [...arguments]
```

### Arguments

##### -u, --username (required)

Your UCLL username (r-number).

##### -p, --password (required)

Your UCLL password.

##### -o, --output (required)

The absolute or relative path to the output file. If it doesn't exist it will be created. If it already exist it will be overwritten.

##### -f, --format (default=0)

The format of the output file. To support the RSS feed feature in Slack we provide a format that will append a space after the <p> and </br> element.

- 0 : No formatting.
- 1 : A space will be appended after the <p> and </br> element.

##### -i, --initialise (default=false)

When you set this value to `true` the database will be created. All the items until now will be fetched and inserted into the database.

**Note** : It is important that you set this value the first time and that you set it back to `false` or just remove from the line after the first time.

repository: DavidOpDeBeeck/UCLL-Intranet-RSS

repo_name: DavidOpDeBeeck/UCLL-Intranet-RSS


text:
# app-sample

## Build

Prerequisites:

* JDK 7 must be installed
* ant must be installed

		cd app-sample
		ant clean
		ant assemble

This builds the following WARs located jre-1.7/app-sample/deployment-unit/:

* opentdc-app-sample.war: sample app which demonstrates basic principals
  of how opentdc apps are built.

## Deploy

Copy the opentdc-app-sample.war manually to the webapps directory of Tomcat and launch
the app with the URL http://localhost:8080/opentdc-app-sample/.

## Architecture

The following figure gives an overview of the architecture of the sample app:

![](https://github.com/opentdc/app-sample/blob/master/architecture-1.png)

### Service

* The service implements the API of the app as REST/JSON service. It
  offers all methods required by the Javascript GUI (in this case ./index.html).
* The service is implemented as a Java servlet, namely as JSP (./Api.jsp). The
  JSP approach allows on-the-fly compiling and allows ultra-fast and flexible
  development roundtrips.

The service implementation Api.jsp has the following layout:

	Api.jsp:

	   <%@page contentType="text/html;charset=UTF-8" language="java" pageEncoding="UTF-8" %>
	   <%!

	      // ContactModel bean
	      public static class ContactModel {
	         ...
	      }

	      public static ContactModel getContact(request, path) {
	         // delegate to backend
	      }

	      public static ContactModel createContact(request, path) {
	         // delegate to backend
	      }

	      public static ContactModel updateContact(request, path) {
	         // delegate to backend
	      }

	      public static List<ContactModel> findContacts(request, path, query) {
	         // delegate to backend
	      }

	   %>
	   <%
	   	* dispatch request and invoke methods
	   	* return result as JSON response
	   %>

### GUI
The GUI is a standard webapp. It communicates with the service over REST/JSON.

Below is the screenshot of the sample app which allows to get, update and create
contacts using the APIs provider/{pid}/segment/{sid}/contact/{cid}
and provider/{pid}/segment/{sid}/contact.

![](https://github.com/opentdc/app-sample/blob/master/architecture-2.png)

### Backend

* The backend can be any database or application service (ERP, CRM, CM, DM, etc.).
  The service-tier delegates to the backend in order to store and retrieve data
  and execute business-logic.
* The project app-generic offers a very simple file-based StoreManager which allows to
  store objects as JSON-formatted files. This allows to quickly build prototypes
  and proof-of-concepts.

## WebApp Layout

The file layout of the webapp looks as follows:

		opentdc-app-sample
		   + WEB-INF
		     + web.xml
		   + index.html
		   + Api.jsp
		   + js
		   	+ bootstrap
		   	+ jquery

Of course, instead of bootstrap any other webapp framework can be used (Polymer, AngularJ, ...).

repository: opentdc/app-sample

repo_name: opentdc/app-sample


text:
<!-- README.md is generated from README.Rmd. Please edit that file -->

# rAfrica

<!-- badges: start -->

<!-- badges: end -->

The goal of rAfrica is to train participants on how to develop a simple
package.

## Installation

You can install the released version of rAfrica from
[CRAN](https://CRAN.R-project.org) with:

``` r
install.packages("rAfrica")
```

*Note: This package is not yet on CRAN*

And the development version from [GitHub](https://github.com/) with:

``` r
# install.packages("devtools")
devtools::install_github("Shelmith-Kariuki/rAfrica")
```

## Example

This is a basic example which shows you how to solve a common problem:

``` r
library(rAfrica)

## jumla function
summation <- jumla(10,20)
summation
#> [1] 30

## counter function
my_tab <- counter(infert, "case")
#> Warning: `group_by_()` is deprecated as of dplyr 0.7.0.
#> Please use `group_by()` instead.
#> See vignette('programming') for more help
#> This warning is displayed once every 8 hours.
#> Call `lifecycle::last_warnings()` to see where this warning was generated.
my_tab
#> # A tibble: 2 x 2
#> # Groups:   case [2]
#>    case     n
#>   <dbl> <int>
#> 1     0   165
#> 2     1    83
```

repository: Shelmith-Kariuki/rAfrica

repo_name: Shelmith-Kariuki/rAfrica


text:
# README.md Generator

  ## Discription

  This application is perfect for a developer on the go, who needs to quickly make a professional README.md for a new project, including a section for the description, installation, usage, what license you used, contributing members/files and tests for the project. It also includes a section for questions for anyone who wants to know more about your project.

  ## Table of Contents

  - [Installation](#installation)
  - [Usage](#usage)
  - [License](#license)
  - [Contributing](#contributing)
  - [Tests](#tests)
  - [Questions](#questions)

  ### Installation

  Open terminal or command and navigate to the file and go into the “Develop” folder and run “npm install”

  ### Usage

  To start the app, while still in the “Develop” run “node index.js” then answer the questions to fill in your README.md file. Once you are done, your generated README.md file will be in “gen-readme” folder. If there is already a README.md in the “gen-readme” it will update that file.

  ### License

  [![License: ISC](https://img.shields.io/badge/License-ISC-blue.svg)](https://opensource.org/licenses/ISC)

  ### Contributing

  I used inquirer npm for the questions

  ### Video

  ### Tests

  none

  ### Questions

  If you have any additional questions,
  Please reach out to me by email or through Github

  Email<EMAIL_ADDRESS>
  Github: theisen92

license: ISC


text:
# docker python microservice
Simplest possible `python` microservice, with `Bottle`. Packed and deployed into
a `docker container`.

If you need an intro on docker, you can check: [docker as a packaging environment](https://gist.github.com/javierarilos/a0f8dafdf63d65fb2c8c#file-docker-as-packaging-execution-environment-md) or `docker` documentation.

This sample is hosted in [github/javierarilos](https://github.com/javierarilos/docker_py_msrvice)

## System requirements
`docker` up and running, see: [docker/installation](https://docs.docker.com/engine/installation/)

## building the docker image
From this same directory:
```bash
$ docker build -t dpm .
```

## running the container
```bash
docker run -it --rm -p=<IP_ADDRESS>:8888:8888 dpm
```

## REST API
The application is a very simple microservice for `customers`.

`GET` a customer:
```bash
$ curl http://<IP_ADDRESS>:8888/customers/alan
```

`POST` a new customer:
```bash
curl -X POST -H 'Content-Type: application/json' -d '{"name": "alan", "born": 1903}' http://<IP_ADDRESS>:8888/customers
```

`GET` all customers:
```bash
$ curl http://<IP_ADDRESS>:8888/customers
```


text:
# Fetch -- The MEGA65 Custom Web Client

This program is a simple browser for displaying and navigating a special 8-bit web.

Like the Internet you know from using "big computers", the MEGA65's 8-bit web uses
HTTP to deliver web pages, which can contain text and graphics, and links to other
pages on the same or other sites on the Internet.

Where it differs, is that these pages are not written using HTML, but use the H65
format, which consists of a memory image of a graphical display, together with
information about any links to other pages.
This allows considerable flexibility, and full use of the MEGA65's advanced graphics
in the pages, without the need for complex parsing and rendering software on the
MEGA65.

Thus while the tools for developing H65 pages may initially be rather
rudimentary, this can be improved without requiring the browser to be modified.
For example, proportional anti-alised text displays, similar to those used in
the [MegaWAT!?](/megawat.h65) slide presentation software will be possible.

[Back](/index.h65)


text:
# XAP Core Buffer Utilities

This package implemented a set of utilities used to read/write buffer in network application.

## Requirements

| Package | Version   |
|---------|-----------|
| CMake   | >=3.10 |

| OS              | Version |
|-----------------|------------|
| Ubuntu Server   | >=18.04 |
| macOS Catalina  | >=10.15 |

| Compiler    | Version     |
|-------------|-------------|
| GCC         | >=7.5.0  |
| Apple clang | >=11.0.3 |

## Build

You can run the following command to build static/shared library and unit test executable.

```
cmake .
make
```

## Test

Run the following command to run unit test:

```
cmake test
```


text:
# Kerethites

## Facts:

The Kerethites were a people group who were probably part of the Philistines. Some versions write this name as “Cherethites.”

* The “Kerethites and Pelethites” were a special group of soldiers from King David’s army who were especially devoted to him as his bodyguards.
* Benaiah, son of Jehoiada, a member of David’s administrative corps, was the leader of the Kerethites and Pelethites.
* The Kerethites remained with David when he had to flee Jerusalem because of Absalom’s revolt.

(Translation suggestions: [Translate Names](../../translate/translate-names))

(See also: [Absalom](../names/absalom.md), [Benaiah](../names/benaiah.md), [David](../names/david.md), [Philistines](../names/philistines.md))

## Bible References:

* [Zephaniah 2:5](rc://en/tn/help/zep/02/05)

## Word Data:

* Strong’s: [[H3774]]

repository: mandolyte/uw-obsidian

repo_name: mandolyte/uw-obsidian


text:
---
title: Koding Terminal Introduction
author: Team Koding
categories: [koding features, koding]
videoId: 1579S_7R6EQ
---

# Koding Terminal Introduction

In this guide we'll go over the Koding Terminal. We'll try to explain how it works, how to use it and in end share some useful tips that you can use to be more productive.

## Getting started

To access a Koding Terminal, select your Virtual Machine on the left hand side as pictured bellow.

![Terminal 1](term1.png)

> type:alert
> If you have a Developer or Professional account then select the VM you want to start, from the list.

Then click on the `Turn it on` button in the modal.

![Terminal 2](term2.png)

After the VM has started, you'll see your Koding IDE.

> type:tip
> The IDE will remember what files / tabs you had opened last time and the FileTree will remember the folder location.

By default after your VM is started, you will see a Terminal prompt in the lower right portion of your Integrated Development Environment (IDE).

## Usage

With the Terminal, you are able to run commands on your Ubuntu Linux VM. All programs and languages are supported, and you have full sudo access, so you can customize your VM however you want.

> type:tip
> `sudo` is a program for Unix-like computer operating systems that allows users to run programs with the security privileges of another user (normally the superuser, or root).

The Terminal itself is fast and responsive. Vim, Nano, Tmux and anything else you throw at it, will work right out of the box.

By clicking the plus button next to the Terminal tab, you are able to create multiple Terminal sessions that are basically multiple Terminals where you can run commands separately.

![Terminal 3](term3.png)

> type:tip
> Terminal sessions are remembered when turning the VM on again.

Because the Terminal is in a tab in the IDE you can also split, merge splits, and even make the terminals fullscreen.

## Tips

The Koding Terminal comes preinstalled with some useful programms that can be run using these commands.

* `fish` - is a smart and user-friendly command line shell for OS X, Linux.
* `mc` - Midnight Commander is a powerful file manager. GNU Midnight Commander is a text-mode full-screen file manager.
* `vi` - is a highly configurable text editor built to enable efficient text editing.
* `nano` - text editor for the command line.
* `emacs` - GNU Emacs is an extensible, customizable text editor.

Bellow you can read more about some other useful commands that you can use in your Koding Terminal.

* `sudo` - most of the bellow commands will need to be prefaced with the sudo command. This elevates privileges to the root-user administrative level temporarily, which is necessary when working with directories or files not owned by your user account.

### File & Directory Commands

The tilde (~) symbol stands for your home directory. If you are user, then the tilde (~) stands for `/home/user`

* `pwd` - The `pwd` command will allow you to know in which directory you're located. A useful gnemonic is "present working directory."
* `ls` - The `ls` command will show you ('list') the files in your current directory.
* `cd` - The `cd` command will allow you to change directories. Eg. to navigate into the root directory, use `cd /`.
* `cp` - The `cp` command will make a copy of a file for you. Example: "cp file foo" will make an exact copy of "file" and name it "foo", but the file "file" will still be there.
* `mv` - The `mv` command will move a file to a different location or will rename a file. Examples are as follows: "mv file foo" will rename the file "file" to "foo".
* `rm` - Use this command to remove or delete a file in your directory.
* `rmdir` - The `rmdir` command will delete an empty directory. To delete a directory and all of its contents recursively, use `rm -r`.
* `mkdir` - The `mkdir` command will allow you to create directories. Example: "mkdir demo" will create a directory called "demo".
* `man`- The `man` command is used to show you the manual of other commands.

### System Information Commands

* `df` - The `df` command displays filesystem disk space usage for all mounted partitions. "df -h" is probably the most useful - it uses megabytes (M) and gigabytes (G) instead of blocks to report. (-h means "human-readable")
* `du` - The `du` command displays the disk usage for a directory.
* `free` The `free` command displays the amount of free and used memory in the system. "free -m" will give the information using megabytes.
* `top` - The `top` command displays information on your Linux system, running processes and system resources, including CPU, RAM & swap usage and total number of tasks being run. To exit top, press "q".
* `uname -a` - The `uname` command with the -a option prints all system information, including machine name, kernel name & version, and a few other details.
* `lsb_release -a` - The `lsb_release` command with the -a option prints version information for the Linux release you're running.
* `ifconfig` - reports the systems network interfaces.

The Koding Terminal is an essential component for development, right in your browser.

Explore it today and if you ever need help with the Terminal you can just click on the bottom right corner question mark icon and the support modal will pop-up or email us at [support<EMAIL_ADDRESS>and we'll gladly help.

repository: WebDevelopmentStudioWebAristan/kdlearn

gha_language: CSS

repo_name: WebDevelopmentStudioWebAristan/kdlearn


text:
# This project is still under construction.

# SudokuSolver
Practicing Object Oriented coding by writing a Sudoku solving program

SudokuSolver

# SudokuSolver
> A practice project to revisit basic object oriented concepts

## Installation
The logic is written in C# and can be run using Xamarin on a Mac. (It should run on Windows too)

## Usage example
Coming soon.

## Development setup

## Release History
For release, and general revision history, please review the commit log.

## License
See the LICENSE file for more information.

## How to contact me
See something here and want to tell me how great it is? Want to compare notes on how a problem was solved? Want to hire me? Just want to say hello?
You can drop me a line at:
email<EMAIL_ADDRESS>Twitter: @MikeButler5

repository: butlermike/SudokuSolver

repo_name: butlermike/SudokuSolver


text:
# ▶ oletus

[![Build Status](https://travis-ci.org/bearror/oletus.svg?branch=master)](https://travis-ci.org/bearror/oletus)

A zero configuration, zero dependency test runner for ECMAScript Modules—made specifically for getting started quick. Painless migration to the bigger guns if you end up needing them.

## Test Syntax

```js
import test from 'oletus'

// this should look pretty familiar
test('arrays are equal', t => {
  t.deepEqual([1, 2], [1, 2])
})
```

## Usage

### Add oletus to your project

Install it with npm:
```bash
npm install --save-dev oletus
```
Add the test script to your `package.json`, using the native [--experimental-modules](https://nodejs.org/api/esm.html#esm_ecmascript_modules):
```json
  "scripts": {
    "test": "npx -n='--experimental-modules --no-warnings' oletus"
  },
```
Alternatively, you can use the [esm](https://github.com/standard-things/esm#esm) package for wider support:
```json
  "scripts": {
    "test": "npx -n='-r esm' oletus"
  },
```

### Create the tests

Write your test modules in a `/test/` directory:
```js
import test from 'oletus'

test('foo', t => {
  t.ok(true)
})

test('bar', async t => {
  const bar = Promise.resolve('bar')

  t.equal(await bar, 'bar')
})
```

---

#### Alternate test locations

It's also possible to run tests that match a pattern passed in as a command-line argument.
```bash
oletus src/**/*.test.mjs
```

---

### `npm test` away!

## Reporters

Oletus has a *concise reporter* on local runs and a *verbose reporter* on CI environments.

<img src="./oletus-reporters.png">

## API

### `test(title, implementation)`
The imported `test` is an *async function* that expects the `title` and `implementation` of the test to be passed in as arguments. The implementation has a single parameter (`t`, for example) that gets passed the [strict node assertion](https://nodejs.org/api/assert.html#assert_strict_mode) module.

## Author

Joonatan Vuorinen ([@bearror](https://twitter.com/bearror))

repository: Avaq/oletus

repo_name: Avaq/oletus


text:
---
layout: post
title: Python magic methods (1)
categories:
- blog
tags:
- Python
- advanced features

---

## Python magic methods (1) : \_\_new\_\_() and \_\_init\_\_()

In Python, magic methods are special methods where you can define to add "magic" to classes. They're always surrounded by double underscores (called 'dunder'). We will look into these magic methods in Object construction and initialization and see how they add advantages to python object oriented programming.

### Object construction and initialization

- \_\_new\_\_(cls, [...): the first method to get called in an object's instantiation
- \_\_init\_\_(self, [...): the method get called to create objects of class

From the definition above, we see that \_\_new\_\_() accepts cls as it's first parameter, while \_\_init\_\_() accepts self. \_\_init\_\_() is called after \_\_new\_\_() when object is initialized.

Let's take a look at example below.

```
class MyClass(object):

    def __new__(cls):
        print "MyClass.__new__ called"
        return super(MyClass, cls).__new__(cls) # here super is type

    def __init__(self):
        print "MyClass.__init__ called"

if __name__ == '__main__':
    c = MyClass()
```

Result:

```
MyClass.__new__ called
MyClass.__init__ called
```

As we can see, \_\_new\_\_() method took cls as the input to create _self_ object, then when a new MyClass object is instantiated, \_\_init\_\_() is called thereafter.

Another thing to note: \_\_new\_\_() is called automatically when calling the class name, which is when we do MyClass(). On the other hand, \_\_init\_\_() is called every time an instance of the class is returned by \_\_new\_\_() passing the returned instance to \_\_init\_\_() as 'self'.

As such, \_\_new\_\_() will return the instance of _cls_, and then, this new instance will be picked up by \_\_init\_\_(). If we ommit calling super for \_\_new\_\_() and not return anything, then \_\_init\_\_() won't be executed.

### When to use \_\_new\_\_()?

If you want to control the actual creation process, use the \_\_new\_\_() method. If you intend to alter something like the base classes or the attributes, you’ll have to do it in \_\_new\_\_().

Below example is to help to create a customized list with a method , "add". By default, python list doesn't have add method, but in this example we can create this customized list by adding add to the attr of the metaclass in \_\_new\_\_() method.

```
class ListMetaclass(type):
    def __new__(cls, name, bases, attrs):
        attrs['add'] = lambda self, value: self.append(value)
        return type.__new__(cls, name, bases, attrs)

class MyList(list):
    __metaclass__ = ListMetaclass # use ListMetaclass to customize class

if __name__ == '__main__':
    #c = MyClass()
    l = MyList()
    l.add(1)
    print (l)
```

Result:
```
[1]
```

The result shows this MyList() instance has a method add which adds elements to the list.

gha_language: HTML


text:
## Pseudo threads with generators and PyGTK/gnome-python
Originally published: 2004-11-05 06:33:06
Last updated: 2004-11-05 06:33:06
Author: Arjan Molenaar

A thread-like interface for those who want to "use" threads in Python with PyGTK. I use it when loading files and display a nice progress bar. The function or method you give to GIdleThread should "yield" every now and then. This makes it simpler to write code, since you do not have to care about nasty locks.


text:
# gs\_install

## Background

Database deployment is a complex process.  **gs\_install**, provided by openGauss, is used to install and deploy openGauss.

Installation and deployment of openGauss require you to specify a configuration file, in which the program installation path, instance data directory, the primary/standby relationship, the number of instances, and the service IP address of each instance are specified.

## Prerequisites

-   You have successfully executed the  **gs\_preinstall**  script.
-   The  **locale**  parameter for each server is set to the same value.
-   openGauss users must be set during the preinstallation process.

## Syntax

-   Install openGauss.

    ```
    gs_install -X XMLFILE [--gsinit-parameter="PARAMETER" [...]] [--dn-guc="PARAMETER" [...]] [--alarm-component=ALARMCOMPONENT] [--time-out=SECS] [-l LOGFILE]
    ```

    >![](public_sys-resources/icon-note.gif) **NOTE:**

-   Display help information.

    ```
    gs_install -? | --help
    ```

-   Display version information.

    ```
    gs_install -V | --version
    ```

## Parameter Description

-   -X

    Specifies the path of the openGauss configuration file.

    Value range: storage paths of XML files

-   -l

    Specifies a log file and its path.

    When  **-l**  is not specified but  **gaussdbLogPath**  is set in the XML file, the default value of the  **-l**  parameter is the combination value of  **gaussdbLogPath/**_User name_**/om/gs\_install-YYYY-MM-DD\_hhmmss.log**.

-   --gsinit-parameter=PARAM

    Specifies the data instance parameters.

    For details about the value range, see parameter description in  [gs\_initdb](gs_initdb.md). Among which, the settings of the  **-A**,  **-D**,  **-U**,  **-C**, and  **-X**  parameters do not take effect.

-   --dn-guc=PARAM

    Set a parameter.

    For details about the value range, see parameter description in  [gs\_guc](gs_guc.md).

-   --time-out=SECS

    Specifies the timeout threshold for startup. Unit: s

    If the value of  **--time-out**  is too small, the instance startup may time out due to a large number of instances. If the instance failed to be started within the specified timeout period, an error will be reported. openGauss still runs at the backend. You can wait for a while and then query the openGauss status to check whether openGauss is started successfully.

    Value range: a positive integer. If there is no special requirement, you do not need to set this parameter. The system automatically adjusts the timeout threshold.

-   --alarm-component=alarm\_component

    Specifies the absolute path of the component to report alarms.

-   -?, --help

    Displays help information.

-   -V, --version

    Displays version information.

## Example

Use  **gs\_install**  to install openGauss.

```
gs_install -X /opt/software/openGauss/clusterconfig.xml
Parsing the configuration file.
Check preinstall on every node.
Successfully checked preinstall on every node.
Creating the backup directory.
Successfully created the backup directory.
begin deploy..
Installing the cluster.
begin prepare Install Cluster..
Checking the installation environment on all nodes.
begin install Cluster..
Installing applications on all nodes.
Successfully installed APP.
begin init Instance..
encrypt cipher and rand files for database.
Please enter password for database:
Please repeat for database:
begin to create CA cert files
The sslcert will be generated in /opt/gaussdb/cluster/app/share/sslcert/om
Cluster installation is completed.
Configuring.
Deleting instances from all nodes.
Successfully deleted instances from all nodes.
Checking node configuration on all nodes.
Initializing instances on all nodes.
Updating instance configuration on all nodes.
Check consistence of memCheck and coresCheck on DN nodes.
Successful check consistence of memCheck and coresCheck on all nodes.
Configuring pg_hba on all nodes.
Configuration is completed.
Successfully started cluster.
Successfully installed application.
```

## Helpful Links

[gs\_postuninstall](gs_postuninstall.md),  [gs\_preinstall](gs_preinstall.md), and  [gs\_uninstall](gs_uninstall.md)


text:
---
title: Courses List
summary: List of my followed University courses
date: "2020-08-14T00:00:00Z"

reading_time: false  # Show estimated reading time?
share: false  # Show social sharing links?
profile: false  # Show author profile?
comments: false  # Show comments?

# Optional header image (relative to `static/img/` folder).
header:
  caption: ""
  image: ""
---
# MSc Embedded Systems

## Compulsory Courses
* Embedded Computer Architectures 1
* System Validation
* Quantitative Evaluation of Embedded Systems
* Real Time Systems 1
* Embedded Systems Laboratory

## Elective Courses
* Security in Embedded Hardware
* Design of Digital Systems
* Programming Principles, Patterns, and Processes
* Basic Machine Learning
* Distributed Systems
* Implementation of Digital Signal Processing
* Embedded Computer Architectures 2

# BSc Electrical Engineering
* Introduction to Electrical Engineering
* Electric Circuit Analysis
* Analog Electronics
* Electromagnetic Radiation
* Computer Architecture and Organisation
* Control Systems
* Signal Processing and Communication
* Network Systems
* Minor Device Physics
* Minor Biorobotics
* Electronic Systems Design

repository: RickvanLoo/Rickvanloo-site

repo_name: RickvanLoo/Rickvanloo-site


text:
# Arduino Based Volume Control System

This is a system for controlling a PGA4311 or PGA2311 with an Arduino.

## Supported features

 * Rotary encoder volume control with push button mute
 * Control of PGA4311 or PGA2311 volume controllers
 * EEPROM volume save state
 * Delayed save to EEPROM to prevent rewrites after every changes volume
 * Volume scaling function for smoother volume transitions
 * Limiting on maximum volume for PGA4311 control registers
 * Digital I/O used: 6 pins
 * Serial debug provided if desired
 * Code approximately 6 kB incuding serial debug

## Intended operation

To use this code, you simply need import it to you
Arduino IDE and ensure that the dependent library
are available.  You should choose which pins meet your
needs and set them in the #define section.  You can
reverse the operation of some pins.

PGA mute pin need pull down 10k resistor to GND.

You might find it prudent to trim this code to the
feature set you are looking for rather than use
it with all the conditional compilation.  That would
clean it up quite a bit and make it simpler to debug.
As is clear, this code has a fair bit of flexible
functionality, but it is rather a mess.

## IMPORTANT

Release of this code in no way implicates that any
product designed by myself or any company that I am
involved with is constrained in any way to the methods
and / or implications of functionality, expressly or
implicitly, based on the code contained herein.  The code
presented here is intended as an as-is instructional
collection of potential methods that may or may not be
fit for any application.

repository: krolaka/arduino-volume-control

repo_name: krolaka/arduino-volume-control


text:
# OVHcloud pelican theme

The theme is based on [pelican theme documentation](https://docs.getpelican.com/en/3.7.1/themes.html).

## Structure

### static

Contains static files (css / js). It also contains header / footer content exported from ovhcloud.com.

**header / footer folders**

The following folders are header / footer related :
* 7af16cdb
* img
* modules
* sites

**fonts/**

Contains needed web fonts.

**css/**

Contains CSS stylesheets.
Pure CSS stylesheets, no pre-processor.

**js/**

Contains JS files.
No javascript package manager / bundler is used yet.

### templates

Each content type has a dedicated template.

**header / footer folders**

There are header (menus) / footer related html files in the corresponding directories. There is one file per language.

**macros/**

Jinja [macros](https://jinja.palletsprojects.com/en/3.1.x/templates/#macros). They are functions to be used in templates.

**components/**

*Logically* grouped templated referring to specific front parts of the application, hence *components*.

repository: ovh/docs-rendering

repo_name: ovh/docs-rendering


text:
# gAssert

gAssert is a Golang utility package for asserting runtime conditions.  Behavior can be set differently for testing and production environments.

For implementation level details use Godoc.

license: Unlicense


text:
[![npm version](https://badge.fury.io/js/build-tools-common.svg)](https://npmjs.com/package/build-tools-common)

# build-tools-common

This package includes common utilities.

## Install

```
npm install --save-dev build-tools-common
```

## Links

- [cross-env](https://www.npmjs.com/package/cross-env)
- [rimraf](https://www.npmjs.com/package/rimraf)

repository: luis-gutierrez-adidas/js-build-tools

repo_name: luis-gutierrez-adidas/js-build-tools


text:
# Build example for an express, reactjs env

> A example for client and server environment for ReactJS in es6
>(gulp, webpack, react, flux, bootstrap 4, sass, babel)

### Install

```
cd client
npm install

```

> Run for dev ([localhost:8080](http://localhost:8080)) :

```
gulp

```

> For final build

```
gulp build

```

repository: johnsbarrie/web-dev-env

repo_name: johnsbarrie/web-dev-env


text:
**Transport fuel emissions methodology. Calculates direct fossil and/or
biogenic carbon dioxide (CO2), methane (CH4), nitrous oxide
(N2O) and carbon dioxide equivalent (CO2e) emissions associated
with fuel consumed for a variety of common transport fuels. Choices
include fuel type and combustion context. Global.**

## Summary

This methodology represents greenhouse gas emissions associated with the
combustion of **fuel** in specific transportation contexts in the US, UK
and other regions. The data and calculation methodology is based on
those provided in the Greenhouse Gas Protocol worksheet *GHG emissions
from transport or mobile sources* (version 2.2), published in June 2011.

-----

## The methodology

### Emissions model

The emissions methodology is based upon emissions factors which describe
the greenhouse gas emissions associated with the specific quantities of
transport fuel. These emissions factors can be contrasted with similar
transport-related emissions factors which describe emissions on the
basis of *distance*. This methodology is typically more accurate for
calculating transport related greenhouse gas emissions since it involves
a more direct measure of fuel consumption without the requirement for
assumptions about vehicle fuel efficiencies.

According to this methodology, CO2 emissions are [directly
related](Custom_emissions_factors) to the quantity of carbon which is
oxidised during combustion and therefore directly proportionate to the
quantity of fuel burned and the concentration of carbon within the
particular fuel type (e.g. gasoline/petrol, diesel). Emissions of
CH4 and N2O, however, are considered to vary with the specific
use context. This category, then, provides fuel-based emissions factors
for CH4 and N2O differentiated by fuel type and specific use
contexts. For a complete greenhouse gas calculation, CO2 emissions
factors referenced for each fuel type from this related
[methodology](Transport_fuels_by_Greenhouse_Gas_Protocol), sourced from
the same Greenhouse Gas Protocol worksheet.

Emissions - conventionally expressed in terms of mass (e.g. *kg*) - are
calculated by multiplying these rates (*mass emitted per volume*; e.g.
*kg CO2 per US gallon*) by a volume of fuel (e.g *gallons*)
consumed.

### Model data

The rate at which fuel combustion produces greenhouse gas emissions
varies depending on fuel type and the specific use context. Therefore,
emissions factors for distinct combinations of fuel type and context are
provided. The fuels represented are:

  - diesel
  - petrol/gasoline
  - residual fuel oil

The use context represented are:

  - train
  - agricultural equipment
  - construction equipment
  - ship and boat

Region-specific emissions factors are provided for each fuel type for
the UK, the US and 'other regions'.

### Activity data required

According to this methodology, greenhouse gas emissions are directly
proportionate to the quantity of fuel consumed. Fuel quantity must be
specified on the basis of volume by setting the ***volume*** profile
item value.

Users can choose to specify their activity data in a comprehensive range
of appropriate [units](Units).

### Calculation and result

The returned quantities for this methodology represent CO2, CH4
and N2O and CO2e emissions associated with the type, quantity
and context of fuel specified. CO2e emissions represent all three
gases, converted using
[these](Greenhouse_gases_Global_warming_potentials) global warming
potential). The individual quantities for CH4 and N2O represent
*absolute quantities* rather than CO2e quantities.

-----

### Similar methodologies

Other Greenhouse Gas Protocol transport methodologies are available
representing [general fuel
consumption](Transport_fuels_by_Greenhouse_Gas_Protocol), [freighting of
goods](Freight_transport_by_Greenhouse_Gas_Protocol), [passenger/public
transport](Passenger_transport_by_Greenhouse_Gas_Protocol), and road
transportation in the [UK](UK_road_transport_by_Greenhouse_Gas_Protocol)
(with [heavy
goods](UK_heavy_goods_transport_by_Greenhouse_Gas_Protocol)),
[US](US_road_transport_by_Greenhouse_Gas_Protocol) and [other
regions](Other_regional_road_transport_by_Greenhouse_Gas_Protocol).

-----

repository: thegreenwebfoundation/datasets

repo_name: thegreenwebfoundation/datasets