text:
# MClust
# Language: R
# Input: CSV
# Output: CSV
# Tested with: PluMA 1.0, R 4.0.0
# Dependency: mclust_5.4.6

PluMA plugin to run the MClust (Scrucca et al, 2016) clustering algorithm.

The plugin accepts as input a CSV file containing samples (rows) and measurements (columns)
Entry (i, j) corresponds to the measurement of j in sample i.

It will then output a CSV file of clusters, mapping samples to cluster numbers.


text:
Logo developed by <a<EMAIL_ADDRESS>

Sneaker Monitors

    A collection of web monitors that notify of restocks or updates on sneaker related sites through Discord Webhook

    Report Bug
    ·
    Request Feature

To be notified of changes, please **star** or **watch** this repository.
This will also increase the awareness of the project for others to use or add to.

Check out the docs [here](https://yasserqureshi1.github.io/Sneaker-Monitors/)

## About the Project
This project is aimed at providing web-monitors for various sites to the sneaker community for free.
The monitors currently notify if a restock or release occurs via Discord Webhook.
Today, competition to purchase sneakers is getting increasingly difficult with resellers using paid automated tools to give them a massive advantage over everyone else.
As such, I have and will continue to develop monitors that will help those members that struggle to finally get the sneakers they want.

This project is continually expanding, and I would greatly appreciate any contributions.
When contributing please fork the project and open a Pull Request.

However, due to popular demand, I am developing a paid (but competitively priced) set of hosted monitors. These will be released on my Discord Server that you can join in [#Contact](#Contact).

*Below is a screenshot of the SNKRS monitor in action...*

## Contents
* [About the Project](#about-the-project)
* [Monitors](#monitors)
* [Installation](#installation)
* [Set Up](#set-up)
* [Issues](#issues)
* [License](#license)
* [Contact](#contact)

## Monitors

Currently the sites that have monitors are:
- All Shopify sites (e.g. Palace Skateboards, Hanon Shop, OVO, shopnicekicks.com, BDGA Store, Noir Fonce, Travis Scott, etc.)
- Supreme
- Nike SNKRS (Supports 42 countries - see the associated README file)
- Footsites (Footlocker UK, US, CA and AU)
- Ssense
- Zalando (UK)
- Off-Spring (UK)
- Solebox
- Snipes

## Installation
Ensure you have [Python 3+](https://www.python.org/downloads/) and [pip](https://pip.pypa.io/en/stable/installing/) installed.

To install the dependencies, navigate to the cloned directory in Terminal or Command Prompt and use the command:
```
pip install -r requirements.txt
```

## Set Up

### Video Tutorials

Click on the image below to watch a YouTube tutorial on setting the monitor up locally...
[![Watch the video](https://img.youtube.com/vi/mUTGCzWIDQk/mqdefault.jpg)](https://youtu.be/mUTGCzWIDQk)

Click on the image below to watch a YouTube tutorial on setting the monitor up on a server...
[![Watch the video](https://img.youtube.com/vi/nmUSSlt4JKk/mqdefault.jpg)](https://youtu.be/nmUSSlt4JKk)

Click on the image below to watch a YouTube tutorial on setting the monitor up using git...
[![Watch the video](https://img.youtube.com/vi/QjeLg4xbnqc/mqdefault.jpg)](https://youtu.be/QjeLg4xbnqc)

### Basic Steps

1. Clone or Download the repository
    - Clone:
    ```
    git clone https://github.com/yasserqureshi1/Sneaker-Monitors.git
    ```
    - Download: Click on the green `Code` button and click on `Download ZIP`. Then unzip this folder

2. Perform the installation described in [#Installation](#installation).

3. Start editting the `.env` file to your specifications. You will only be interacting with the ```.env``` file.
    - **Add Webhook**: Paste your Discord Webhook URL under the `WEBHOOK` variable. It should look like this:
    ```
    WEBHOOK = "https://discord.com/api/webhooks/..."
    ```
    - (Optional) **Add Proxy**: Paste your proxy under the `PROXY` variable. There are two structures:

        1. ```PROXY = "<proxy>:<port>"```
        2. ```PROXY = "<proxy_username>:<proxy_password>@<proxy_domain>:<port>"```
    - You can also edit other details within the `.env` file as you see fit

4. Run the Python file. You can use the following command:
  ```
  python [file name].py
  ```

**NOTE:** The script needs to be running continuously for it to keep monitoring websites. As such, you should host it on a server. I have a YouTube tutorial on this [here](https://youtu.be/nmUSSlt4JKk). However, I suggest testing this out on your PC before using a server.

## Issues

If you find an issue, please open an issue [here](https://github.com/yasserqureshi1/Sneaker-Monitors/issues/new).
I will try to respond fairly quickly and try to come up with solution.

I may ask you to provide the log file that is produced by the monitor.
It contains no personal data but may help me diagnose where the issue arises.

## License

Distributed under the MIT License. See ```LICENSE``` for more information.

## Contact

For help join my Discord server [here](https://discord.gg/D8kfJ4pt3m) and post a question in the #questions channel

license: MIT

repository: snkrkarma/Sneaker-Monitors

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: snkrkarma/Sneaker-Monitors


text:
# WSPS Python client

This is a Python client for [WSPS server](http://github.com/lietu/wsps-server).

WSPS stands for WebSocket Pub(lisher)-Sub(scriber), and that pretty much covers what it does. The WSPS server provides a WebSocket interface for clients to subscribe to messages on different "channels", and then publishing messages on those channels.

Licensed under MIT and new BSD licenses, more details in `LICENSE.txt`.

## Dependencies

This library uses ws4py, which can work just with threads, using Tornado, or
with Gevent. This library gives you the ability to use all of those options as
well, but if you plan on using Tornado or Gevent you will need to install a
compatible version yourself.

Currently the Gevent and Tornado client implementations are imaginary, but not
for long.

## Usage

### How to get it

With pip:
```
pip install wsps
```

Or easy_install:
```
easy_install wsps
```

### Example

This example assumes the WSPS server is running at localhost:52525.

The server `local_settings.py` should contain the following:

```python
LISTEN_PORT = 52525

SUBSCRIBE_KEYS = {
    r"some-channel": "subscribe-key"
}

PUBLISH_KEYS = {
    r"some-channel": "publish-key"
}

AUTHORIZATION_MANAGER = 'wspsserver.auth:SettingsAuthManager'
```

After that, this code should work:
```python
from time import sleep  # Not normally required
from wsps import WSPSClient  # Threaded client

subscribe_key = "subscribe-key"
publish_key = "publish-key"

def on_close(code, reason):
    print("Disconnected with code {}, reason was: {}".format(
        code, reason
    ))

def on_msg(packet):
    print("Got message: {}".format(packet.data["msg"]))

wsps = WSPSClient("ws://<IP_ADDRESS>:52525", on_close)
wsps.connect()
wsps.subscribe("some-channel", on_msg, subscribe_key)
sleep(0.25) # Normally you don't have to wait to subscribe to your own events
wsps.publish("some-channel", {"msg": "Hello, WSPS!"}, publish_key)
sleep(0.25) # Normally you also don't wait for events to arrive before quitting
wsps.disconnect()
```

## Improved performance via WSAccel

You can use [WSAccel](https://pypi.python.org/pypi/wsaccel) to improve the
performance of the client, WSPS will dynamically patch the ws4py library with
some optimized Cython code from it if it is available.

To install it just use pip:
```
pip install wsaccel
```

# Financial support

This project has been made possible thanks to [Cocreators](https://cocreators.ee) and [Lietu](https://lietu.net). You can help us continue our open source work by supporting us on [Buy me a coffee](https://www.buymeacoffee.com/cocreators).

[!["Buy Me A Coffee"](https://www.buymeacoffee.com/assets/img/custom_images/orange_img.png)](https://www.buymeacoffee.com/cocreators)

repository: lietu/wsps-python

repo_name: lietu/wsps-python


text:
---
metaTitle: "R - Feature Selection in R -- Removing Extraneous Features"
description: "Removing features with zero or near-zero variance, Removing features with high numbers of NA, Removing closely correlated features"
---

# Feature Selection in R -- Removing Extraneous Features

## Removing features with zero or near-zero variance

A feature that has near zero variance is a good candidate for removal.

You can manually detect numerical variance below your own threshold:

```r
data("GermanCredit")
variances<-apply(GermanCredit, 2, var)
variances[which(variances<=0.0025)]

```

Or, you can use the caret package to find near zero variance.  An advantage here is that is defines near zero variance not in the numerical calculation of variance, but rather as a function of rarity:

>
<p>"nearZeroVar diagnoses predictors that have one unique value (i.e. are
zero variance predictors) or predictors that are have both of the
following characteristics: they have very few unique values relative
to the number of samples and the ratio of the frequency of the most
common value to the frequency of the second most common value is large..."</p>

```r
library(caret)
names(GermanCredit)[nearZeroVar(GermanCredit)]

```

## Removing features with high numbers of NA

If a feature is largely lacking data, it is a good candidate for removal:

```r
library(VIM)
data(sleep)
colMeans(is.na(sleep))

   BodyWgt   BrainWgt       NonD      Dream      Sleep       Span       Gest
0.00000000 0.00000000 0.22580645 0.19354839 0.06451613 0.06451613 0.06451613
      Pred        Exp     Danger
0.00000000 0.00000000 0.00000000

```

In this case, we may want to remove NonD and Dream, which each have around 20% missing values (your cutoff may vary)

## Removing closely correlated features

Closely correlated features may add variance to your model, and removing one of a correlated pair might help reduce that. There are lots of ways to detect correlation.  Here's one:

```r
library(purrr) # in order to use keep()

# select correlatable vars
toCorrelate<-mtcars %>% keep(is.numeric)

# calculate correlation matrix
correlationMatrix <- cor(toCorrelate)

# pick only one out of each highly correlated pair's mirror image
correlationMatrix[upper.tri(correlationMatrix)]<-0

# and I don't remove the highly-correlated-with-itself group
diag(correlationMatrix)<-0

# find features that are highly correlated with another feature at the +- 0.85 level
apply(correlationMatrix,2, function(x) any(abs(x)>=0.85))

  mpg   cyl  disp    hp  drat    wt  qsec    vs    am  gear  carb
 TRUE  TRUE  TRUE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE

```

I'll want to look at what MPG is correlated to so strongly, and decide what to keep and what to toss.  Same for cyl and disp.  Alternatively, I might need to combine some strongly correlated features.

repository: haifenghuang/generate

repo_name: haifenghuang/generate


text:
# Puppet Enterprise (pe) Administration (adm) Module

This Puppet module contains Bolt plans used to deploy and manage Puppet Enterprise infrastructure. Plans are provided to automate common lifecycle activities in order to increase velocity and reduce the possibility of human error incurred by manually performing these activities.

The peadm module is able to deploy and manage Puppet Enterprise 2019.7 and higher for Standard, Large, and Extra Large architectures.

#### Table of Contents

- [Puppet Enterprise (pe) Administration (adm) Module](#puppet-enterprise-pe-administration-adm-module)
      - [Table of Contents](#table-of-contents)
  - [Expectations and support](#expectations-and-support)
  - [Overview](#overview)
    - [What peadm affects](#what-peadm-affects)
    - [What peadm does not affect](#what-peadm-does-not-affect)
    - [Requirements](#requirements)
  - [Usage](#usage)
  - [Reference](#reference)
  - [Getting Help](#getting-help)

## Expectations and support

While the peadm module was initially built by the Puppet Solutions Architecture team to streamline particularly large and complex Puppet Enterprise deployments, but has matured to a point where we believe that users with a reasonable understanding of Puppet Enterprise architecture can use it on their own.

As a Puppet Enterprise customer this tool is **supported** through Puppet Enterprise's standard and premium [support.puppet.com](https://support.puppet.com) service, and if you have questions or need assistance, you are welcome to reach out to your Support team for help, or to talk to your Sales or Technical Account Manager contacts to arrange a chat with one of us on the Solutions Architect team.

We also love contributions! We're more than happy to also chat about any ideas you may have for improving this module, or offer guidance on ways you could get involved.

## Overview

The normal usage pattern for peadm is as follows.

1. Users set up a Bolt host from which they can run peadm plans. The Bolt host can be any machine that has ssh access to all of the PE nodes.
2. Users run the `peadm::install` plan to bootstrap a new PE cluster. Depending on the architecture chosen, peadm may create some node groups in the classifier to set parameters on the built-in `puppet_enterprise` module, tuning it for large or extra large architectures.
3. Users use and operate their PE cluster as normal. The peadm module is not used again until the next upgrade.
4. When it is time to upgrade, users run the `peadm::upgrade` plan from their Bolt host to accelerate and aid in the upgrade process.

### What peadm affects

* The `peadm::install` plan adds a number of custom OID trusted facts to the certificates of PE infrastructure nodes as it deploys them. These trusted facts are later used by the plans to quickly and correctly identify nodes in particular roles.
* Up to four node groups may be created to help configure `puppet_enterprise` class parameters for PE infrastructure roles. The most notable configuration is the designation of compilers as being either "A" or "B" nodes for availability.

### What peadm does not affect

* The peadm module is not required to exist or be present outside of the point(s) in time it is used to create a new PE cluster, or upgrade an existing cluster. No new Puppet classes or other persistent content not provided out-of-box by PE itself is applied to PE infrastructure nodes by the peadm module.
* Having used the peadm module to install or to upgrade a PE cluster is not known to affect or curtail the ability to use any normal, documented PE procedures, e.g. failover to a replica, or manual upgrade of a cluster.

### Requirements

* Puppet Enterprise 2019.8.1 or newer (tested with PE 2021.7)
* Bolt 3.17.0 or newer (tested with Bolt 3.21.0)
* EL 7, EL 8, Ubuntu 18.04, or Ubuntu 20.04
* Classifier Data enabled. This PE feature is enabled by default on new installs, but can be disabled by users if they remove the relevant configuration from their global hiera.yaml file. See the [PE docs](https://puppet.com/docs/pe/latest/config_console.html#task-5039) for more information.

## Usage

Follow the links below to usage instructions for each peadm plan.

* [Install](https://github.com/puppetlabs/puppetlabs-peadm/blob/main/documentation/install.md)
* [Upgrade](https://github.com/puppetlabs/puppetlabs-peadm/blob/main/documentation/upgrade.md)
* [Convert](https://github.com/puppetlabs/puppetlabs-peadm/blob/main/documentation/convert.md)
* [Status](https://github.com/puppetlabs/puppetlabs-peadm/blob/main/documentation/status.md)

## Reference

Information from the Puppet documentation site that will help you understand which architecture is right for you.

* [PE Architecture Documentation](https://puppet.com/docs/pe/latest/choosing_an_architecture.html)
* [PE Multi-region reference architecture](https://puppet.com/docs/patterns-and-tactics/latest/reference-architectures/pe-multi-region-reference-architectures.html)

Documentation pertaining to additional uses of peadm.

* [DR Component Recovery](https://github.com/puppetlabs/puppetlabs-peadm/blob/main/documentation/recovery.md)
* [Architectures](https://github.com/puppetlabs/puppetlabs-peadm/blob/main/documentation/architectures.md)
* [Expanding Deployment](https://github.com/puppetlabs/puppetlabs-peadm/blob/main/documentation/expanding.md)
* [Classification](https://github.com/puppetlabs/puppetlabs-peadm/blob/main/documentation/classification.md)
* [Testing](https://github.com/puppetlabs/puppetlabs-peadm/blob/main/documentation/pre_post_checks.md)
* [Docker Based Examples](https://github.com/puppetlabs/puppetlabs-peadm/blob/main/documentation/docker_examples.md)

## Getting Help

* If you find bugs with this module, please make use of [issues](https://github.com/puppetlabs/puppetlabs-peadm/issues) in the project on GitHub
* If you are a Puppet Enterprise (PE) customer that uses peadm to manage a deployment of PE and are currently having an outage or need assistance troubleshooting another issue, e.g. upgrades, contact the [Support Team](https://support.puppet.com)

repository: puppetlabs/puppetlabs-peadm

branch_name: refs/heads/main

gha_language: Puppet

repo_name: puppetlabs/puppetlabs-peadm


text:
# Introduction

This bundle of python scripts is aimed at everyone in the IT security industry who has to inspect, manage and track application vulnerabilities and create nice looking reports. At the moment there is de facto no standard format/layout to describe application vulnerabilities. In the past history there were several suggestions but none of them was established as a standard.

Besides that every (web) application scanner uses its own reporting format so you can't really compare results from different vendors.  This is here the idea for this whole project came of: The ability to compare different scanning results for better vulnerability scan coverage.

# Technology

I mainly use Python to to the most important jobs because of its simplicity and OS independence. Among Python 3.x I make heavy use of:

* **XML**
  Used to store vulnerability data and to convert scanning results into preferred layout

* **XSLT**
  XML transformation at its best. Basically there is one XSLT file for every single application scanner to do the transformation part. The rest is performed by Python magic.

* **SQLite**
  I love SQL and I definitely love SQLite for being a lite, useful RDMS. I generally like the idea of putting data into relations and therefor create astonishing results. Just try to do the same with Excel and afterwards you'll love *relational* data bases.

# The AppVuln* suite

The vulnerability management system (VMS) consists of 3 main components

* **AppVulnXML**
   Specifies how to store application vulnerability data and structures it a useful parseable way. In case of HTTP the traffic is being      parsed and saved in smaller structures like: URL, headers, POST parameters, data etc.

* **AppVulnDB**
   In order to track all the vulnerabilities found within your favorite scanning tool, you'll need a DB to take of the management itself. AppVulnDB is basically the vulnerability management system mentioned before and records vulnerabilities (and metadata) in the AppVulnXML format. So this component will provide you with an API to import/export AppVulnXML files.

* **AppVulnMS**
  If you put all together, you'll get a VMS able to convert scanning results into AppVulnXML format and finally import them to the AppVulnDB. At the moment the AppVulnMS describes the whole software bundle you'll get.

## AppVulnXML

The XML describes a way how to handle and store application vulnerability data. Meta data is stored as well. Generally speaking you'll have 3 main section within any XML document:

* **Scanner information**
  Includes details about the scanner itself like name, version etc.

* **Summary**
  You'll get a brief short summary about results: How many findings? How many High/Medium/Log/Informational issues? Scan duration ...

* **Results**
  Last but not least you'll get the results section which contains all vulnerability related data.

### Scanner information

```xml
<Scanner>
        <Name>Favourite scanning tool</Name>
        <Version>x.y.z</Version>
</Scanner>
```

### Summary

```xml
<Summary>
    <TotalIssues>41</TotalIssues>
    <ScanDuration/>
    <Targets>
      <Host name="http://exmple.com">
        <Issues total="41">
          <High>7</High>
          <Medium>0</Medium>
          <Low>1</Low>
          <Informational>33</Informational>
        </Issues>
      </Host>
    </Targets>
  </Summary>
```

### Results

```xml
 <Results>
    <Vulnerabilities>
      <Vuln type="authBypassSQLInjection" error_type="">
        <Description>Authentication Bypass Using SQL Injection</Description>
        <Comments>SQL Injection</Comments>
        <Target host="http://demo.testfire.net/bank/login.aspx"/>
        <Severity>High</Severity>
        <RawTraffic>
          <RequestTraffic base64="false"><![CDATA[...]]></RequestTraffic>
          <ResponseTraffic base64="false"><![CDATA[...]]></ResponseTraffic>
        </RawTraffic>
        <TestProbe>
          <HTTP>
            <Request method="POST" version="HTTP/1.1">
              <URL>/bank/login.aspx</URL>
              <Parsed>
                <Header name="Content-Length" value="41"/>
                ...
                <Header name="Cookie" value="ASP.NET_SessionId=zocks0555ove35rprhyz0w45"/>
                <Header name="Cookie" value="amSessionId=65819338695"/>
                <Header name="Cookie" value="amUserInfo=UserName=anNtaXRo&Password=ZGVtbzEyMzQ="/>
                <Data><![CDATA[uid=jsmith&passw=demo1234&btnSubmit=Login]]></Data>
              </Parsed>
              <Payload>
                <Input type="Parameter" name="passw"><![CDATA[4ppSc4n]]></Input>
                <Raw><![CDATA[...]]></Raw>
              </Payload>
            </Request>
            <Response version="HTTP/1.0" status="302" reason="Moved Temporarily">
              <Parsed>
                <Header name="Date" value="Mon, 01 Jul 2013 12:17:44 GMT"/>
                <Header name="Expires" value="-1"/>
                <Header name="Content-Type" value="text/html; charset=utf-8"/>
                <Header name="Content-Length" value="136"/>
                <Header name="Proxy-Connection" value="keep-alive"/>
                <Header name="X-Powered-By" value="ASP.NET"/>
                ....
                <Data base64="False"><![CDATA[...]]></Data>
              </Parsed>
            </Response>
          </HTTP>
        </TestProbe>
        <References>
          <Ref type="CWE" id="CWE-566" URL="http://cwe.mitre.org/data/definitions/566.html"/>
          <Ref id="external-site" type=""Web Application Disassembly with ODBC Error Messages" (By David Litchfield)" URL="http://www.cgisecurity.com/lib/webappdis.doc"/>
          <Ref id="external-site" type="SQL Injection Training Module" URL="http://download.boulder.ibm.com/ibmdl/pub/software/dw/richmedia/rational/08/appscan_demos/sqlinjection/viewer.swf#recorded_advisory"/>
        </References>
      </Vuln>

      ....
   </Vulnerabilities>
</Results>
```

## AppVulnDB

At the moment the vulnerability DB consists of following tables:

* **scanner**
  Contains scanner related details, e.g. version

* **scan**
  A scan entry contains all summary information about a single scan:

    * *scope* (e.g. Single scan)

    * *target* (e.g. http://example.com)

    * *start/finish date of scan*

    * *scanner ID* (references one entry in the *scanner* table)

    * *number of total vulnerabilities*

    * etc.

* **vulnerability**
   The main table aimed to store all valuable information about a vulnerability:

   * *type* (e.g. XSS, CSRF, Buffer Overflow etc.)

   * *name* (e.g. "XSS in URL bla bla")

   * *description*

   * *error_type* (e.g. "false_positive" or simply empty suggesting that the vulnerability is a real one)

   * *severity* (e.g. High, Medium, Low, Informational)

   * *scanner ID* (reference to *scanner* table)

   * *poc_type_id* (reference to the *poc_type* table)

   * *poc_id*

   * *date added*

   * *comments*

* **poc_type**
  Since one application can communicate through different protocols, different PoC (Proof of Concept) types are needed. Example: If you want to describe a XSS vulnerability you'll need a different level of granularity as a buffer overflow vulnerability. That's why I think different PoC types are needed depending on the protocols the application is able to use. Since the focus of AppVulnMS is more or less on *web* application vulnerabilities, there'll be a default PoC type called *http*. But feel free to add your own types.

* **poc_type_http**
  Handles PoC data for the PoC type *http*:

  * *URL*

  * *method* (e.g. GET, POST, DELETE, HEAD etc.)

  * *request headers*
     This field contains all request headers as a parseable XML structure.

  * *request cookies*
     This field contains all request cookies as a parseable XML structure.

  * *request_data*
     If you have a POST method, then you'll always want to store the POST data as well.

  * *response headers*

  * *response cookies*

  * *response data*
     This field contains the response data from server in plain text.

  * *input type*
     Describes what kind of input type was used to trigger the payload: Cookie, parameter, request header etc.

  * *input name*
     Name of the cookie, parameter, request header etc.

  * *input data*
     Contains payload input data sent to the application.

  * *scanner* (reference to the *scanner* table)

* **reference**
  Contains tool specific references related to one vulnerability.

  * *reference type* (e.g. external site, CVE, CWE. NVD etc.)

  * *name of the reference* (e.g. "Read more about SQLi ... ")

  * *reference ID*
   This is very handy when it comes to public vulnerabilities data bases like CVE, CWE etc. In that case the  reference ID contains the CVE/CWE/[...] ID you can lookup in that particular data base.

  * *URL*

Having those vulnerability details one could easily generate fancy pie charts or diagrams using external libraries like [HighCharts](http://www.highcharts.com/) or [D3](http://d3js.org/). No integration with all this kind of libraries is planed.

## AppVulnMS

The management system itself tries to act as a connecting glue between the scan results, the AppVulnXML files and the AppVulnDB. You could think of some modular framework - although it's not - easy to extend with your new modules. I tried to simplify the basic structure of a single module and give the user the ability to run every module from the command line. Every module should at least have some *--help* option:

```shell

$ python3 bin/AppVulnMS-cli.py m <here comes the module name> --help

....

```

Each module should have a *parent category* like *convert*, *appvulndb*, *report* and so on: Just have a look inside the *modules* directory.

### Available modules

Currently there are following categories and modules available:

* **converter**

  * IBM Rational AppScan 8.x

  * Acunetix 9.x

  * PortSwigger Burp Suite

* **AppVulnDB**

  * SQLite: SQLite implementation of AppVulnDB

# Usage

Feel free to clone this repository. In order to get this work make sure you have following packages installed:

* **python 3.x**

* **python-sqlite**

* **python-lxml**
  Python3 binding for the libxml2 and libxslt libraries

## Basic

The basic run would be:

```shell

$ python3 bin/AppVulnMS-cli.py -h

       _           __   __    _      __  __ ___
      /_\  _ __ _ _\ \ / /  _| |_ _ |  \/  / __|
     / _ \| '_ \ '_ \ V / || | | ' \| |\/| \__ \
    /_/ \_\ .__/ .__/\_/ \_,_|_|_||_|_|  |_|___/
          |_|  |_|

    --------------------------------------------
    Application Vulnerability Management System

usage: AppVulnMS-cli.py [-h] {m} ...

positional arguments:
  {m}         Choose mode
    m         Interact with available modules

optional arguments:
  -h, --help  show this help message and exit

```

As you can at the moment there is only one mode to run *AppVulnMS* with. In the near future an additional mode "db" should be added which is supposed to handle all the DB actions. Right now the DB activities are bundled into one single module.

Now let's have a look at the additional parameters for the (m)odule mode:

```shell

$ python3 bin/AppVulnMS-cli.py m -h

...

usage: AppVulnMS-cli.py m [optional args] [positional args]

------------------------------------------------------------------------
In order to list available modules:
    $ AppVulnMS-cli.py m -l

To interact with specific module:
    $ AppVulnMS-cli.py m <modules name> <modules parameters>

To get modules parameters:
    $ AppVulnMS-cli.py m <modules name> --help
------------------------------------------------------------------------

::: Interact with the available modules.

positional arguments:
  module_name         Modules name
  module_params       Modules parameters

optional arguments:
  -h, --help          show this help message and exit
  -q, --quiet         Keep it quiet
  -v, --verbose       Add verbosity
  -l, --list-modules  List available modules

```

Let's have a look at the available modules:

```shell

$ python3 bin/AppVulnMS-cli.py m -l

...

 For Acunetix scanning results that'd be:

```shell

$ python3 bin/AppVulnMS-cli.py m converter/xml/acunetix -i Acunetix-Export.xml -x data/modules/converter/acunetix/transformation.xslt -o Acunetix-Export-Converted.xml

```

Explanations:

* -i Acunetix-Export.xml
   Specified the input file.

* -x data/modules/[...]/transformation.xslt
   Specifies the XSLT file to use for the transformation. You could of course use your own one.

* -o Acunetix-Export-Converted.xml
   Where to store output.

## Import files to DB

Let's have a look at the implemented module and its options:

```shell
$ python3 bin/AppVulnMS-cli.py m vms/appvulndb/sqlite --help

...

usage: AppVulnMS-cli.py [-h] {init,import} ...

positional arguments:
  {init,import}  Choose mode
    init         Create SQLite AppVulnDB
    import       Import vulns in AppVulnXML format into DB

optional arguments:
  -h, --help     show this help message and exit
```

So first of all we'll have to init/create a DB file:

```shell
$  python3 bin/AppVulnMS-cli.py m vms/appvulndb/sqlite init -f appvulndb.sqlite

...

[INFO]  Succesfully created DB
```

And now we could easily import the previous generated AppVulnXML file into the DB:

```shell
$ python3 bin/AppVulnMS-cli.py m vms/appvulndb/sqlite import -d appvulndb.sqlite -f tmp/acunetix.xml

...

[INFO]  Successfully imported data into DB
```

Now you can verify the results using some SQLite client:

```shell
$ echo "SELECT COUNT(*) FROM vulnerability;SELECT * FROM scanner;" | sqlite3 -interactive appvulndb.sqlite
SQLite version 3.8.2 2013-12-06 23:53:30
Enter ".help" for instructions
Enter SQL statements terminated with a ";"
sqlite> SELECT COUNT(*) FROM vulnerability;SELECT * FROM scanner;
179
1|Acunetix Web Vulnerability Scanner|9|
sqlite>
```

# Disclaimer

This piece of software works as it is. Although its far behind from being only  proof of concept, you could still use it in your company. Since I've code it in my free time any credits, "I LIKE"s whatever would be appreciated. If you have any suggestions about new modules, better core design or simply want to say "Hello", don't hesitate to contact me.

repository: dorneanu/appvulnms

repo_name: dorneanu/appvulnms


text:
---
title: "Go Basics"
order: 3
description: Basic types, string formatting, functions, and methods
tags:
  - tutorial
---
# Go Basics

This section introduces basic types and string formatting. After that, you will dive into functions and methods in Golang.

## Numbers

Integer types are:

```go
int         int8        int16       int32       int64
uint        uint8       uint16      uint32      uint64      uintptr
```

* **int** will be 32 or 64 bits long depending on the OS. However, one can specify precisely how many bits are used with 8, 16, 32, and 64.
* **uint** defines the unsigned integers, which are simply positive integers.
* **uintptr** is an integer ["to hold the bit pattern of any pointer"](https://golang.org/pkg/builtin/#uintptr).

There are two aliases:

* **byte** for **uint8**
* **rune** for **int32**

The types for floating-point arithmetic are `float32` and `float64`. These are only an *approximation* for real numbers because of the [finite precision](https://en.wikipedia.org/wiki/Floating-point_arithmetic#Accuracy_problems).

`complex64` and `complex128` represent complex numbers. These are useful in geospatial coordinate systems and scientific applications, among others. They have "real" and "imaginary" parts that are always `floats`. When the real and imaginary parts are `float32`, the complex number is a `complex64`. Likewise, when the real and imaginary parts are `float64`, the complex number is a `complex128`.

## Strings

In Go, a `string` is a read-only sequence of bytes. Therefore strings are immutable. They're encoded in UTF8 by default.

## Booleans

A `bool` is a special 1-bit integer. It can represent `true` or `false`.

## Type declaration

In Go, the name comes before the type in the declaration. There are two ways to initialize a variable in Go.

First:

```go
var s string = "initial"
```

Second:

```go
s := "initial"
```

You can also use **var** to define variables without initialization:

```go
var (
    a, b int
    s string
    c complex64
)
```

This is equivalent to:

```go
var a, b int
var s string
var c complex64
```

Without initialization, variables have so-called *zero values* which depend on their type.

To define constants, you must use the `const` keyword instead of `var` or `:=` keywords.

<HighlightBox type=note>

Constants can be *typed* or *untyped*. For example, an untyped constant:

```go
const hello = "Hello, World!"
```

The untyped constant means that the type of `hello` is not defined yet.

</HighlightBox>

Because of static types in Go, you have more freedom with untyped constants than with typed ones. Compare the following two examples:

```go
const number = 2
var f float64 = number
```

This first example **works**: the "number" constant is untyped, so the variable "f" can accept it (despite itself being typed `float64`).

```go
const number int = 2
var f float64 = number
```

This second example **does not work**: the "number" constant and the variable "f" are differently typed (`int` and `float64` respectively).

## String formatting

`fmt.Printf` writes to standard output and returns the number of bytes written and the write error. The string formatting is:

```go
%v for a value, which will be converted into a string with default options.
%T for the type of a value
%x for the hex encoding
%d for integer
%f for float, %e and %E for scientific notation
%s for string
%p for the pointer address of the variable
```

Here is an example code:

```go
package main
import "fmt"
func main() {
    a, b := 2, 3
    c := float64(a + b)
    fmt.Printf("%v + %v = %f = %v, stored as %T", a, b, c, c, c)
}
```

<HighlightBox type="tip">

[Test it online](https://go.dev/play/p/7Uvyt1jI-5r).

</HighlightBox>

Compile this to see the output.

## Functions

Functions can take zero or more arguments and can return zero or more arguments. The syntax looks like the following:

```go
func myFunc(v1, v2 type12, v3 type3, v4 type3,....) (ret1 returntype1, ret2 returntype2, ...) {
    return
}
```

If return variable names are given in the declaration, you do not need to explicitly return them.

For example, consider a swap function that switches the values of `x` and `y`:

```go
func swap(x, y string) (string, string) {
    return y, x
}
```

You could also write:

```go
func swap(x, y string) (r1 string, r2 string) {
    r1, r2 = y, x
    return
}
```

Go also offers function closures:

```go
func fibonacci() func() int {
    x, y := 0, 1
    return func() int {
        x, y = y, x + y
        return x
    }
}
```

Let's walk through `func fibonacci()` in more detail:

1. Go supports *anonymous functions*, which you return.
2. You declare `x` and `y` inside `fibonacci()`, and use them inside the *anonymous function*.

<HighlightBox type="note">

`x, y = y, x + y` works because the right side is evaluated fully before the left side.

</HighlightBox>

Now write less idiomatic code to highlight some more aspects:

```go
package main
import "fmt"
func fibonacci() func() int {
    x, y := 0, 1
    return func() int {
        x, y = y, x + y
        return x
    }
}
func loop(n int, f func() int) {
    if n > 0 {
        fmt.Println(f())
        loop(n - 1, f)
    }
}
func main() {
    loop(10, fibonacci())
}
```

<HighlightBox type="tip">

[Test it online](https://go.dev/play/p/Y9LnhYgirCZ).

</HighlightBox>

This will print the first 10 Fibonacci numbers.

<HighlightBox type=note>

Important here is that `fibonacci()` returns a function, and this function is passed into `loop()` as `f`. On subsequent iterations, `loop(n-1,f)` passes this anonymous function into itself recursively.

</HighlightBox>

Here you used the control statement `if` for the first time, to break out of the recursion. Each `fibonacci()`, stored as `f` in `loop`, has its own `x` and `y` - this is called a **closure**. So, what happens if you split the loop into 2?

```go
func main() {
    loop(5, fibonacci())
    loop(5, fibonacci())
}
```

This will give the first 5 Fibonacci numbers twice.

To get the first 10, try the following:

```go
func main() {
    f:= fibonacci()
    loop(5, f)
    loop(5, f)
}
```

Do you see why that works?

## Methods

Methods are defined on types. Go does not have classes. First, define a structure type:

```go
type Rectangle struct {
    a, b int
}
```

You can use this structure for a variable declaration:

```go
r1 := Rectangle{2, 3}
```

You also have access to members through the `.` operator:

```go
fmt.Println(r1.a, r1.b)
```

Now you can declare a method on it:

```go
func (r Rectangle) Area() int {
    return r.a * r.b
}
```

Methods are functions, but they have a so-called *receiver* argument (in the previous example `r Rectangle`). You can use such a method with the `.` operator:

```go
fmt.Println(r1.Area())
```

Do you see how `Area()` became a method of `Rectangle`?

<HighlightBox type=note>

You can declare a method with a receiver only in the same package as the type is defined.

</HighlightBox>

The following example is not declared on a `struct` type:

```go
package main
import "fmt"
type MyNumber int
func (f MyNumber) Abs() MyNumber {
    if f <  0 {
        return -f
    }
    return f
}
func main() {
    f := MyNumber(2)
    fmt.Println(f.Abs())
}
```

<HighlightBox type="tip">

[Test it online](https://go.dev/play/p/6aMJsTmRm2S).

</HighlightBox>

Do you see how `Abs()` became a method of the new type, `MyNumber`?

## Pointer

A function argument is copied into the function. If you want to change the argument, you will require pointers. Pointers are addresses of variables. Look at an example:

```go
func increase(i int) {
    i= i + 1
}
```

The following function will not change `i`:

```go
increase(i int)
```

Instead, try it this way:

```go
package main
import "fmt"
func increase(i int) {
    i = i + 1
}
func main() {
    i := 0
    fmt.Println(i)
    increase(i)
    fmt.Println(i)
}
```

<HighlightBox type="tip">

[Test it online](https://go.dev/play/p/Wkt9tVnlcun).

</HighlightBox>

The previous attempt will get the same result (`0`) twice. Nothing happened to `i`.

Now see what happens if you include a pointer:

```go
package main
import "fmt"
func increase(i *int) {
    *i = *i + 1
}
func main() {
    i := 0
    fmt.Println(i)
    increase(&i)
    fmt.Println(i)
}
```

<HighlightBox type="tip">

[Test it online](https://go.dev/play/p/nCbLaAbRa49).

</HighlightBox>

Now you see that the value of `i` changes. What happened is as follows:

1. `&i` gives the address with type `*int`, which is a pointer and expected by the function `func increase(i *int)`.
2. `*i` is the value the pointer points to.

You can also use pointers in methods to modify the receiver:

```go
package main
import "fmt"
type Rectangle struct {
    a, b int
}
func (r *Rectangle) doubleIt() {
    r.a *= 2
    r.b *= 2
}
func main() {
    r := Rectangle{3, 4}
    fmt.Println(r.a, r.b)
    r.doubleIt()
    fmt.Println(r.a, r.b)
}
```

<HighlightBox type="tip">

[Test it online](https://go.dev/play/p/khjFSJ0hsAE).

</HighlightBox>

<HighlightBox type=note>

`r.b` is the same as `(*r).b` in this context, but it is easier to read.

</HighlightBox>

Pointers are important.

<HighlightBox type="info">

This video provides a simple demonstration of functional programming in Golang, to clarify how functions interact to produce particular results.

<YoutubePlayer videoId="kaUULN0V4Gs"/>

</HighlightBox>

<HighlightBox type="reading">

**Further readings**

* [Go Playground](https://play.golang.org/)
* [Go by Example: Pointers](https://gobyexample.com/pointers)

</HighlightBox>

<HighlightBox type="synopsis">

To summarize, this section has explored:

* The basic **types** (including numbers, strings, booleans, and type declarations), **string formatting**, **functions**, and **methods** employed in Golang.
* Where to access online tests to practice implementing some simple coding examples for yourself.

</HighlightBox>

<!--##

repository: cosmos/sdk-tutorials

gha_language: JavaScript

gha_license_id: NOASSERTION

repo_name: cosmos/sdk-tutorials


text:
## Aerospace Workspace Objects ##

There are two custom UI objects that have been developed specifically for Aerospace applications: a Climb Gauge and Altitude Indicator. These gauges are based off of NI VeriStand's native indicators, but have a different visual look.

For the Aerospace - Climb Gauge, the max and min values for the indicator should be set as desired / appropriate (Ex. -180 to 180 ; -90 to 90, 0 to 180, etc).

### LabVIEW Version ###

LabVIEW 2011

### Quality, Limitations ###

These are two very simple workspace objects that have been used for many years. They should be considered mature and high quality.

### License ###

*This repository and any materials provided by NI therein are provided AS IS.  NI shall have no liability for any direct, indirect, incidental, punitive, special, or consequential damages for your use of the repository or any materials contained therein.*


text:
Description
===========

This is an OpenStack HEAT template to deploy [MongoDB](http://www.mongodb.org/)
to multiple servers in an OpenStack cloud.

This template uses [MongoDB salt-formulas](https://github.com/rcbops/mongodb-formula)
to configure the servers. Three instances will be Mongo configuration servers,
at least two mongo routing (mongos) servers, and we at least 3 mongodb shards in a replica set.
Each replica set created becomes a shard for databases to spread across.

For access to nodes in the MongoDB cluster, a floating ip will be assigned to the
salt-master. Or a new server can be created in the same network as the MongoDB network.
Additionally, mongos server will also be on a separete network so that applications could
access your database cluster without being on the same network.

Any changes to the MongoDB configuration can be done using Salt pillars on the Salt
master. Adding additional mongos nodes can be done via Salt as well.

Requirements
============
* A Heat provider that supports the following:
  * OS::Neutron::Net
  * OS::Neutron::Subnet
  * OS::Neutron::Router
  * OS::Neutron::RouterInterface
  * OS::Neutron::FloatingIP
  * OS::Neutron::FloatingIPAssociation
  * OS::Neutron::Port
  * OS::Heat::SoftwareConfig
  * OS::Heat::SoftwareDeployment
  * OS::Heat::RandomString
  * OS::Heat::ResourceGroup
  * OS::Nova::Server
  * OS::Nova::KeyPair

* A separete application network where mongos node will be connected.
* The flavor should have at least 10GB of disk space.
* Port 27017 should be accesible
* An Ubuntu image (12.04 or newer) preconfigured with heat-cfntools and heat config-script.
Instructions for creating a heat-cfntools enabled image for use with Heat can be
found [here] (http://docs.openstack.org/developer/heat/getting_started/jeos_building.html).

* An OpenStack username, password, and tenant id.
* [python-heatclient](https://github.com/openstack/python-heatclient)
`>= v0.2.12`:

```bash
pip install python-heatclient
```
Using Heat-client
=============
Here is an example of how to deploy this template using the
[python-heatclient](https://github.com/openstack/python-heatclient):

```
heat stack-create mongo-iptables-test -f mongodb_stack.yaml -e env.yaml \
  -P minion-size-mongodb=m1.small -P floating-network-id=<...> \
  -P image=[image_name] -P keyname=[ssh_key] \
  -P apps-network=<...>
```
All the required parameters are as follows:
```

    "minion-count-mongos": How many mongos servers will be required
    "apps-network": Network UUID of application network
    "image": Image name
    "floating-network-id": UUID of the external network. The private network created by this stack will route to this network. Also, any floating ip's needed by this stack will come this network.
    "keyname": Key name for loggin in to instances
    "minion-size-mongodb": Flavor (image size) of mongod servers to be created.
    "minion-count-mongodb": How many mongod servers will be in a cluster.

```

Using Salt
=============
If you wish to make changes to your environment after all the nodes were built,
you may re-run salt states as follows:

```
salt -G 'roles:mongoconfigsrv' state.highstate
salt -G 'roles:mongodb' state.highstate
salt -G 'roles:mongos' state.highstate
salt -G 'roles:mongodb' state.sls mongodb.replication
salt -G 'roles:mongos' state.sls mongodb.mongos.cluster
```
The roles work as follows:
"mongoconfigsrv" is a role for mongo configuration servers.
"mongodb" is a role for mongodb (shards) servers.
"mongos" is a role for mongos (router) servers.

Using Horizon
=============
You can also go to your Horizon Dashboard in your browser and create
the MongoDB stack from under the Orchestration tab.

License
=======
```
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
```

repository: chalupaul/RPC-Heat-MongoDB

repo_name: chalupaul/RPC-Heat-MongoDB


text:
# Taganaut
A library that lets you tag entities by ID. Includes a tag management API and efficient lookup.

Planned features:

* Support for browsers and Node.js.
* Support for standalone tags, tag collections, nested tags and more.
* ~~Efficient search powered by [Lunr.js](https://github.com/olivernn/lunr.js).~~
* Helper functions for better user experience - check for duplicate tags, get action log, undo action.
* In-memory and Sqlite3 database support.

repository: TimboKZ/taganaut

repo_name: TimboKZ/taganaut


text:
> [Go to French version](/fr/Règlements/Décrets,%20ordonnances%20et%20règlements%20statutaires/98/179.md)

# Ontario Hydro Nuclear Facilities Exclusion from Part I of the Canada Labour Code Regulations (Industrial Relations)

**SOR/98-179**

Enabling authorities:
- [CANADA LABOUR CODE](/en/Acts/Revised%20Statutes%20of%20Canada/L/L-2.md)

Date registered: 19 March 1998

----------

His Excellency the Governor General in Council, on the recommendation of the Minister of Labour, pursuant to sections 121.2[a] and 121.5[a] of the [Canada Labour Code](/en/Acts/Revised%20Statutes%20of%20Canada/L/L-2.md), hereby makes the annexed Ontario Hydro Nuclear Facilities Exclusion from Part I of the Canada Labour Code Regulations (Industrial Relations).

a: S.C. 1996, c. 12, s. 1

## Interpretation

**1** The definitions in this section apply in these Regulations.

***employment*** means employment with Ontario Hydro or a person referred to in paragraph (b) of the definition ***nuclear facility***. (*emploi*)

***nuclear facility*** means a nuclear facility in Ontario that is subject to the [Nuclear Safety and Control Act](/en/Acts/Statutes%20of%20Canada/1997/c.%209.md) or any regulations made under that Act and that is
- **(a)** owned and operated by Ontario Hydro; or
- **(b)** owned or operated by a person other than Ontario Hydro if, on the day on which these Regulations come into force or on a day after that day, it is owned and operated by Ontario Hydro. (*installation nucléaire*)

***Labour Relations Act, 1995*** means Schedule A to the Labour Relations and Employment Statute Law Amendment Act, 1995, S.O. 1995, c. 1. (*Loi de 1995 sur les relations de travail*)

***Labour Relations and Employment Statute Law Amendment Act, 1995*** means An Act to restore balance and stability to labour relations and to promote economic prosperity and to make consequential changes to statutes concerning labour relations, S.O. 1995, c.1. (*Loi de 1995 modifiant des lois en ce qui concerne les relations de travail et l’emploi*)
> SOR/2001-519, s. 1.

## Exclusion

**2** Employment on or in connection with a nuclear facility is hereby excluded from the application of Part I of the [Canada Labour Code](/en/Acts/Revised%20Statutes%20of%20Canada/L/L-2.md), except sections 121.2 to 121.5.

## Application of Ontario Acts and Instruments

**3** Subject to section 4, the following Acts and instruments, as amended from time to time, apply, to the extent that they are relevant, in relation to employment on or in connection with a nuclear facility:
- **(a)** the Labour Relations Act, 1995 and the regulations made under it;
- **(b)** the regulations made under the Labour Relations Act, R.S.O. 1990, c. L.2, in so far as they are not inconsistent with the Labour Relations Act, 1995, and until those regulations are repealed or replaced; and
- **(c)** any rules of procedure made by the Ontario Labour Relations Board under section 110 of the Labour Relations Act, 1995.

**4** For the purposes of section 3,
- **(a)** paragraph 1(3)(a) of the Labour Relations Act, 1995 shall be read without reference to the words "architectural" and "land surveying";
- **(b)** the definition "employee" in subsection 1(1) of that Act shall include persons whose duties include the supervision of other employees; and
- **(c)** every reference in section 15, 54 or 136 of that Act to the "Human Rights Code" shall be read as a reference to the "[Canadian Human Rights Act](/en/Acts/Revised%20Statutes%20of%20Canada/H/H-6.md)".

**5** Any proceeding instituted before the Canada Industrial Relations Board before the day on which these Regulations come into force shall be continued as if these Regulations had not been made.
> 1998, c. 26, s. 85.

## Coming into Force

**6** These Regulations come into force on April 1, 1998.

repository: TravisMadill/CanadianLaws

path: /en/Regulations/Statutory Orders and Regulations/98/179.md

repo_name: TravisMadill/CanadianLaws


text:
*Warning*: this is totally incomplete. It only exposes enough for me to extract some statistics I wanted. Be prepared to extend the structs in [`streak.go`](streak.go). I'll accept pull requests!

Example:
-----------------

See [`cmd/streak_example.go`](cmd/streak_example.go) for a complete working example program. Code snippet:

```go
fmt.Println("Pipelines:")
pipelines, err := client.GetPipelines()
if err != nil {
	log.Fatal("Failed to get pipelines: ", err)
}
for _, pipeline := range pipelines {
	fmt.Printf("  %s:\n", pipeline.Name)
	fmt.Printf("  .Key: %s:\n", pipeline.Key)
	fmt.Printf("  .Description: %s:\n\n", pipeline.Description)
}
```

Example output:

	Pipelines:
		Sales / CRM:
		.Key: agxzfm1haWxmb29nYWVyLgsSDE9yZ2FuaXphdGlvbiINbGVjdG9yaXVzLmNvbQwLEghXb3JrZmxvdxjRDww
		.Description: Use this pipeline to manage your sales process across your organization. Create a box for each customer.

repository: evanj/streak

repo_name: evanj/streak


text:
## 0.6.0 (2019-11-24)

- move from jbuilder to dune
- move from topkg to to dune-release
- Lwt 5.0.0 compatibility see #6.

## 0.5.0 (2018-03-25)

- Remove dependency on lwt_log use logs_lwt instead to ensure compatibility with  >= lwt 3.1.0 see #2.
- Remove usage of Lwt.ignore_result see #3.
- Ensure that on node start up if using a remote config then any remote nodes are connected to first before proceeding. Failure
  to connected to any remote node in the config will cause the node to not start.
- Move to using Jbuilder (using topkg jbuilder integration as well) instead of Oasis. The library will now appear as two
  packages on opam : distributed (the concurrent I/O agnostic core) and distributed-lwt the lwt based implementation.
- Moved to using odoc to generate documentation.
- Stopped using oUnit for unit tests.
- Ensure compatibility with lwt >= 4.0.0 (safe semantics) #3.
- Ensure pids are unique across functor invocations.
- Simplify library : remove heartbeat functionality, can be duplicated at application level using receive time-outs and spawning
  corresponding process on remote node.
- Update case/receive API so that calling receive/receive_loop with a list of empty matchers is a compile time error.
  New APIs are `val case : (message_type -> (unit -> 'a t) option) -> 'a matcher_list`, `termination_case : (monitor_reason -> 'a t) -> 'a matcher_list`, `val (|.) : 'a matcher_list -> 'a matcher_list -> 'a matcher_list`, `val receive : ?timeout_duration:float -> 'a matcher_list -> 'a option t`, `val receive_loop : ?timeout_duration:float -> bool matcher_list -> unit t`.
- Added appveyor CI support.
- Added uwt support.

### 0.4.0 (2017-01-18)

- Distributed 0.4.0 is Lwt 3.0.0 compatible see #1.
- Changed the signature of `case` function from `val case : (message_type -> bool) -> (message_type -> 'a t) -> 'a matcher` to `val case : (message_type -> (unit -> 'a t) option) -> 'a matcher` to remove unnecessary asserts.
- Added more unit tests to increase code coverage, integrated with coveralls in build process to get automatic coverage reports.
- bug fixes related to heart beat monitoring.

### 0.3.0 (2016-11-06)

- Removed dependency on batteries to allow compatibility with more versions of ocaml.
- Added receive_loop auxiliary function.
- Added optional monitor remote node function to run_node.
- Modified signature of spawn and run node slightly to take a function (unit -> unit t) instead of unit t.
- Made add_remote_node idempotent when adding a node that already exists.
- Added more examples.
- Added online docs.
- Fix bug related to not cleaning up mailbox in case of exception in user provider message handler or recursive call in user provided handler.
- Fix bug related heart beat processing.

### 0.2.0 (2016-10-25)

- No functional changes over the previous release, just changes related to opam packaging.

### 0.1.0 (2016-10-23)

- Initial release.

repository: essdotteedot/distributed

repo_name: essdotteedot/distributed


text:
# Picky::Vietnamese

Vietnamese substituter for Picky search engine (Remove all diacritics)
NOTE: Lower case all letters for now

## Installation

Add this line to your application's Gemfile:

    gem 'picky-vietnamese'

And then execute:

    $ bundle

Or install it yourself as:

    $ gem install picky-vietnamese

## Usage

Add this to index and/or search config for Vietnamese diacritic support
```ruby
substitutes_characters_with: Picky::Vietnamese::Substituter.new
```

## Contributing

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

repository: duyleekun/picky-vietnamese

repo_name: duyleekun/picky-vietnamese


text:
---
title: "Hitz Cardiovascular Genetics Lab - Home"
layout: homelay
excerpt: "Hitz Cardiovascular Genetics Lab"
sitemap: false
permalink: /
---

The main aim of our group is to understand the genetic origin of structural heart defects and their functional impact on heart and disease development. Our multi-disciplinary group is formed of bioinformaticians, biochemists, molecular biologists and geneticists. In collaboration with national and international partners, we use a variety of techniques, including large-scale DNA-sequencing in individuals and families with structural heart defects to identify disease-associated variation in the human genome. Our goal is to further characterize the functional impact of the identified genes and genetic variation during heart development and disease progression. To further characterize the underlying molecular changes, we apply different techniques, such as transcriptomics and epigenetic profiling on the bulk as well as on the single-cell level in human heart tissue, cellular systems and different transgenic model organism (e.g. Mouse and Zebrafish).

    Previous

    Next

 **We are constantly looking for new students to join our group** [(more info)]({{ site.url }}{{ site.baseurl }}/Jobs)

repository: enriquea/hitzlab

branch_name: refs/heads/gh-pages

gha_language: CSS

repo_name: enriquea/hitzlab


text:
# 1.0.0-beta.7

## Bug Fixes

- Allowing `replace` in the `ddo` checker.

# 1.0.0-beta.6

## Other

- Fixing link in README.md

# 1.0.0-beta.5

## Breaking Changes

- Now, if a checker is not optional, the api-check for it will be evaluated immediately.

## New Features

- Adding `displayName` for the wrapper controller for error messaging and debugging.
- Adding `scopeTypesFunction` to the `ddo` to allow you to specify `warn` or `throw`.

# 1.0.0-beta.4

## New Features

- Adding ability to specify your own instance of an `apiCheck` which allows you to use your own checkers.

## Bug Fixes

- Fixing the prefix for the `scopeTypes` instance of an `apiCheck` to be `angular-scope-types` rather than `api-check-angular`

# 1.0.0-beta.3

## Bug Fixes

- Fixing issue where a new instance of the controller was created and the properties were not bound to that instance.

# 1.0.0-beta.2

## Other

- Adding `.npmignore`

# 1.0.0-beta.1

## Breaking changes

- `scopeTypes` must be a function that accepts the api-check instance and returns the api (perf improvement)
- Changing what is exported to be the `scopeTypesFactory` function.

## New Features

- Adding `disabled` option.
- Improved the API, adding more tests, adding example.

# 1.0.0-beta.0

- Initial release

repository: alianza-dev/angular-scope-types

repo_name: alianza-dev/angular-scope-types


text:
# DockerfileRB

![](https://github.com/gscho/dockerfile-rb/workflows/Rake%20Test/badge.svg)

The intent of this gem is to use a PEG (citrus) to parse a Dockerfile into a hash of Ruby objects.

## Installation

Add this line to your application's Gemfile:

```ruby
gem 'dockerfile-rb'
```

And then execute:

    $ bundle

Or install it yourself as:

    $ gem install dockerfile-rb

## Usage

Example usage:

```
require 'dockerfile-rb'

dockerfile = DockerfileRB.parse(File.read('/path/to/Dockerfile'))
puts dockerfile.inspect
```

## Contributing

Bug reports and pull requests are welcome on GitHub at https://github.com/gscho/dockerfile-rb.

## License

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

repository: gscho/dockerfile-rb

gha_language: Ruby

gha_license_id: MIT

repo_name: gscho/dockerfile-rb


text:
# Galeropsis lateritia (Watling) G. Moreno, Heykoop & Illana, 1989 SPECIES

#### Status
SYNONYM

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

#### Published in
Mycotaxon 36(1): 66 (1989)

#### Original name
Gastrocybe lateritia Watling, 1968

### Remarks
null

repository: mdoering/backbone

path: /life/Fungi/Basidiomycota/Agaricomycetes/Agaricales/Bolbitiaceae/Conocybe/Conocybe deliquescens/ Syn. Galeropsis lateritia/README.md

repo_name: mdoering/backbone


text:
---
layout: page
title: Lean Prover Zulip Chat Archive
permalink: archive/116395maths/72099divltiffltmul.html
---

## [maths](index.html)
### [div_lt_iff_lt_mul](72099divltiffltmul.html)

#### [Kevin Buzzard (Jan 15 2019 at 12:21)](https://leanprover.zulipchat.com/#narrow/stream/116395-maths/topic/div_lt_iff_lt_mul/near/155161891):
I just wanted to get from `a<b*c` to `a/c<b` (on the real  numbers) with a hypothesis that `c>0`. I was surprised to find that although all three of `div_lt_iff_lt_mul`, `lt_mul_of_div_lt` and `div_lt_of_lt_mul` were in Lean, they were in `data.int.basic` :-) and only applied to ints. This should be some general lemma about ordered monoids or some such thing, right? I might start doing what Chris always encourages me to do, which is to make a super-short PR, assuming that this is actually something missing from mathlib. But is it there and I missed it?

#### [Kevin Buzzard (Jan 15 2019 at 12:26)](https://leanprover.zulipchat.com/#narrow/stream/116395-maths/topic/div_lt_iff_lt_mul/near/155162157):
Currently struggling to find ordered monoids :-/ Do we only have ordered additive monoids?

#### [Mario Carneiro (Jan 15 2019 at 12:49)](https://leanprover.zulipchat.com/#narrow/stream/116395-maths/topic/div_lt_iff_lt_mul/near/155163224):
it should be in `ordered_field` somewhere

#### [Mario Carneiro (Jan 15 2019 at 12:49)](https://leanprover.zulipchat.com/#narrow/stream/116395-maths/topic/div_lt_iff_lt_mul/near/155163236):
`div_lt_iff`

#### [Mario Carneiro (Jan 15 2019 at 12:52)](https://leanprover.zulipchat.com/#narrow/stream/116395-maths/topic/div_lt_iff_lt_mul/near/155163385):
lean core has several more long winded unidirectional versions - `div_lt_of_mul_lt_of_pos` , I can't find the reverse direction

#### [Kevin Buzzard (Jan 15 2019 at 13:15)](https://leanprover.zulipchat.com/#narrow/stream/116395-maths/topic/div_lt_iff_lt_mul/near/155164568):
Aah! This is a theorem about multiplication and 0 (which is to do with addition) so indeed it's not about monoids. Maybe it's about ordered semirings? Thanks Mario.

#### [Mario Carneiro (Jan 15 2019 at 13:21)](https://leanprover.zulipchat.com/#narrow/stream/116395-maths/topic/div_lt_iff_lt_mul/near/155164872):
It's a theorem about fields because division

#### [Mario Carneiro (Jan 15 2019 at 13:22)](https://leanprover.zulipchat.com/#narrow/stream/116395-maths/topic/div_lt_iff_lt_mul/near/155164927):
division doesn't exist on monoids or groups

#### [Kevin Buzzard (Jan 15 2019 at 13:22)](https://leanprover.zulipchat.com/#narrow/stream/116395-maths/topic/div_lt_iff_lt_mul/near/155164929):
Oh of course. ok it all makes sense now :-)

#### [Kevin Buzzard (Jan 15 2019 at 13:22)](https://leanprover.zulipchat.com/#narrow/stream/116395-maths/topic/div_lt_iff_lt_mul/near/155164934):
Now I'm just annoyed that I didn't go through this thought process myself before asking.

#### [Kevin Buzzard (Jan 15 2019 at 13:23)](https://leanprover.zulipchat.com/#narrow/stream/116395-maths/topic/div_lt_iff_lt_mul/near/155164954):
Had I taken the trouble to try and formalise what statement I thought was true for ordered monoids I suspect I would have made more progress on my own...

#### [Mario Carneiro (Jan 15 2019 at 13:24)](https://leanprover.zulipchat.com/#narrow/stream/116395-maths/topic/div_lt_iff_lt_mul/near/155165038):
you might wonder why division isn't defined for groups, and this is one of the differences from add_groups, which have subtraction, but there is a difference between the total division on groups and the almost total division on fields and it doesn't seem to be helpful to unify them; lots of theorems overlap with a name conflict, but they are all proven differently


text:
## Implementing UI Behavior with State Machines
UI behavior implementation can be much simplified with state machines.
This repository contains a simplified UML State Chart implementation in
Groovy and a sample base class to apply stateful behavior to typical
detail view and edit pages.

### StateMachine.groovy
A groovy implementation for a simple state machine with these features:
* States and Events are represented by Enums
* Activities and Guards are implemented as Closures
* Transitions can have Guards and Activities
  * they are defined with fromState, targetState, triggerEvent, \[Activity] and \[Guard]
  * if Activity returns a State, the default targetState is overwritten, thus allowing branching Transitions
* States can have Activities onEntry, onExit and onEvent
  * onEvent Activities can also have Guards

### DetailViewBehavior.groovy
An abstract class for detail views controlled by a selection view
like a Tree, TreeTable, List etc. .
The behaviour can be controlled efficiently by a state machine
for detail views. See more details in the GroovyDoc

### Documentation
* [GroovyDoc](https://geobe.github.io/state-machine/docs/index.html)
* [State Machine Tutorial](https://www.georgbeier.de/docs-and-howtos/ui-state-machine/)

repository: geobe/state-machine

repo_name: geobe/state-machine


text:
## Overview
Flint Service includes Discovery Service, Rest Service and WebSocket Service. DIAL protocol is implemented in Flint to provide the 2nd screen application also called sender application to discover and launch the 1st screen application also called receiver application. The sender application is playing the role of DIAL client, and the Discovery Service and Rest Service are playing the role of DIAL server.

## Flint Discovery Service
Flint Discovery Service supports SSDP protocol which is defined in DIAL protocol, and also implements mDNS discovery protocol.
* SSDP: Details for SSDP please refer to Reference [1] Section 5.
* mDNS: mDNS will respond to the request with search name as `openflint` and return the URL address and port of DIAL Server. Details for mDNS please refer to Reference [2].

## Flint Rest Service
Flint Rest Service provide interfaces for a sender application to query, launch and stop a receiver application, which is defined in DIAL protocol spec, and Flint Rest Service provides more and flexible extension interfaces atop the standard DIAL protocol for sender application and receiver application.

![Flint Architecture Chart](http://openflint.github.io/assets/images/flint-protocol-overview.png)

### API
* `/apps/<appid>`: Standard DIAL HTTP interface; requested by the sender application
* `/apps/<appid>/dial_data`: Standard DIAL HTTP Interface for receiver application to send additional data to DIAL server; requested by receiver application
* `/apps/~<appid>`: Extension HTTP interface; requested by the sender application
* `/system/control`: Extension HTTP interface for system control, currently only support volume control; requested the sender application
* `/receiver/~<appid>`: Extension WebSocket interface for receiver application to establish Message Channel to DIAL server; requested by receiver application
> Flint Rest Service will check `appid` from URL and apply different treatment:
    - `~<appid>`: Follow the extension of DIAL protocol in Flint Rest Service, all **extension** related descriptions in following paragraphs are only target to `~<appid>` applications.
    - `<appid>`: Follow the standard DIAL protocol and register application configuration information to DIAL server.

### Get Receiver Application Status
* HTTP `GET` Request
    * Sender application sends `GET` request to `/apps/<appid>` or `/apps/~<appid>`
    * Details for this part please refer to References [1] Section 6.1
* HTTP Response
    * Rest Service sends response to sender application for the status of receiver application
    * Details for this part please refer to References [1] Section 6.1
* Extension
    * Currently Flint Reset service not support receiver application in `installable` status
    * Flint adds a `starting` status. If HTTP status code return is 200, it means that the receiver application is in `starting` phase, then sender application should repeat a query cycle (cycle time is 10 seconds) and wait for the receiver application to launch. Sender application should judge that receiver application launch failed if the status has not been changed to `running` status after several cycles.
    * If sender application wants to keep the connection with Rest Service after application launched, sender application needs to send `ping`/`pong` message. Because Flint Rest Service is based on HTTP stateless connection, sender application needs to send `GET` request to Flint service regularly (1-5 seconds) and fill Authorization field in HTTP request header, the value should be acquired from the Rest Service response to the HTTP 'POST' request of launching receiver application described in next section.

### Launching Receiver Application
* HTTP `POST` request
    * Sender application sends `POST` request to Rest Service to launch receiver application
    * Details for this part please refer to References [1] Section 6.2
* HTTP response
    * Details for this part please refer to References [1] Section 6.2
* Extension
    * POST request will send 3 different commands: launch, relaunch and join.
        * `launch`: If the receiver application status is `stopped`, the receiver application can be launched with this command, and the `POST` message body should contain the information about the receiver application to be launched
        * `relaunch`: If the receiver application status is `running` or `starting`, the receiver application can be stopped and then relaunched with this command, and message body should contain the information of the receiver application to be launched. The result of application relaunch depends on whether the implementation and configuration of each application support to relaunch.
        * `join`: If the receiver application status is `running` or `starting`, the sender application will send `join` command to add itself to the session management of Rest Service, and will affect the running or starting receiver application.
    * Response will return some information related to session management.
        * token: Flint service creates a session for the sender application who send request, and other request from the sender application needs contain the token. In order to guarantee the token is always valid, the sender application need send `GET` request with the token to Flint Service regularly.
        * interval:  It defines the interval between the `GET` request sent from sender application, unit is millisecond.
    * Please refer to [Annex B] for message format definition.

### Stop Receiver Application
* request: Please refer to References [1] Section 6.4
* response: Please refer to References [1] Section 6.4
* extension: Flint Rest Service provides 2 interfaces to handle DELTE message:
    * `/apps/~<appId>`: http request header need contain token and request to disconnect the session with Flint Service. Since that, Flint service will not manage the session related to this token.
    * `/apps/~<appId>/<instance>`: http request header need contain token and request to stop this application. If the session related to this token is valid, the application can be stopped.
    * Message format can refer to [Annex C]

* System Control Interface
Flint Rest Service provides this interface to support sender application can do system control, now supports volume adjustment. Message format can refer to [Annex D]

## Standard Handle POST request from receiver application
* Details for the `POST` request please refer to Reference [1] Section 6.3.1

### Extension: Communication with receiver application

Flint Service communicates with receiver application via WebSocket. Rest Service provides a WebSocket serve for receiver application to connect this WebSocket server as a client. Please refer to [Annex E] for the specified message format.

* `register`: After receiver application connects to the WebSocket server, it need send `register` message to Flint Service to indicate the receiver application launched successfully.
* `registerok`: After Flint Service gets `register` message, it will return `registerok` to notify receiver application that register is successful and return some information of Flint Service to the receiver application.
* `startHeartbeat`: After register process is completed, Flint Service will notify the receiver application to start heart beat. Then Flint Service will send `ping` message to receiver application regularly and receiver application need send response `pong` message. If receiver application need monitor the heart beat status initiatively, it can send `ping` message to Flint Service and Flint Service will send `pong` message accordingly.
* `senderconnected`: After a sender application creates a session via `POST` request, Flint Service will send a `senderconnected` message to receiver application and transfer the sender application’s token together. Receiver application can manage the sender application session Id through this message.
* `senderdisconnected`: After sender application’s session is disconnected, Flint service will send a `senderdisconnected` message to receiver application and transfer the sender application’s token together. Receiver application can manage the sender application session Id through this message.
* `additionaldata`:
* `unregister`: When receiver application can send `unregister` message to disconnect the WebSocket connection.

======

## Build-in WebSocket Communication Facility

Flint Service provides WebSocket Server as internal communication facility to sender and receiver. Application developers can use it conveniently to transfer data between the receiver application and sender application.

* WebSocket Server
    * The receiver application can create one or more communication channels via WebSocket Server with Sender application.
    * After all these communication channels are created by the receiver application successfully, these information will be sent to Flint Service via `additionaldata` and Flint service then forwards to sender application. After sender application receives the channel address and add its token, it could communicate with the receiver application.
    * Multiple sender applications can connect to one communication channel in the same time.
    * Please refer to [Annex F] for Websocket Server API.

## Reference
1. DIAL: (http://www.dial-multiscreen.org/dial-protocol-specification/DIAL-2ndScreenProtocol-1.7.pdf)

2. MDNS: (http://www.multicastdns.org)

3. DIAL Registry: (http://www.dial-multiscreen.org/dial-registry/namespace-database)

## Annex
### **A. appid**
* `~<appid>`：Developers need add ~ as prefix for their applicaitons if they need the support from Flint Service
* `<appid>`：Please refer to References [3]

### **B. Launch Receiver Application**
* request

```
POST http://<IP_ADDRESS>:9431/apps/~appid
Content-Type: application/json
{
    "type":"launch/relaunch/join",
    "app_info":{
        "url":"http://www.youtube.com",
        "useIpc":true or false, # whether sender and receiver apps use WebSocket Server to communicate
        "maxInactive":n # millisecond, receiver app alive time, only work when useIpc is false,  set -1 if keep receiver app alive
    }
}
```

* response
```
# If Receiver app launched by request, will send:
201 CREATE
Content-Type: application/json

{
    "token":"EE2287DB-D10D-FECD-667B-8342AD095C33"
    "interval":3*1000 #ping/pong interval
}
```

```
# If receiver app already running, will send:
200 OK

Content-Type: application/json
{
    "token":"EE2287DB-D10D-FECD-667B-8342AD095C33"
    "interval":3*1000 #ping/pong interval
}
```

### **C. Stop Receiver Application**
* request

```
DELETE http://ip:port/apps/~appid
Authorization: EE2287DB-D10D-FECD-667B-8342AD095C33
```

Or

```
DELETE http://ip:port/apps/~appid/{instance}
Authorization: EE2287DB-D10D-FECD-667B-8342AD095C33
```

* response

```
#If successful, response:
200 OK
```

```
# If failed, If reason is token out of date, response:
400 Bad Request

# If reason is appid invalid, response:
404 Not Found
```

### **D. system control**
* request

```
POST http://ip:port/system/control
Content-Type: application/json

{
    "type":"GET_VOLUME | SET_VOLUME | GET_MUTED | SET_MUTED",
    "level": 0.5, # Available if if type is SET_VOLUME
    "muted": false # Available if type is SET_MUTED
}
```

* response

```
200 OK
Content-Type: application/json

{
    "success": true, # boolean
     "type":"GET_VOLUME | SET_VOLUME | GET_MUTED | SET_MUTED",
     "level": 0.5, #float, volume
     "muted": false #boolean
}
```

### **E. Receiver application register to Flint Service**

* WebSocket URL: **`ws://<IP_ADDRESS>:9431/receiver/~<appid>`**

* `register`：Receiver -> Flint service

```
    {
        "type":"register",
        "appid":"~appid"
    }
```

* `unregister`: Receiver -> Flint Service

```
    {
        "type":"unregister",
        "appid":"~appid"
    }
```

* `additionaldata`：Receiver -> Flint Service

```
    {
        "type":"additionaldata",
        "appid":"~appid",
        "additionaldata":{
            "key1":"value1"
        }
    }
```

* `startHeartbeat`：Flint Service -> Receiver

```
    {
        "type":"startHeartbeat",
        "appid":"~appid",
        "interval":3*1000 # ping/pong interval
    }
```

* `senderconnected`：Flit Service -> Receiver

```
    {
        "type":"senderconnected",
        "appid":"~appid",
        "token":"EE2287DB-D10D-FECD-667B-8342AD095C33"
    }
```

* `senderdisconnected`：Flint Service -> Receiver

```
    {
        "type":"senderdisconnected",
        "appid":"~appid",
        "token":"EE2287DB-D10D-FECD-667B-8342AD095C33"
    }
```

* `ping/pong`：Flint Service <-> Receiver

```
    {
        "type":"heartbeat",
        "appid":"~appid",
        "heartbeat":"ping/pong"
    }
```

### **F. WebSocket Server API**
* Receiver application create WebSocket message channel, URL: `ws://localhost:9439`

```
var ws_A = new WebSocket("ws://<IP_ADDRESS>:9439/channels/" + channelNameA);
ws_A.onmessage = function (event) {
    var msg = JSON.parse(event.data);
    // Handle new sender connected event
    if (msg.type === 'senderConnected') {
        console.log('senderId:', msg.senderId);
    // Handle sender lost event
    } else if (msg.type === 'senderDisconnected') {
        console.log('senderId:', msg.senderId);
    // Handle other message
    } else if (msg.type === 'message') {
        console.log('senderId:', msg.senderId);
        console.log('data:', msg.data);
    }
};
ws_A.send(
    {
        "senderId": "xxx", # Indicate which sender to send, if senderId is *:*, mean broadcast to senders
        "data": "string" # string
    }
);

var ws_B = new WebSocket("ws://<IP_ADDRESS>:9439/channels/" + channelNameB); # multiple message channel is allowed
```

* Receiver Application send addtionaldata to Flint Service

```
ws.send(
    {
        "channelNameA": "ws://<IP_ADDRESS>:9439/channels/channelNameA",
        "channelNameB": "ws://<IP_ADDRESS>:9439/channels/channelNameB"
    }
);
```

* Flint Service send additionaldata to sender application

```
    <additionaldata>
        <channelNameA>ws://<IP_ADDRESS>:9439/channels/channelNameA</channelNameA>
        <channelNameB>ws://<IP_ADDRESS>:9439/channels/channelNameB</channelNameB>
    </additionaldata>
```

* Sender Connect to Message Channel

When sender application get the URL of Message Channel from additionaldata, should connect them with a unique token:

```
    Receive URL: ws://<IP_ADDRESS>:9439/channels/channelName
    Connect URL: ws://<IP_ADDRESS>:9439/channels/channelName/senders/senderToken
```

Sender application should connect to the Connect URL to establish connection with Receiver application.

repository: jsli/flingd-coffee

repo_name: jsli/flingd-coffee


text:
# gatsby-source-openapi

A gatsby source plugin that parses an [OpenAPI 3 specification](http://spec.openapis.org/oas/v3.0.3) into gatsby GraphQL nodes.

Schemas are stored as JSON strings and must be dereferenced at runtime.

## License

MIT License

Copyright (c) 2020 Richard Willis

repository: badsyntax/gatsby-openapi

gha_language: TypeScript

repo_name: badsyntax/gatsby-openapi


text:
This folder contains four files

- `repeater.js`: a function exported for use in other files (logic)
- `test.js`: a file containing tests for the function in `repeater.js`
- `index.js`: a simple Command Line Interface for using the function in `listify.js` (handler)
- `index-demo.js`: a file you can run to see the expected behavior of your `index.js`

---

you will need to write `index.js`, correctly processing the user input before passing it to the `repeater` function and logging the result.

---

_challenge: what would you pass in the terminal to log 6 empty lines?_

repository: miroslavveljanoski/web-apps

repo_name: miroslavveljanoski/web-apps


text:
Testing from home
=================

Setting up networks on a single computer
----------------------------------------

The UDP-broadcast-only network modules (Go, D, Rust) are designed to be able to be used on a single machine, with multiple programs listening to the same port. Erlang and Elixir users using nodes should have no problems either.

You are allowed to manually input whatever you need for network configuration, such as manually naming the peers' names, ports, or whatever else in order to avoid needing to write general peer discovery.

This is not a good time to be having network problems, so if you have any problems ask for help as soon as possible.

Testing network problems
------------------------

### Disconnects

Testing resilience to disconnects is hard when there is no network cable to unplug. Instead, we have to use whatever operating system features we have to emulate network problems. DIfferent systems have different limitations:

 - Linux lets you block outgoing communication for programs run as part of a group, but not incoming - which is like disconnecting one half of the network cable.
 - Windows let's you block all network communication (in and out) for a single program (effectively disconnecting that program), but only for network activity that isn't on localhost or loopback - which is what all our network communication will be.

This means that creating test scenarios for disconnecting one of three elevators is not easily possible using just the system features. However, we can block *all* communication that isn't to and from the simulators, which lets us test what happens when all the elevators are (simultaneously) disconnected. Because of this, we recommend **only using two elevators**, as testing with three won't test anything different than testing with just two.

 - Linux: use iptables as you would for packet loss, but just drop everything:
    ```
    sudo iptables -A INPUT -p tcp --dport 15657 -j ACCEPT
    sudo iptables -A INPUT -p tcp --sport 15657 -j ACCEPT
    # +more for other simulator ports you use
    sudo iptables -A INPUT -j DROP
    ```
   Then run `sudo iptables -F` to flush the filter chain when you are done.
 - Windows: use a program called [clumsy](http://jagt.github.io/clumsy/), and set the rule to
    ```
    udp or (tcp.DstPort != sim1 and tcp.SrcPort != sim1 and tcp.DstPort != sim2 and tcp.SrcPort != sim2)
    ```
    where `sim1` and `sim2` are the ports used by the simulators, then enable the `Drop` function for both inbound and outbound with a chance of 100%.

### Packet loss

For testing packet loss, do the same thing, but change the probability to 20%:

 - Linux: Change the last line to `sudo iptables -A INPUT -m statistic --mode random --probability 0.2 -j DROP`.
 - Windows: Literally just change the drop chance to 20% in the thing with the number.

### If you insist on testing three

While it is both not required and not recommended to test network problems with three elevators, here are two possible ways of doing it - if you insist:

 - Add disconnect (and packet loss, if you want) to your own networking code. Since the stop button and obstruction switch are not in use, you could use those to trigger the network-problem effects.
 - Run one of the elevators in a virtual machine (like VirtualBox), then disconnect all networking to the virtual machine. Chances are that your virtual machine will be some other operating system than the host machine, so this is not always possible. The most common combination of a Windows host with some Linux VM running on VirtualBox seems to work nicely, with no extra configuration needed.

### Local communication with sockets

If your program needs to perform some internal communication using sockets, then you will have to add exceptions to the rules for packet loss and disconnect testing. Ask for help if you need it.

Elevator hardware
-----------------

One of the tests involves disconnecting the power to the elevator motor. You can simulate this by pressing the `[key_moveStop]` key in the simulator window, which by default is bound to `8` (numpad or number row, both work). If your software is constantly, consistently, or confusingly sending commands to move the elevator, you can still force the elevator to get stuck by continuously spamming the moveStop key.

Specification clarifications
============================

As is tradition, there are some inevitable problems with the specification...

 - Cab order redundancy:
   - In order to open up more valid solutions than saving cab orders to disk, it should be possible to store the backup of cab requests on the other nodes, by using the assumption that *at least one other elevator is working normally*. However, the current specification requires that cab requests be served when the elevator is disconnected (in order to let people off), which means that no service guarantee can be delivered if the backup copy of that cab order must be stored on an unreachable node, meaning that no light should be turned on.
     In this case, the correct solution would be to service the request without turning on the light.

     Double-however, another part of the specification says that you can assume that there are no two simultaneous errors, which means that once a node has lost connection to the network (making it unable to backup the cab request), it cannot also crash (guaranteeing that it will serve the un-backed-up cab request).
     Because of this, servicing the request *and also turning on the light* is also a valid solution.


text:
---
layout: post
title: Earn 50rs per reffer flipkart unlimited trick
date: '2015-07-07T10:25:00.000+05:30'
author: pawneshwer
categories:
- earn-money
tags:
- Earn Money
description: Earn 50rs by reffer from flipkart, earn unlimited from flipkart and shop from flipkart,Limited trick avail this earning trick,July 2015 earning trick 50 rs
keywords: Earn 50rs by reffer from flipkart, earn unlimited from flipkart and shop from flipkart,Limited trick avail this earning trick,July 2015 earning trick 50 rs
modified_time: '2016-02-20T06:52:39.920+05:30'
thumbnail: http://3.bp.blogspot.com/-X8ver9z5vRY/VZtZ4Rx-IoI/AAAAAAAAGzA/DZqEIhI0c4Q/s72-c/Earn-50rs-per-reffer-flipkart-unlimited-trick-logo.jpg
blogger_id: tag:blogger.com,1999:blog-1967791069058877982.post-4584790310438682344
blogger_orig_url: http://www.edablogs.com/2015/07/earn-50rs-per-reffer-flipkart-unlimited-trick.html
redirect_from:
- /2015/07/earn-50rs-per-reffer-flipkart-unlimited-trick.html
---

{% include JB/setup %}

## Earn 50rs per reffer flipkart unlimited trick

Here is another **_earning trick_** from **flipkart**. Reffer your friends and **earn 50** rs per reffer. This 50rs will be added to your wallet and you can redeem that [voucher](http://en.wikipedia.org/wiki/Voucher "Voucher") at time of order. Means when you order something from flipkart you can use that voucher for discount. So **invite unlimited** friends and earn more as possible.

[![Earn 50rs per reffer flipkart unlimited trick](http://3.bp.blogspot.com/-X8ver9z5vRY/VZtZ4Rx-IoI/AAAAAAAAGzA/DZqEIhI0c4Q/s1600/Earn-50rs-per-reffer-flipkart-unlimited-trick-logo.jpg "Earn 50rs per reffer flipkart unlimited trick")](http://3.bp.blogspot.com/-X8ver9z5vRY/VZtZ4Rx-IoI/AAAAAAAAGzA/DZqEIhI0c4Q/s1600/Earn-50rs-per-reffer-flipkart-unlimited-trick-logo.jpg)

### We will post Flipkart Loot trick soon to earn unlimited from 1 mobile.

## How to earn Money:

1.  If you already installed **Flipkart app** then remove it from your mobile.
2.  Now download new flipkart app from **download** button below.

[Download Now](https://dl.flipkart.com/dl/referral?code=dog5uu)

1.  Open this link in **browser** then open will come, goto app and **Playstore** will open, ad install from there. (* Don't open in Opera mini)
2.  After installing **Flipkart app** signup with new **mobile number** and **confirm your Email** id also.
3.  Now you will get message that you have **earned 50rs** voucher.

[![Earn 50rs per reffer flipkart unlimited trick](http://1.bp.blogspot.com/-WiOrfEAVGuI/VZtZ6P0lPeI/AAAAAAAAGzQ/6KcGKwNgATQ/s320/Earn-50rs-per-reffer-flipkart-unlimited-trick.jpg "Earn 50rs per reffer flipkart unlimited trick")](http://1.bp.blogspot.com/-WiOrfEAVGuI/VZtZ6P0lPeI/AAAAAAAAGzQ/6KcGKwNgATQ/s1600/Earn-50rs-per-reffer-flipkart-unlimited-trick.jpg)

1.  To earn more open flipkart app, goto options and select "**Invite and earn**" option.

[![Earn 50rs per reffer flipkart unlimited trick](http://1.bp.blogspot.com/-J0BnakqcGQg/VZtZ6hg4bPI/AAAAAAAAGzU/uYGh12yC_B4/s320/Earn-50rs-per-reffer-flipkart-unlimited-trick2.jpg "Earn 50rs per reffer flipkart unlimited trick")](http://1.bp.blogspot.com/-J0BnakqcGQg/VZtZ6hg4bPI/AAAAAAAAGzU/uYGh12yC_B4/s1600/Earn-50rs-per-reffer-flipkart-unlimited-trick2.jpg)

1.  Now click on "**_Invite Friends_**" button.
2.  And share your reffer link to your friends on **Whatsapp,facebook** and etc.
3.  When your friends Install and Signup you will **receive 50rs** each.

### I am testing it on Virtual device to get unlimited trick on same mobile.


text:
## `zdesk gather badges icon-upload create`

/gather/badges/icon_uploads

### Synopsis

    zdesk gather badges icon-upload create [ ... ]

### REST endpoint

    POST https://{HOSTNAME}/api/v2/gather/badges/icon_uploads

### Description

https://developer.zendesk.com/api-reference/help_center/help-center-api/badges#request-badge-icon-upload-url

repository: fprimex/zdesk-cli

repo_name: fprimex/zdesk-cli


text:
# `fluid.schema.modelComponent`

This component extends the concept of a [model
component](https://docs.fluidproject.org/infusion/development/tutorial-gettingStartedWithInfusion/ModelComponents.html)
to add validation of model material whenever changes occur.  A schema-validated modelComponent is by definition also a
[schema validated component](./schemaValidatedComponent.md), although it only requires you to follow the underlying
syntax for standard framework features like invokers, et cetera.

## Component Options

In addition to the options supported by the underlying [`fluid.schema.component`](schemaValidatedComponent.md) grade,
this component supports the following key option:

| Option        | Type     | Description |
| ------------- | -------- | ----------- |
| `modelSchema` | `Object` | One or more rules that describe what model material is valid, defined using [FSS](fss.md). The merged `modelSchema` option will be used to validate the model whenever it changes. |

For examples of how merging can be used to extend an FSS schema, see the [schema validated component docs](schemaValidatedComponent.md).

## The model validation cycle.

This grade listens for model changes.  Whenever the model changes, the model is validated against the FSS schema in
`options.modelSchema`, and the validation results are saved to the `validationResults` model variable.  To avoid
triggering one or more additional validation passes, this grade ignores changes made to the `validationResults` model
variable itself.

If you wish to take action after validation completes, you will need to define a modelListener that listens to changes
to the `validationResults` model variable.  For the format of validation errors, see the [validator
documentation](validator.md).  For an example of a grade that listens for and makes use of validation results as they
appear, see the tests for the error binder included in this package.

repository: fluid-project/fluid-json-schema

repo_name: fluid-project/fluid-json-schema


text:
# running-app
Ruby on Rails Running App that allows you to track runs with information about
the route or trail, such as distance, elevation, and a description. Users can
also log their runs to keep track of how often they run, times they have spent
on trails, and their moods/how they felt, as well as other information.

## Running Locally

To get the backend working, first install dependencies, then create the database,
then start up the server.

#### Install Dependencies
Matching game uses Ruby version 2.6.1, to install its dependencies run `bundle install` from the root.

#### Set up database
From the root run:

```
cd matching-game-backend
rails db:create
rails db:migrate
```

#### Start up Server
`rails s`

You will be able to access the app via http://localhost:3000/ by default, but
this can be configured) using `-p` and `-b` switches.

## Future Improvements
* Make it pretty (add CSS and photos)
* Build out test suite
* Add to the stats page using class scope methods
* Add to option to add upload photos
* Potentially other OmniAuth options (currently using only Google)

repository: trishogen/running-app

repo_name: trishogen/running-app


text:
## Whenever

Whenever is a Ruby gem that provides a clear syntax for writing and deploying cron jobs.

    $ cd my_project
    $ wheneverize .

This will create an initial `config/schedule.rb` file for you.

    every 3.hours do
      runner "MyModel.some_process"
      rake "my:rake:task"
      command "/usr/bin/my_great_command"
    end

    every 1.day, :at => '4:30 am' do
      runner 'MyModel.task_to_run_at_four_thirty_in_the_morning'
    end

    every :hour do
      runner "SomeModel/ladeeda"
    end

    every '0 0 27-31' do
      command "echo 'you can use raw cron syntax too'"
    end

    every :day, at: => '12:20am', :roles => [:app] do
      rake "app_server:task"
    end

license: Unlicense

repository: daryllxd/lifelong-learning

gha_language: Elixir

gha_license_id: Unlicense

repo_name: daryllxd/lifelong-learning


text:
# Introduction to Python

## Lesson One: Introduction

- clone the repo:

```bash
$ git clone https://github.com/tmax818/vs_python.git
```
- open the integrated terminal `Ctrl+Shift+~`


text:
![Licensed under the MIT License](https://img.shields.io/github/license/teo-tsirpanis/farkle.svg)
[![NuGet](https://img.shields.io/nuget/v/Farkle.svg)](https://nuget.org/packages/Farkle)
[![CI](https://github.com/teo-tsirpanis/Farkle/actions/workflows/ci.yml/badge.svg)](https://github.com/teo-tsirpanis/Farkle/actions/workflows/ci.yml)
[![CII Best Practices](https://bestpractices.coreinfrastructure.org/projects/5005/badge)](https://bestpractices.coreinfrastructure.org/projects/5005)
[![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/teo-tsirpanis/Farkle/badge)](https://api.securityscorecards.dev/projects/github.com/teo-tsirpanis/Farkle)
[![Discord Server](https://badgen.net/discord/members/mYzXu5Zt8J)](https://discord.gg/mYzXu5Zt8J)

# Farkle

<!--"Modern" is a marketing catchphrase, but keep in mind that FsLexYacc is definitely not "modern"-->
Farkle is a modern and easy-to-use parser library for F# and C#, that creates [LALR parsers][lalr] from composable [parser combinator][combinator]-like objects.

## Documentation

* [Quick Start: Creating a calculator](https://teo-tsirpanis.github.io/Farkle/quickstart.html)
* [Using Farkle with C#](https://teo-tsirpanis.github.io/Farkle/csharp.html)
* [API Reference](https://teo-tsirpanis.github.io/Farkle/reference/index.html)

## Maintainer(s)

- [@teo-tsirpanis](https://github.com/teo-tsirpanis)

[lalr]:https://en.wikipedia.org/wiki/LALR_parser
[combinator]:https://en.wikipedia.org/wiki/Parser_combinator
[gold]:http://goldparser.org/

repository: teo-tsirpanis/Farkle

branch_name: refs/heads/mainstream

gha_language: F#

repo_name: teo-tsirpanis/Farkle


text:
# Ticktok.io website

This is the website source, you can visit it here: https://ticktok.io

## Run locally
With Ruby 2.x installed
```
bundle install
bundle exec jekyll serve
```