text:
# ember-app-explorer
![Build and Deploy](https://github.com/rajasegar/eax/workflows/Build%20and%20Deploy/badge.svg)
[![Coverage Status](https://coveralls.io/repos/github/rajasegar/eax/badge.svg?branch=master)](https://coveralls.io/github/rajasegar/eax?branch=master)
[![semantic-release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg)](https://github.com/semantic-release/semantic-release)
[![npm version](http://img.shields.io/npm/v/ember-app-explorer.svg?style=flat)](https://npmjs.org/package/ember-app-explorer "View this project on npm")

A CLI tool to explore your Ember.js app folders to make better decisions for your
code maintainability and modularity.

## Features
- View your ember app details like ember-cli version, no of dependencies and dev dependencies, supported Node.js versions, the package manager used and so on.
- View File size composition of your `app/` folder
- Find the file size of your components, routes, etc in decreasing order
- You can export the file size data to a CSV format for deeper analysis
- Find the largest and heavy components and their dependencies with other entities
- Find where your components, services are used in the app
- Find the asset composition of your builds like percentage of JS,CSS and images
- View the compression statistics for your build assets like Gzip and Brotli and export them as CSV

## Install
```
npm i -g ember-app-explorer

```

You can also use npx like:
```
npx ember-app-explorer
```

## Usage

Using current folder.
```
eax
```

Specifying a path
```
eax ~/Users/user/code/my-ember-app
```

## Screenshots
![screenshot](screenshots/home.png)

![build](screenshots/build.png)

![components](screenshots/components.png)

## Help
List of Keyboard navigation shortcuts:
```
    ['Next Page', 'Right Arrow'],
    ['Prev Page', 'Left Arrow'],
    ['Up', 'Up Arrow / k'],
    ['Down', 'Down Arrow / j'],
    ['Select', 'Enter / l'],
    ['Quit', 'q / Esc / Ctrl-c'],
    ['Help', '?', '!'],
    ['Go to Home', '0'],
    ['Go to Build Stats', 'b'],
    ['Go to Components', 'c'],
    ['Go to Adapters', 'a'],
    ['Go to Controllers', 'o'],
    ['Go to File Sizes', 'f'],
    ['Go to Helpers', 'h'],
    ['Go to Mixins', 'x'],
    ['Go to Models', 'm'],
    ['Go to Routes', 'r'],
    ['Go to Services', 's'],
    ['Go to Utils', 'u'],
    ['Search', '/'],
    ['Export to CSV', 'e']
    ['To Move around in a page', 'Tab']
    ['Go to the beginning of any list', 'gg'],
    ['Go to the end of any list', 'G']
```

## FAQs

### How do I quit this thing?
You can press `q`, or `Esc` or `C-c` to quit the program at any time.

### How can I see the keyboard shortcuts for navigating?
Press `?` or `!` to see the keyboard navigation shortcuts page.
There is an [issue](https://github.com/rajasegar/eax/issues/7) with `?` when you open the help page from a page containing lists, hence in those cases you can use the `!` for help.

### How can I quickly navigate to home page screen?
Press `0` to go to the home page.

### How do I navigate between different pages of the cli?
You can use the arrow keys to navigate between pages, `Left Arrow` to previous screen
and `Right Arrow` to next screen.

### How can I search for items in the list?
Press `/` to search in any list. A popup dialog will appear to enter the search term,
if the search functionality is enabled for that list where you have the focus.
The search term is fuzzy which means you can search for any part of the name and you
can also use regular expression search.

### Does it support vi/vim navigation keys in the lists?
Yes. You can use `j`,`k`,`gg`,`G`,`l` and `/`

### Can I export the data from the lists?
Yes. You can press 'e' to export your data from the lists in CSV format.
It will prompt for a file name. But at present only the data from the `File Sizes` and `Build Assets` pages
can be exported. We are working on to add export feature to more lists.

repository: rajasegar/eax

repo_name: rajasegar/eax


text:
LuckyMe
=======

Check your luck

LuckyMe is a python game application trying your luck.
This games is based on generating random numbers.
SO all you get is your luck.

The game starts with asking for a luck index.
Luck index is how lucky you feel today.

For example if give 1 as your lucky index,
then you will be asked to give a number between 0 and 9 inclusive
and four random numbers are generated.
If any of the four numbers is your number, then you win else you lose.

For making this process more transparent, we also show the random list generated.

license: MIT

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
ICA-issued Long-Term Visit Pass (LTVP) holders and short-term visitors who belong to the categories below may apply for entry approval via the Singapore Citizen/Permanent Resident (PR) Familial Ties Lane:

- An immediate family member or relative of a Singapore Citizen or a Singapore PR;1
- A spouse-to-be of a Singapore Citizen or a Singapore PR;
- PR and ICA-LTVP IPA holders seeking to complete formalities for their long-term immigration facilities; or
- A non-resident who has exceptional reasons for seeking entry to Singapore (e.g. death of a family member in Singapore).

To apply for entry approval under this lane, please click the link here.

### Border and Health Control Measures

Please ensure you take note of the border and health control measures for entering Singapore found [here](/health).

-----

1 Work Pass holders, Student’s Pass (STP) holders, and STP IPA holders who are an immediate family member or relative of a Singapore Citizen or a Singapore PR may also apply for entry approval via the SC/PR Familial Ties Lane. All other Work Pass holders should apply for entry under the [Work Pass Holder General Lane](/wphl/overview). All other STP holders and STP IPA holders should apply for entry under the [Student’s Pass Holder Lane](/stpl/overview).

repository: isaacteh-ust/gvt-test

repo_name: isaacteh-ust/gvt-test


text:
---
layout: post
title: "Prometheus"
date: 2018-04-22 22:22:22
tags: [tutorials, Prometheus, 2018]
---

#### Prometheus
- for live reload either enable `--web.enable-lifecycle` when starting up and then `curl -X POST localhost:9090/-/reload` _or_
- `kill -1 $prometheus_PID` send SIGHUP

##### Configuration
- relabel instances (aka remove ports) - in main Prometheus YAML file

```yaml
scrape_configs:
    - job_name: 'prometheus'
      static_configs:
          - targets: ['host:port']
      relabel_configs:
          - source_labels: [__address__]
            target_label:  instance
            regex: ^(localhost):9100*
            replacement: mac-${1}
          - source_labels: [__address__]
            target_label:  instance
            regex: ^.*:9091
            replacement: pushgw
```

#### Alerting (for version 2.x)
- Alert rules configuration - in main Prometheus YAML file

```yaml
rule_files:
    - "rules/test.rules"
```

- the `test.rules` file

```yaml
groups:
- name: host
  rules:

  - alert: idle_below_30pct
    expr:  (100 * (1 - avg by(job)(irate(node_cpu{mode='idle'}[1m])))) < 30
    annotations:
      summary: "Instance {{ $labels.instance }} CPU usage is dangerously high"
      description: "{{ $labels.instance }} is using a LOT of CPU. CPU usage is {{ humanize $value}}%."
    labels:
      severity: warning

  - alert: low_disk_space_root
    expr: node_filesystem_avail{mountpoint="/"} < 50_000_000_000
    annotations:
        summary: "Instance {{ $labels.instance }} disk {{ $device }} is low on space"
        description: "Description disk {{ $labels.instance }} is at {{ humanize $value }}B"
    labels:
        group: storage
        severity: critical
```

- Alert configuration in Alertmanager

```yaml
route:
    receiver: default
    routes:
        - match:
            alertname: ALL
          repeat_interval: 1m
          receiver: all
receivers:
- name: default
- name: ALL
```

gha_language: CSS

gha_license_id: NOASSERTION


text:
# Sinch Notification channel

This package adds a notification channel for Sinch services. You can use it to send SMS messages. Other channels might be available in the future.

## Installation

Install through Composer.

## Config

Add the following to your services config file.

```php
'sinch' => [
	'api_key' => env('SINCH_API_KEY',''),
	'service_plan_id' => env('SINCH_PLAN_ID',''),
	'from' => env('SINCH_FROM',''),
	'prefix' => '',
	'log' => env('SINCH_LOG',true),
	'log_channel' => env('SINCH_LOG_CHANNEL','stack'),
	'send' => env('SINCH_SEND',false),
	'bulglish' => true,
	'allow_multiple' => false,
],
```

- *log* if the messages should be written to a log file
- *log_channel* the log channel to log messages to
- *send* if the messages should be sent (production/dev environment)
- *bulglish* if cyrillic text should be converted to latin letters for SMS messages (cyrillic messages are limited to 67 characters)
- *allow_multiple* if SMS messages above 160 characters should be allowed (billed as multiple messages)

## Send test

To send a test message use the following artisan command:

`php artisan sinch:test phone --message='content' --channel=sms`

## Direct usage

You can instantiate a `Boyo\Sinch\SinchMessage` object and send it immediately.

```php
use Boyo\Sinch\SinchMessage;
use Boyo\Sinch\SinchSender;

class MyClass
{
	public function myFunction()
	{
		$message = (new SinchMessage())->to('359888888888')->channel('sms')->sms('SMS text');

		$client = new SinchSender();
		$client->send($message);
	}
}
```

## Usage with notifications

1. Create a message file that extends `Boyo\Sinch\SinchMessage`. It can take whatever data you need in the construct and should implement a `vuild()` method that defines the messages text content - a good practice would be to render a view file, so that your message content is in your views. You should only define the methods for the delivery channels that your are going to use.

```php
use Boyo\Sinch\SinchMessage;

class MyMessage extends SinchMessage
{
	public function __construct($data)
    {
        $this->id = $data->id; // your unique message id, add other parameters if needed
    }

	public function build() {
		// set your sms text
		$this->sms('SMS text');

		return $this;
	}
}
```

2. In your Notification class you can now include the Sinch channel in the `$via` array returned by the `via()` method.

```php
use Boyo\Sinch\SinchChannel;

via($notifiable)
{

	// ...

	$via[] = SinchChannel::class;

	return $via

}
```

Within the same Notification class you should also define a method `toSms()`:

```php
public function toSms($notifiable)
{
	return (new MyMessage($unique_id))->to($notifiable->phone)->channel('sms');
}
```

The channel method is where you define the delivery channel you wish to use.

- **sms** delivery by sms only (this is the default value, if you omit the channel method)
- other Sinch channels might be available in the future

repository: boyanraichev/laravel-sinch

repo_name: boyanraichev/laravel-sinch


text:
Implementing the Settings UI
===
In this chapter you will learn how to expose file type plug-in configuration settings through a user interface.

Add an Option to Lock Product Codes
===

Start by adding a user control element to your WinUI project, which you can call, for example, **SettingsUI.cs**. Add a group box and a check box (named ```cb_LockPrdCodes```) to the control, which should look as shown below:

![LockPrdCodesOption](images/LockPrdCodesOption.jpg)

As product codes should be locked by default, set the **Checked** property to True.

Your **SettingsUI** class needs to use the following namespace:

* **Sdl.FileTypeSupport.Framework.Core.Settings**

The Settings Bundle
--

Each plug-in uses a settings bundle to store and retrieve settings. The mechanism for doing that is provided in a separate class called **UserSettings**, which we will implement later ([Loading and Saving the Settings](loading_and_saving_settings.md)). For now, we create an object based on the **UserSettings** class:

# [C#](#tab/tabid-1)
```cs
private UserSettings _userSettings;
```
***

So that we can obtain the correct user settings for this settings page from the Filter Framework, we need to tell the framework which settings we need. We can do this by implementing [IFileTypeSettingsAware](../../api/filetypesupport/Sdl.FileTypeSupport.Framework.Core.Settings.IFileTypeSettingsAware-1.yml):

# [C#](#tab/tabid-2)
```cs
public partial class SettingsUI : UserControl, IFileTypeSettingsAware<UserSettings>
```
***

Initialize the Plug-in User Interface Settings
When the user raises the plug-in user interface, the control element should be set according to what is stored in the settings bundle. This is handled by setting the _userSettings object (which we declared previously) and implementing the Settings property from [IFileTypeSettingsAware](../../api/filetypesupport/Sdl.FileTypeSupport.Framework.Core.Settings.IFileTypeSettingsAware-1.yml).

# [C#](#tab/tabid-3)
```cs
public UserSettings Settings
{
    get
    {
        return _userSettings;
    }
    set
    {
        _userSettings = value;
        UpdateControl();
    }
}
```
***

During initialization the ```UpdateControl``` method is invoked, which sets the state of the check box (checked or unchecked) to the value of the LockPrdCodes member of the ```UserSettings``` class as shown below:

# [C#](#tab/tabid-4)
```cs
public void UpdateControl()
{
    cb_LockPrdCodes.Checked = _userSettings.LockPrdCodes;
}
```
***

Save the Settings to the Settings Bundle
--

Conversely, the user interface needs to save the check box setting to the settings bundle, e.g. when the user raises the plug-in UI, changes the check box setting, and then clicks **OK** to apply the changed setting to the settings bundle:

# [C#](#tab/tabid-5)
```cs
private void cb_LockPrdCodes_CheckedChanged(object sender, EventArgs e)
{
    _userSettings.LockPrdCodes = cb_LockPrdCodes.Checked;
}
```
***

Putting it All Together
--

The full code of your user control looks as shown below:

# [C#](#tab/tabid-6)
```cs
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Data;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using Sdl.FileTypeSupport.Framework.Core.Settings;

namespace Sdk.FileTypeSupport.Samples.SimpleText.WinUI
{
    /// <summary>
    /// Implements the user interface for the file type definition.
    /// </summary>
    #region "ClassDeclaration"
    public partial class SettingsUI : UserControl, IFileTypeSettingsAware<UserSettings>
    #endregion
    {
        /// <summary>
        /// Create a settings object based on the UserSettings class.
        /// </summary>
        #region "SettingsObject"
        private UserSettings _userSettings;
        #endregion

        /// <summary>
        /// Initalize the user interface control by setting it to the
        /// setting value stored in the settings bundle.
        /// </summary>
        #region "Initialize"
        public SettingsUI()
        {
            InitializeComponent();
        }
        #endregion

        /// <summary>
        /// Reset the user interface control to its default value, which is
        /// checked, i.e. the product lock option should be enabled
        /// by default.
        /// </summary>
        #region "UpdateControl"
        public void UpdateControl()
        {
            cb_LockPrdCodes.Checked = _userSettings.LockPrdCodes;
        }
        #endregion

        /// <summary>
        /// Save the settings based on the value of the the check box.
        /// The setting is saved through the UserSettings class, which
        /// handles the plug-in settings bundle.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        #region "SaveSetting"
        private void cb_LockPrdCodes_CheckedChanged(object sender, EventArgs e)
        {
            _userSettings.LockPrdCodes = cb_LockPrdCodes.Checked;
        }
        #endregion

        /// <summary>
        /// Implementation of <code>IFileTypeSettingsAware</code> allowing the Filter Framework
        /// to pass through the user settings so that we can initialize the UI.
        /// </summary>
        #region "ApplySettings"
        public UserSettings Settings
        {
            get
            {
                return _userSettings;
            }
            set
            {
                _userSettings = value;
                UpdateControl();
            }
        }
        #endregion
    }
}
```
***

See Also
--

[Creating a New Assembly for the Settings UI](creating_a_new_assembly_for_the_settings_ui.md)

[Implementing the UI Controller Class](implementing_the_ui_controller_class.md)

[File type settings](file_type_settings.md)

[Loading and Saving the Settings](loading_and_saving_settings.md)

>[!NOTE]
>
> This content may be out-of-date. To check the latest information on this topic, inspect the libraries using the Visual Studio Object Browser.

repository: icmoldovan/studio-api-docs

branch_name: refs/heads/main

gha_language: JavaScript

gha_license_id: MIT

repo_name: icmoldovan/studio-api-docs


text:
*This project is part of the [Simple Animations Framework](https://pub.dev/packages/simple_animations)*

# 🍹 Liquid

Liquid provides beautiful visual animations that increases the visual quality of your Flutter application.

## 🌞 Highlights

- **[Liquid Studio](https://felixblaschke.github.io/liquid-studio)** for a simple animation creation and discovery
- Use as animations or static backgrounds

## ⛏ Usage

🛈 *The following code snippets use [**supercharged**](https://pub.dev/packages/supercharged) for syntactic sugar.*

### Getting started

Add **Simple Animations** to your project by following the instructions on the
**[install page](https://pub.dev/packages/simple_animations/install)**.

To learn how to use Liquid:

- Continue reading this page
- Explore and create Liquid animations with **[Liquid Studio](https://felixblaschke.github.io/liquid-studio)**

### Plasma

Plasma is a `Widget` that creates an animation with moving particles that generates a smooth liquid effect. It can be configured in many styles.

You can also use a non-animating variant to generate a fancy background image. Therefor set `speed` to `0.0` and choose nice position by tuning the `offset`.

![plasma](https://raw.githubusercontent.com/felixblaschke/simple_animations_documentation_assets/master/sa_liquid/plasma-example.gif)

Use the **[Plasma creator in Liquid Studio](https://felixblaschke.github.io/liquid-studio/#/plasma)** to create an animation.

Hit the **Generate code** button and copy the code into your Flutter app.

![generate_code](https://raw.githubusercontent.com/felixblaschke/simple_animations_documentation_assets/master/sa_liquid/generate_code.png)


text:
# StoriesSDK

## Example

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

## Requirements

- iOS 10.0

## Installation

StoriesSDK is available through private pod. To install it, simply add the following line to your Podfile:

```pod 'StoriesSDK', :git =><EMAIL_ADDRESS>```

## Author

- [Григорий<EMAIL_ADDRESS>- [Ильнур<EMAIL_ADDRESS>
## License

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

repository: sgsolo/storyes

gha_language: Swift

repo_name: sgsolo/storyes


text:
# Implementation of the `Table` driver

## General approach
First of all, the conceptual model behind the `Table` driver has two layers :

- headers
- body

![Grid has two layers : headers and body](/doc/img/grid-model.png)

So, when implementing the `Table` driver inside a `models.xsl` output implementation, one has to first deal with the headers, then with the body.

Both layers are handled the same way :

- First getting all the lines through a specific getter.
- Second dealing with lines through another specific getter, one by one.
- Then, for each line dealing with cells one by one through the common pattern to retrieve drivers.

## Getting all the lines
*Examples are based on the ddi2fr implementation*

The ddi source exposes specific getters to retrieve all lines :

- `enofr:get-header-lines($source-context)` retrieves lines for headers
- `enofr:get-body-lines($source-context)` retrieves lines for headers

**This getters are not made for dealing with the line contents (see below) but only for iterating over lines.**

In face both these getters don't return line contents but only line labels.

Iterating could be done through a classic `xsl:for-each` element.

## Dealing with lines one by one
*Examples are based on the ddi2fr implementation*

The ddi source exposes specific getters to retrieve line contents :

- `enofr:get-header-line($source-context,position)` retrieves lines for headers
- `enofr:get-body-line($source-context,position)` retrieves lines for headers

A position parameter is used to define which line content should be returned.

## Dealing with line content using the common pattern
*Examples are based on the ddi2fr implementation*

The upper getters should be used to deal with the line contents through the 'common pattern' :

```xslt
<xsl:apply-templates select="enofr:get-body-line($source-context, position())" mode="source">
```

This way drivers will be fired and catched the same way as "simple" questions (aka : not grid ones).

## Pluging all together
*Examples are based on the ddi2fr implementation*

First one iterates on lines, then dealing with lines one by one :

```xslt
<!--Iteration over lines -->
<xsl:for-each select="enofr:get-header-lines($source-context)">
	<!-- Dealing with line content-->
        <xsl:apply-templates select="enofr:get-body-line($source-context, position())" mode="source">
```

One should care about the xpath context : Inside an `xsl:for-each` element, the xpath context is changed for the temporary tree build upon the `@select` value.
Then when calling back to the source interface (`mode='source'`), the driver tree needs to be passed through a param.
Usually like this :

```xslt
    <xsl:apply-templates select="eno:child-fields($source-context)" mode="source">
          <xsl:with-param name="driver" select="." tunnel="yes"/>
    </xsl:apply-templates>
```

But inside an `xsl:for-each`, the `.` will refer to the temporary tree and not anymore to the driver tree.
So, one should save the driver tree before, using a xsl:variable is a common way to do this :

```xslt
    <xsl:variable name="driver-tree">
	    <xsl:copy-of select="."/>
    </xsl:variable>
```

Then simply call back with this variable as param :
```xslt
    <xsl:apply-templates select="eno:child-fields($source-context)" mode="source">
    	<xsl:with-param name="driver" select="$driver-tree" tunnel="yes"/>
    </xsl:apply-templates>
```

repository: InseeFr/Eno

gha_language: HTML

repo_name: InseeFr/Eno


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

### Description

Integer signedness error in rfc2231_get_param from strings.c in PINE before 4.58 allows remote attackers to execute arbitrary code via an email that causes an out-of-bounds array access using a negative number.

### POC

#### Reference
- http://marc.info/?l=bugtraq&m=106367213400313&w=2

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

repository: trickest/cve

repo_name: trickest/cve


text:
# Telepathy Client
Transfer data "telepathically" (using WebRTC) between devices (ionic2 client)

The Telepathy Server implementation can be found [here](https://github.com/hvoecking/telepathy-server).

# Setup
Run the setup script from the projects root directory:
```
./setup.sh
```

repository: hvoecking/telepathy-client

repo_name: hvoecking/telepathy-client


text:
# MultiprojectorTiledDisplay #
Predominantly, this code is an implementation of the multiprojector geometric alignment and edge blending approaches proposed [here](http://ieeexplore.ieee.org/document/1167859/). Futher, we have [proposed](http://ieeexplore.ieee.org/document/7019727/) and implemented an approach for enhancing the overall projection resolution by utilizing the perspective projection invariant, [cross-ratio](https://en.wikipedia.org/wiki/Cross-ratio). Code has been tested for only one planar projection region configuration till now, a 3X3 multiprojector setup. Work on GUI development and addressing arbitrary tiled configurations is under progress.
![Alt text](data/camera_calibration/system.gif?raw=true)

### Current limirations
* Hard-coded configuration(see, sl\_multiproj.cpp)
* Tested on older OpenCV only(v2.4)
* Assumes gPhoto2 supported camera

### Dependecies
* OpenCV
* gPhoto2
* Qt(soon...)

### Build
```mkdir build```
```cd build```
```cmake ../ ```
```make```

### Documentation(**Not generic**)
* [Running calibration](https://github.com/pranavkantgaur/MyDocs/blob/master/Multiprojector_instruction_manual/running_calibration.ogv)
* [Applying calibration settings](https://github.com/pranavkantgaur/MyDocs/blob/master/Multiprojector_instruction_manual/applying_settings.ogv)
* [Addendum](https://github.com/pranavkantgaur/MyDocs/blob/master/Multiprojector_instruction_manual/instruction_manual.pdf)

### TODOs
* GUI
* User manual(for hackers, sl\_multiproj.cpp contains the core implmentation)
* File(or, GUI)-based configurability
* Extension of the code for arbitrary planar multiprojector arrangements

### Who do I talk to? ###

* Please write to<EMAIL_ADDRESS>for any queries related with development.


text:
# Infusion

**Infusion** is a documentation builder for inclusive designers, and those who want to be inclusive designers. Build accessible pattern libraries and all sorts of other docs.

* [Documentation →](https://thepaciellogroup.github.io/infusion)
* [Contributing →](https://github.com/ThePacielloGroup/infusion/blob/master/CONTRIBUTING.md)

repository: rupl/infusion

repo_name: rupl/infusion


text:
# PopOpen
Open a document in the foreground

* Written in F#, just for fun
* Open a document with an associated application.
* Find the process of the application
* Push the application to the top most active window
* Install the nuget package to use it from C#
* [License: MIT](../master/LICENSE.md)

### To install

```
PM> Install-Package PopOpen
```

### logging

You can pass your logger method as lambda function for debugging purpose. The following examples passes log4net's Debug.

```
PopOpen.OpenD(path, s => _log.Debug(s));
```

Visit https://www.nuget.org/packages/PopOpen/ for more package details

### Technical details.

* Process.Start() will open a document with an associated application
* Restart Manager (rstrtmgr.dll) can identify what process is locking a file (https://msdn.microsoft.com/en-us/magazine/cc163450.aspx)
* It finds the opening process by checking who's locking the file
* GetWindowRect finds the the window
* SetWindowPos sets the window to top-most

repository: andrewchaa/PopOpen

repo_name: andrewchaa/PopOpen


text:
---
author: Mihai Maruseac
title: Upcoming stackage LTS 15 snapshot with ghc-8.8.2
description: Upcoming stackage LTS 15 snapshot with ghc-8.8.2
timestamp: 2020-02-10T12:01:00Z
---

The stackage curator team has started preparations for an LTS major
bump which will include ghc-8.8.2.

In addition to allowing new, breaking changes of packages into an LTS release,
this LTS 15 will [discontinue the legacy format for snapshots]
(https://www.stackage.org/blog/2020/02/discontinuing-legacy-snapshots).

To give everyone some time to prepare, we are announcing the planned release date
as approximately **one week** from the date of this post.

Getting your package into the nightly snapshot will ensure its inclusion
in LTS 15 as well. To add your package, please submit a PR to
[commercialhaskell/stackage](https://github.com/commercialhaskell/stackage).
To add your package to LTS 15 after it's released, please open a new issue
on [commercialhaskell/lts-haskell](https://github.com/commercialhaskell/lts-haskell).
Please feel free to contact the stackage curators with any questions you may have
via the [stackage mailing list](https://groups.google.com/forum/#!forum/stackage),
or the [stackage gitter chat](https://gitter.im/commercialhaskell/stackage).

For more insight into how stackage curators handle these sorts of things, see:
[the LTS major bump process](https://github.com/commercialhaskell/stackage/blob/master/CURATORS.md#new-lts-major-bump).

repository: dpwiz/stackage-content

repo_name: dpwiz/stackage-content


text:
vim-c-posix-syntax
========

C Posix Library syntax highlighting

## Configuration

If you want to disable some of the highlights, add the following to ```.vimrc```.

```vim
" Disable Posix type highlights
let g:c_no_posix_type = 1

" Disable Posix struct highlights
let g:c_no_posix_struct = 1

" Disable Posix enum highlights
let g:c_no_posix_enum = 1

" Disable Posix variable highlights
let g:c_no_posix_variable = 1

" Disable Posix constant highlights
let g:c_no_posix_constant = 1

" Disable Posix enum constant highlights
let g:c_no_posix_enum_constant = 1

" Disable Posix function highlights
let g:c_no_posix_function = 1
```


text:
# AUTO ML APP: Developing and Deploying Dash via Heroku

Creating an AUTO-ML app with Dash. Includes classification and time series alorithms. The app implements an explained-ML philosophy. Classification includes dimensionality reduction with t-sne for visualization and PCA. Classification uses simple Logistic Regression and Support Linear Vector. Time series include autocorrelation and XGBoost Regression. Includes basic visual explanations from all algorithms.

Web app: https://auto-ml-app.herokuapp.com/

# Classification Algorithms
![main](/assets/Classification.png)

![main](/assets/Introduction.png)

![main](/assets/Autocorrelation.png)

![main](/assets/Dendogram.png)

![main](/assets/Manifold.png)

![main](/assets/ClassAlgorithm.png)

![main](/assets/Dependence.png)

# Forecasting Algorithms

![main](/assets/TimeSeries.png)

![main](/assets/Trees.png)

![main](/assets/Split.png)

# Credits
- DASH  (https://plotly.com/dash/)
- PYMC3 (https://docs.pymc.io/)
- Wattenberg, et al., "How to Use t-SNE Effectively", Distill, 2016 (https://distill.pub/2016/misread-tsne/)
- Understanding LSTM Networks (http://colah.github.io/posts/2015-08-Understanding-LSTMs/), (http://blog.echen.me/2017/05/30/exploring-lstms/)
- T. Chen, C. Guestrin, "XGBoost: A Scalable Tree Boosting System" , arXiv:1603.02754v3 (https://arxiv.org/abs/1603.02754v3)
- Christopher Olah for inspiration (http://colah.github.io/posts/2015-09-Visual-Information/)

repository: Javihaus/Auto-ML-app-with-dash

repo_name: Javihaus/Auto-ML-app-with-dash


text:
# urban-slack
Urban Dictionary definitions for Slack
![screenshot](https://github.com/t3h2mas/urban-slack/blob/master/screenshots/urban.png)
I am using heroku to tie this into the custom slack command.

## installation
Instructions for installing package requirements.

I'll leave it up to you to connect the app to slack...

`pip install -r requirements.txt`

run the flask app
`python app.py`

## todo
* verify token
* catch errors?
* add more data from Urban Dictionary

license: Unlicense


text:
---
layout: post
title: "Don't miss out on free school meals this summer"
permalink: /archives/2020/07/lbrut-free-school-meals-this-summer.html
commentfile: 2020-07-06-lbrut-free-school-meals-this-summer
category: around_town
date: 2020-07-06 10:00:00
image: "/assets/images/2020/lbrut-summer-free-meals.jpg"
excerpt: |
    Families in Richmond upon Thames are being urged to check if they qualify for free school meals, after a government u-turn means that the scheme will now be funded over the summer holidays.
---

Families in Richmond upon Thames are being urged to check if they qualify for free school meals, after a government u-turn means that the scheme will now be funded over the summer holidays.

Last month, the Government announced that they would be funding the scheme that provides vulnerable and low-income families with vital vouchers for food over the traditional six-week summer break, having previously ruled it out.

With the Coronavirus pandemic having had a massive effect on employment, it is expected that more families will be eligible to claim for free school meals than before.

Cllr Penny Frost, Chair of the Council's Education and Children's Services Committee, said:

> "I am delighted that the Government has seen sense and decided to fund free school meals over this year's summer holiday. As a result of the pandemic, more people will be out of work, more and more people will be claiming Universal Credit and therefore free school meals will be ever more relevant.

> "This scheme is a vital lifeline for so many families across our borough and will be a relief to many who were facing up a very fiscally challenging six weeks.

> "I'd strongly urge all families whose financial circumstances have been affected by the pandemic to check if they are eligible for the scheme."

Families in receipt of the following support payments will be entitled your child will be entitled to receive free school meals:

Universal Credit - provided you have an annual net earned income of no more than £7,400, as assessed by earnings from up to three of your most recent assessment periods

Income Support

Income-based Jobseekers Allowance

Income-related Employment and Support Allowance

The guaranteed element of Pension Credit

Support under Part VI of the Immigration and Asylum Act 1999

Child Tax Credit (provided you're not also entitled to Working Tax Credit and have an annual gross income as assessed by Her Majesty's Revenue and Customs, that does not exceed £16,190)

Working Tax Credit run-on (the payment someone receives for a further four weeks after they stop qualifying for Working Tax Credit)

More information is available at [www.richmond.gov.uk/free_school_meals](http://www.richmond.gov.uk/free_school_meals)

-- from a Richmond Council press release - 6 July 2020

repository: pmahnke/stmgrts

repo_name: pmahnke/stmgrts


text:
---
title: 'Ubuntu Bug #625193 “We can’t fix it because your description didn’t include enough information”'
author: Sathyajith Bhat
type: post
date: 2010-09-05T17:02:42+00:00
url: /2010/09/05/ubuntu-bug-625193-we-cant-fix-it-because-your-description-didnt-include-enough-information/

categories:
  - General
tags:
  - ubuntu
  - linux

---
They say a picture is worth a thousand words. [This picture][1] speaks for itself. Yes, its fugly.  src="https://i.imgur.com/YCn7C.jpg" alt=""   /></a>
</p>

"Vish" [says][2] "the description didn't include enough information".

> > Thank you for taking the time to report this bug and helping to make Ubuntu better. Unfortunately, we cant fix it because your description didnt include enough information.

Uh-huh. Riiight. Maybe he didn't look at the image.

Well, he got a pretty descriptive [bug report][3]. Hilarious.

> Overview:
>
> Default Ubuntu wallpaper is not a wallpaper for an OS which aims to be the best looking OS on the planet.
>
> Steps to Reproduce:
>
> Install or upgrade Ubuntu 10.10
>
> Expected Results:
>
> Expecting a cool and awesome looking wallpaper for "the perfect 10" because Ubuntu is awesome and therefore the wallpaper should reflect this awesomeness.
>
> Actual Results:
>
> - My eyes ! They're melting !

> - The 10 is not perfect with this wallpaper

> - MacOS X "Snow Leopard" and Windows 7 have better default wallpapers

> - Does not inspire awe

> - No one likes it, I haven't found any positive feedback on this wallpaper
>
> Build Date & Platform:
>
> Up to date Ubuntu 10.10
>
> Additional Information:
>
> - Slows down the work of the Ubuntu Manual team

> - Was listening to "Metallica - The thing that should not be" while writing this comment

via [Bug #625193 is not in Ubuntu: “Official 10.10 wallpaper is unappealing”][5].

 [1]: https://i.imgur.com/YCn7C.jpg
 [2]: https://bugs.launchpad.net/ubuntu/+bug/625193/comments/17
 [3]: https://bugs.launchpad.net/ubuntu/+bug/625193/comments/24
 [4]: https://launchpad.net/~strycore
 [5]: https://bugs.launchpad.net/ubuntu/+bug/625193


text:
# Template-Engine-Emp-Summary

  ## Table of Contents

  1. Installation
  2. Usage
  3. Video Link
  4. License
  5. Credits

  ## Installation
  Clone with the SSH Key:
    git@github.com:cwf1984/Template-Engine-Emp-Summary.git

  Install NPM Inquirer and Path in Node:
  npm i inquirer
  npm i path

  Both are needed to run the program.

  ## Usage
  * When the user runs the program in node, they are prompted to answer a set of questions.
  * Once the user answers all questions, a new readme file called newREADME.md  is created with the information they provided.
  * I am still working to get the badge of the license chosen to display.

  ## Video

  Click the link below to watch a video of the program as it is run:

    https://drive.google.com/file/d/1XcnFZZih5uIFz93p3k8WOpa6mUtbkp31/view

  ## License

  MIT License

  Copyright (c) [2020] [Vanessa B]

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

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

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

  ## Credits

  I want to thank Bootcamp Spot, the University of Washington and Trilogy Education for the assignment and code they provided. This assignment was challenging and also good practice. Thank you to the instructor, TA's, and my tutor for their patience, dedication and help.


text:
# stream-limiter

A PassThrough stream that stops streaming after the specified number of bytes has been passed.

Does not support *objectMode*.

## Setup

```shell
npm install stream-limiter
```

## Implementation details

Always count bytes and not characters, even if it is inserted into the chain of text streams.

Please note, that for text streams some characters can take more then one byte and thus can be cut off in the middle at the end of the resulting stream. This is an intentional behavior, as the exact byte size is considered to be more important here.

## Usage

```javascript
const StreamLimiter = require('stream-limiter')
const { Readable } = require('stream') // or: require('readable-stream')

// Sample readable stream of 8 bytes.
// The bytes might (but not have to) be interpreted as 8 ascii chars:
//  'M', 'a', 'r', 's', 'h', 'a', 'l', 'l'
const rs = new Readable()
rs.push(Buffer.from([77, 97, 114, 115, 104, 97, 108, 108]))
rs.push(null)

// limiter PassThrough stream with maxBytes = 7
const sl = StreamLimiter(7)

// pipe through it
rs.pipe(sl).pipe(process.stdout)
// output > Marshal     (without last 'l')

// An implicit conversion to chars took place while
// printing output in the terminal window, but basically
// we have [77, 97, 114, 115, 104, 97, 108] bytes sequence
// at the readable end of 'sl' stream here.
```

The only constructor parameter is the ```maxBytes``` - number of bytes allowed to pass through the stream.

This can be any number, including ```+Infinity```. Numbers less then 1 (e.g. 0, 0.99, -5, ```-Infinity```) are treated as zero bytes limit, thus the stream will end (and emit the 'finish' event) immediately after the streaming has begun.

Any other value (like ```NaN```, or of any type other then ```Number```) will be interpreted as ```+Infinity``` and act as if there is no limit.

## Dependencies

For a *"stable streams base, regardless of what version of Node you are using"* we use [readable-stream](https://www.npmjs.com/package/readable-stream) standalone stream module instead of Node core implementation (read elaboration on this [here](https://r.va.gg/2014/06/why-i-dont-use-nodes-core-stream-module.html)).

repository: heroqu/stream-limiter

repo_name: heroqu/stream-limiter


text:
# Read Only Input Elements

Here is an input element with a `value` and no `onChange` handler.

```javascript
const MyInput = ({ value }) => {
  return (
    <input value={value} />
  );
};
```

React will raise a warning regarding the `input` element because it has a
`value` without an `onChange` handler leaving React to wonder if it is
intended to be a _controlled_ or _uncontrolled_ component.

If our intention is to have the `value` set but not allow the user to
directly change it, we just need to let React know that.

```javascript
const MyInput = ({ value }) => {
  return (
    <input readOnly value={value} />
  );
};
```

The `readOnly` prop means we don't intend for the input to be modified by
user input. The React warning will now go away.

h/t Dillon Hafer

repository: jbranchaud/til

gha_language: Vim Script

repo_name: jbranchaud/til


text:
---
layout: project
type: project
image: images/twitter-clone-thumbnail.png
title: Simple Tweet
permalink: projects/simple-tweet
# All dates must be YYYY-MM-DD format!
date: 2021-07-30
labels:
  - Android Development
  - Java
  - API
  - OAuth
summary: Simple Tweet is a Twitter clone Java Android Application that I created to familiarize myself with the REST APIs and OAuth logins.
---

Simple Tweet is a Twitter clone Java Android Application.
The app signs users into their twitter account using OAuth login. Logged in users can view their twitter feed and post to Twitter from their account within the app.
I decided to make a clone of Twitter because I wanted to familiarize myself with using REST APIs which Twitter offers, as well as the OAuth login necessary to retrieve user specific data from the API.

### How does it work?
This application works by retrieving tweets from the Twitter API. To get a specific user's feed and to be able to give user's the option to post to the feed, I prompt users to sign into the app using an OAuth login.
After logging in, a HTTP Get request is used to fetch the tweets on the user's timeline and it is then displayed into a recycler view for the user to see. Similarly, an HTTP Post request is used to create tweets by the user.

### What I learned
I was able to successfully familiarize myself with REST APIs by playing with the API offered by Twitter. This clone also gave me my first introduction to using OAauth for logins.
I am aware of the widespread applications of REST APIs and OAuth protocols, so to be able to get familiar with these tools felt like an invaluable lesson to learn and I am sure I will end up using later down the line.

### ✨ View this project on [Github](https://github.com/vgerber614/SimpleTweet)! ✨
[https://github.com/vgerber614/SimpleTweet](https://github.com/vgerber614/SimpleTweet)


text:
# Get all by parent

If the term has no parent: name of the dictionary is used as `parent` option.
```http
GET /termAllByParent/Овощи?limit=5 HTTP/1.1
Content-Type: application/json
```

# Put one item

To dictionary (First items in dictionary):
```http
POST /term HTTP/1.1
Content-Type: application/json

{
  "dictionaryId": "3e3e9614-7032-4f04-bd9f-523c3b74f3d4",
  "term": "Огурец",
}
```

To parent term (Nested terms):
```http
POST /term HTTP/1.1
Content-Type: application/json

{
  "dictionaryId": "3e3e9614-7032-4f04-bd9f-523c3b74f3d4",
  "parentId": "023370f2-1ef3-4968-ae6a-315242b6c757",
  "term": "Корнишон",
}
```

# Put multiple items

To dictionary (First items in dictionary):
```http
POST /termAll HTTP/1.1
Content-Type: application/json

{
  "dictionaryId": "3e3e9614-7032-4f04-bd9f-523c3b74f3d4",
  "terms": [
    {"term": "Огурец"}
    {"term": "Помидор"}
    {"term": "Картофель"}
  ]
}
```

To parent term (Nested terms):
```http
POST /termAll HTTP/1.1
Content-Type: application/json

{
  "dictionaryId": "3e3e9614-7032-4f04-bd9f-523c3b74f3d4",
  "parentId": "023370f2-1ef3-4968-ae6a-315242b6c757",
  "terms": [
    {"term": "Корнишон"}
    {"term": "Пикули"}
    {"term": "Салатный"}
  ]
}
```


text:
# Belka Podcasts

This is a web-site for Belka Space. The main content is audio podcasts and presentations.

![Belka logo](documents/belka-35.png)

# About
This repository contains Web server which serves browser version of application. API server is RESTful, it can be used to build mobile application.

# Technologies
Stack of technologies used in project:
- Backend
  - Node.js
  - Express.js
  - Handlebars as template engine
  - MySQL
  - Sequelize as ORM for MySQL
  - Epilogue as REST API generator for Sequelize
- Frontend
  - Bootstrap 4
  - jQuery

# Installation
First install `ghostscript` and `graphicmagick`. Add them to your PATH. These libraries convert PDF file to images.

Install packages (requires [node-gyp](https://github.com/nodejs/node-gyp) to be installed)
```
npm install
```

Run in development mode (with nodemon)
```
npm run dev
```

You need a .env file in root folder with following configuration:

```
PORT=
NODE_ENV=
SQL_DIALECT=
SQL_USERNAME=
SQL_PASSWORD=
SQL_HOST=
SQL_PORT=
SQL_DATABASE=
```

To create / drop / fill / recreate database with sample data:
```
# Create empty database
npm run db:create

# Drop existing database
npm run db:drop

# Fill database with sample data
npm run db:fill

# Drop & create & fill
npm run db:recreate

# Check connection
npm run db:test
```

No tests available yet.

# API
Posts
`http://belka.kpi.ua/api/posts`

Podcasts
`http://belka.kpi.ua/api/podcasts`

Categories
`http://belka.kpi.ua/api/categories`

Posts grouped by categories
`http://belka.kpi.ua/api/category_posts`

Post images
`http://belka.kpi.ua/api/post_images`

All API above can be used with various query parameters for filtering, sorting, search and pagination. Look query parameters usage in [epilogue](https://github.com/dchester/epilogue#rest-api) documentation.

Posts grouped by year
`http://belka.kpi.ua/api/annual`

# Dev
## Diagrams that represent architecture of project

#### Project architecture
![dia1](documents/proj_arch.png)

#### Web server architecture
![dia2](documents/server_arch.png)

#### EER model of SQL database
![EER](documents/eer.png)

## Security
[bcrypt](https://github.com/kelektiv/node.bcrypt.js) is used to hash password. Hash is stored in database.
[express-session](https://github.com/expressjs/session) is used to keep admin session in browser.
[express-JWT](https://github.com/auth0/express-jwt) is used to access secure API (post, put, delete requests).

## Frontend
We use [Bootstrap 4](https://v4-alpha.getbootstrap.com) to make responsive design.

Because of simplicity of frontend code, we use pure css and js without any transpilers.

### Backend
We created a small module 'fetch-data' that allows to make an HTTP request to API server to fetched certain attributes and then format them applying given functions to fetched attributes (look [R.evolve](http://ramdajs.com/docs/#evolve)).

Also created middleware 'slug' that adds [slug](https://en.wikipedia.org/wiki/Semantic_URL) at the end of id in url string. It works absolutely like on [StackOverflow](http://stackoverflow.com/).

All parts of MVC pattern realization are splitted into 2 groups - 'blog' and 'admin', that are located in self-titled folders.

----------
## Belka contacts
- [VK](https://vk.com/belka.space)
- [Facebook](https://www.facebook.com/belka.space.kpi)
- [Telegram](https://t.me/belka_space)
- [Instagram](https://www.instagram.com/belka.space)

----------
## Links
- Backend by [Vlad Khitev](https://vk.com/id18315550)
- Frontend by [Ivan Romanchuk](https://vk.com/irmchk)

© NTUU "KPI" 2017

repository: vkhitev/belka

repo_name: vkhitev/belka


text:
# Httpbin

This was put in because I wanted to try learning to write my own yaml instead
of using one that someone else wrote. It's a simple Kubernetes deployment
around [httpbin](http://httpbin.org/) by
[@kennethreitz](https://github.com/kennethreitz), along with exposure as
a service and an ingress resource, all tucked safely away in its own namespace.

repository: jabagawee/playing-with-kubernetes

repo_name: jabagawee/playing-with-kubernetes


text:
Stemonitis confluens var. syncarpa Yamash. VARIETY
=======

#### Status
SYNONYM

#### According to
Index Fungorum

#### Published in
Journal of Science of the Hiroshima University, B, 2 3: 34 (1936)

#### Original name
Stemonitis confluens var. syncarpa Yamash.

### Remarks
null

repository: kehh/backbone

repo_name: kehh/backbone


text:
## 0.9.0 - 8-20-15
* Add min-height, min-width, display flex, content, & alternative left

## 0.8.0 - 4-25-15
* Make border radius width values consistent with other snippet types
* Add background size

## 0.7.0 - 4-14-15
* Add package keywords

## 0.6.0 - 4-14-15
* Add vertical-align: middle, fill, width/height: auto, float: none
* Make height's prefix more consistent
* Move breakpoints around to support my workflow better

## 0.5.0 - 1-9-15
* Fixed text-transform

## 0.4.0 - 12-21-14
* Added `!important`

## 0.3.0 - 12-21-14
* Changed prefixes for background rules, they all now start with "bg"
* Removed extra `background-postion` rules, probably not needed
* Added `border-radius`
* Fixed `white-space`

## 0.2.0 - 12-11-14
* Added support for .css.less files (Maxime Grébauval)
* Added `position: static`, `width`, and `height`
* Fixed `background-position` prefixes

## 0.1.0 - 12-06-14
* Added a shit ton of snippets

repository: neromaki/atom-css-snippets

repo_name: neromaki/atom-css-snippets


text:
# Graphiti::Rails

Graphiti::Rails provides robust Rails integration for Graphiti, following standard Rails conventions.

## Usage
Out of the box, Graphiti::Rails requires no configuration!

## Installation
Add this line to your application's Gemfile:

```ruby
gem 'graphiti-rails'
```

### Additional Setup

#### Debug Exception Format

If you're already running Rails in [API-only mode](https://guides.rubyonrails.org/api_app.html#changing-an-existing-application), there's no additional setup. Otherwise, we recommend the following in `config/application.rb`:

```ruby
config.debug_exception_response_format = :api
```

This will cause the [`ActionDispatch::DebugExceptions`][debug-exceptions] middleware to generate debug information in the requested content-type instead of as HTML only. In turn, this allows graphti-rails to generate more specific error messages for JSON API requests.

#### Handled Exception Formats

Since Rails doesn't correctly format exceptions for JSON:API requests, graphiti-rails intercepts these requests for proper rendering. If you'd like to use the GraphitiError handlers for other response types as well, you can add them in `config/application.rb`:

```ruby
config.graphiti.handled_exception_formats += [:xml]
```

## Features

### Exception Handling
By default, Rails does a few things to handle exceptions. We integrate into this handling to ensure behavior as close to the Rails defaults while still adding important conventions and additional information provide by Graphiti.

#### `rescue_from`

At the highest level, is [`rescue_from`][rescue-from] which allows you to handle an error at the controller level. This bypasses all default error handling in Rails, leaving it up to the developer to account for all scenarios. In the future, we would like to provide some APIs for default handling in these cases.

#### `ActionDispatch::DebugExceptions`

Next is [`ActionDispatch::DebugExceptions`][debug-exceptions]. This middleware logs exceptions and renders debugging information for local requests. We hook in here to log information in a proper format for JSON:API.

#### `ActionDispatch::ShowExceptions`

Last is [`ActionDispatch::ShowExceptions`][show-exceptions]. This middleware rescues any exception returned by the application and calls an exceptions app that will wrap it in a format for the end user. We wrap the exceptions app to ensure that JSON:API errors are always rendered in the standard format.

### Context Wrapping
We wrap all requests in a Graphiti context pointing to the current controller instance. If you'd like to use a different context, overwrite the `graphiti_context` method in your controller.

For more information about Graphiti context, see the [Graphiti docs][context].

### Debugging
We also provide hooks for Graphiti's built-in debugger. For more information see the [Graphiti docs][debugger].

## Contributing
We'd love to have your help improving graphiti-rails. To chat with the team and other users, join the `#rails` channel on [Slack][slack].

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

[debug-exceptions]: https://api.rubyonrails.org/classes/ActionDispatch/DebugExceptions.html
[context]: https://www.graphiti.dev/guides/concepts/resources#context
[debugger]: https://www.graphiti.dev/guides/concepts/debugging#debugger
[rescue-from]: https://api.rubyonrails.org/classes/ActiveSupport/Rescuable/ClassMethods.html#method-i-rescue_from
[show-exceptions]: https://api.rubyonrails.org/classes/ActionDispatch/ShowExceptions.html
[slack]: https://join.slack.com/t/graphiti-api/shared_invite/enQtMjkyMTA3MDgxNTQzLWVkMDM3NTlmNTIwODY2YWFkMGNiNzUzZGMzOTY3YmNmZjBhYzIyZWZlZTk4YmI1YTI0Y2M0OTZmZGYwN2QxZjg

repository: graphiti-api/graphiti-rails

gha_language: Ruby

repo_name: graphiti-api/graphiti-rails


text:
# SDNS

[![Travis](https://img.shields.io/travis/semihalev/sdns.svg?style=flat-square)](https://travis-ci.org/semihalev/sdns)
[![Go Report Card](https://goreportcard.com/badge/github.com/semihalev/sdns?style=flat-square)](https://goreportcard.com/report/github.com/semihalev/sdns)
[![GoDoc](https://img.shields.io/badge/godoc-reference-blue.svg?style=flat-square)](http://godoc.org/github.com/semihalev/sdns)
[![codecov](https://codecov.io/gh/semihalev/sdns/branch/master/graph/badge.svg)](https://codecov.io/gh/semihalev/sdns)
[![GitHub version](https://badge.fury.io/gh/semihalev%2Fsdns.svg)](https://github.com/semihalev/sdns/releases)

:dizzy: Lightweight, fast recursive dns server with dnssec support

Based on [kenshinx/godns](https://github.com/kenshinx/godns), [looterz/grimd](https://github.com/looterz/grimd)

<img src="https://github.com/semihalev/sdns/blob/master/logo.png?raw=true" width="300">

## Installation

```shell
go get github.com/semihalev/sdns
```

or

[download](https://github.com/semihalev/sdns/releases)

or run with [Docker image](https://hub.docker.com/r/c1982/sdns/)

```shell
docker run -d --name sdns -p 53:53 -p 53:53/udp -p 853:853 -p 8053:8053 -p 8080:8080 sdns
```

-   Port 53 DNS server
-   Port 853 DNS-over-TLS server
-   Port 8053 DNS-over-HTTPS server
-   Port 8080 HTTP API

## Building

```shell
$ go build
```

## Testing

```shell
$ make test
```

## Flags

| Flag   | Desc                                                           |
| ------ | -------------------------------------------------------------- |
| config | Location of the config file, if not found it will be generated |

## Configs

| Key             | Desc                                                                                |
| --------------- | ------------------------------------------------------------------------------------------------------------------------------ |
| version         | Config version                                                                                |
| blocklists      | List of remote blocklists                                                                                |
| blocklistdir    | List of locations to recursively read blocklists from (warning, every file found is assumed to be a hosts-file or domain list) |
| loglevel        | What kind of information should be logged, Log verbosity level crit,error,warn,info,debug                                      |
| bind            | Address to bind to for the DNS server. Default :53                                                                             |
| bindtls         | Address to bind to for the DNS-over-TLS server. Default :853                                                                   |
| binddoh         | Address to bind to for the DNS-over-HTTPS server. Default :8053                                                                |
| tlscertificate  | TLS certificate file path                                                                                |
| tlsprivatekey   | TLS private key file path                                                                                |
| outboundips     | Outbound ip addresses, if you set multiple, sdns can use random outbound ip address                                            |
| rootservers     | DNS Root servers                                                                                |
| root6servers    | DNS Root IPv6 servers                                                                                |
| rootkeys        | DNS Root keys for dnssec                                                                                |
| fallbackservers | Fallback servers IP addresses                                                                                |
| api             | Address to bind to for the http API server, leave blank to disable                                                             |
| nullroute       | IPv4 address to forward blocked queries to                                                                                |
| nullroutev6     | IPv6 address to forward blocked queries to                                                                                |
| accesslist      | Which clients allowed to make queries                                                                                |
| timeout         | Query timeout for dns lookups in duration Default: 5s                                                                          |
| connecttimeout  | Connect timeout for dns lookups in duration Default: 2s                                                                        |
| hostsfile       | Enables serving zone data from a hosts file, leave blank to disable                                                            |
| expire          | Default cache TTL in seconds Default: 600                                                                                |
| cachesize       | Cache size (total records in cache) Default: 256000                                                                            |
| maxdepth        | Maximum recursion depth for nameservers. Default: 30                                                                           |
| ratelimit       | Query based ratelimit per second, 0 for disable. Default: 0                                                                    |
| clientratelimit | Client ip address based ratelimit per minute, 0 for disable. if client support edns cookie no limit. Default: 0                |
| blocklist       | Manual blocklist entries                                                                                |
| whitelist       | Manual whitelist entries                                                                                |

## Server Configuration Checklist

-   Increase file descriptor on your server

## Features

-   Linux/BSD/Darwin/Windows supported
-   DNS RFC compatibility
-   DNS lookups within listed servers
-   DNS caching
-   DNSSEC validation
-   DNS over TLS support
-   DNS over HTTPS support
-   Middleware Support
-   RTT priority within listed servers
-   EDNS Cookie Support (client<->server)
-   Basic IPv6 support (client<->server)
-   Query based ratelimit
-   IP based ratelimit
-   Access list
-   Prometheus basic query metrics
-   Black-hole internet advertisements and malware servers
-   HTTP API support
-   Outbound IP selection

## TODO

-   [x] More tests
-   [x] Try lookup NS address better way
-   [x] DNS over TLS support
-   [x] DNS over HTTPS support
-   [x] Full DNSSEC support
-   [x] RTT optimization
-   [x] Access list
-   [x] Periodic priming queries described at RFC 8109
-   [ ] Automated Updates DNSSEC Trust Anchors described at RFC 5011
-   [ ] Full IPv6 support (server<->server communication)
-   [ ] Query name minimization to improve privacy described at RFC 7816

## Contributing

Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.

Please make sure to update tests as appropriate.

## Made With

-   [miekg/dns](https://github.com/miekg/dns) - Alternative (more granular) approach to a DNS library

## License

[MIT](https://github.com/semihalev/sdns/blob/master/LICENSE)

repository: anbring/sdns

repo_name: anbring/sdns


text:
# airsonic Docker Image based on alpine
[airsonicurl]: https://github.com/airsonic/airsonic
[![airsonic](https://raw.githubusercontent.com/airsonic/airsonic/master/contrib/assets/logos/airsonic_dark_1400x400.svg?sanitize=true)][airsonicurl]

This is my airsonic Docker Image based on alpine image with s6-overlay runs as non root by default.

## Usage

``` bash
docker run \
--rm \
--name=airsonic \
-v </path/to/data>:/airsonic \
-v </path/to/playlists>:/playlists \
-v </path/to/podcasts>:/podcasts \
-v </path/to/music>:/music \
-e AIR_GID=<gid> -e AIR_UID=<uid> \
-e AIR_CONTEXTPATH=<url-base> \
-p 4040:4040 \
-m 512m \
wuerfelbecher/airsonic-docker

```

## Usage as systemd service

``` ini
# /etc/systemd/system/airsonic.service
# This is only a sample, please change the contents to fit your environment
[Unit]
Description=Airsonic Media Server
After=network.target local-fs.target remote-fs.target docker.service

[Service]
ExecStartPre=-/usr/bin/docker rm -f airsonic
ExecStartPre=-/usr/bin/docker pull wuerfelbecher/airsonic-docker
ExecStart=/usr/bin/docker run \
    --rm --name=airsonic \
    -v /srv/airsonic/data:/airsonic \
    -v /srv/airsonic/playlists:/playlists \
    -v /srv/airsonic/podcasts:/podcasts \
    -v /mnt/music:/music \
    -p 4040:4040 \
    wuerfelbecher/airsonic-docker

[Install]
WantedBy=multi-user.target

```

## Parameters / Variables

| Parameter | Function |
| :---: | --- |
| `-p 4040` | Webserver port |
| `-v /airsonic` | Configuration file location |
| `-v /music` | Location of music |
| `-v /playlists` | Location for playlists |
| `-v /podcasts` | Location of podcasts |

| Variable  | Function |
| :---:     | --- |
| `AIR_USR` | for custom UserName, Defaults to **airsonic**|
| `AIR_GRP` | for custom GroupName, Defaults to **airsonic**|
| `AIR_UID` | for custom UserID, Defaults to **618** |
| `AIR_GID` | for custom GroupID, Defaults to **618** |
| `AIR_JAVA_OPTS`  | for custom Java Options, Defaults to **-Xmx512m** |
| `CONTEXT_PATH` | for setting the url-base, Defaults to **/** |

## License

MIT License

Copyright (c) 2018 Thomas Büttner

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

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

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

repository: Wuerfelbecher/airsonic-docker

gha_language: Shell

repo_name: Wuerfelbecher/airsonic-docker


text:
# dockerfiles
A collection of useful dockerfiles
___
_Inspired by @jfrazelle's awesome repo: https://github.com/jfrazelle/dockerfiles_

These are dockerfiles for individual programs that I might want to run in their own container. Why? The isolation is nice,
but its also a great way to make these programs "portable" across systems. _(I'm doing this to see if its a superior way
to do what I'm doing with my dotfiles repo.)_

repository: nloadholtes/dockerfiles

repo_name: nloadholtes/dockerfiles


text:
# Viper-Generator
Module Viper Generator for Swift 5

On original Module you can access to https://github.com/Juanpe/Swift-VIPER-Module

This is Updated suit for my condition

# How to Install
1. open `Terminal`
2. type `open ~/Library/Developer/Xcode/Templates/`
3. create new folder with name as you like ex: `Modul Generator`
4. paste `Module VIPER.xctemplate`
5. done

# VIPER diagram overview
![img](https://github.com/ajijoyo/Viper-Generator/blob/master/viper_diagram.png)

repository: ajijoyo/Viper-Generator

repo_name: ajijoyo/Viper-Generator


text:
# Count minimum steps to get the given desired array

## Consider an array with n elements and value of all the elements is zero. We can perform following operations on the array

1. Incremental operations:Choose 1 element from the array and increment its value by 1.
2. Doubling operation: Double the values of all the elements of array.

## We are given desired array target[] containing n elements. Compute and return the smallest possible number of the operations needed to change the array from all zeros to desired array

```txt
Examples:

Input: target[] = {2, 3}
Output: 4
To get the target array from {0, 0}, we
first increment both elements by 1 (2
operations), then double the array (1
operation). Finally increment second
element (1 more operation)

Input: target[] = {2, 1}
Output: 3
One of the optimal solution is to apply the
incremental operation 2 times to first and
once on second element.
```

https://www.geeksforgeeks.org/count-minimum-steps-get-given-desired-array/

repository: abhaydhiman/Pyalgo

repo_name: abhaydhiman/Pyalgo


text:
### [CVE-2019-9491](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2019-9491)
![](https://img.shields.io/static/v1?label=Product&message=Trend%20Micro%20Anti-Threat%20Toolkit%20(ATTK)&color=blue)
![](https://img.shields.io/static/v1?label=Version&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Vulnerability&message=Arbitrary%20RCE&color=brighgreen)

### Description

Trend Micro Anti-Threat Toolkit (ATTK) versions <IP_ADDRESS>8 and below have a vulnerability that may allow an attacker to place malicious files in the same directory, potentially leading to arbitrary remote code execution (RCE) when executed.

### POC

#### Reference
- http://hyp3rlinx.altervista.org/advisories/TREND-MICRO-ANTI-THREAT-TOOLKIT-(ATTK)-REMOTE-CODE-EXECUTION.txt
- http://packetstormsecurity.com/files/156160/TrendMicro-Anti-Threat-Toolkit-Improper-Fix.html
- http://seclists.org/fulldisclosure/2019/Oct/42
- http://seclists.org/fulldisclosure/2020/Jan/50
- https://seclists.org/bugtraq/2019/Oct/30
- https://seclists.org/bugtraq/2020/Jan/55

#### Github
- https://github.com/ARPSyndicate/cvemon
- https://github.com/alphaSeclab/sec-daily-2019

repository: trickest/cve

repo_name: trickest/cve


text:
# geiesmonads (_j_-_s_-monads)

![alt image](/img/say_monad.jpg)

Crisp clear chainable JavaScript/ECMAScript 6 monads.

Special Challenge: parser combinators in JavaScript!!!
------------------------------------------------------
File [parsers.js](https://github.com/Muzietto/geiesmonads/blob/master/parsers/js/parsers.js) contains an implementation of __chainable parser combinators__, featuring both __applicative__ and __monadic__ interfaces.

Test page is [here](https://muzietto.github.io/geiesmonads/parsers/Mocha_Parser_Combinators_Tests.html).

Live examples page is [here](https://muzietto.github.io/geiesmonads/parsers/Console_Parser_Examples.html).

A complete [JSON parser](https://muzietto.github.io/geiesmonads/parsers/js/json_parsers.js) is presented, and it is tested [here](https://muzietto.github.io/geiesmonads/parsers/Mocha_JSON_Parser_Tests.html).

NB - with a big credit due to [Understanding Parser Combinators](https://fsharpforfunandprofit.com/posts/understanding-parser-combinators/) and to [Paco](https://github.com/gabrielelana/paco).

New with RELEASE 2.2
--------------------
File [geiesmonads_es6_reader.js](https://github.com/Muzietto/geiesmonads/blob/master/es6/geiesmonads_es6_reader.js) contains an implementation of a __chainable reader monad__.

Test page is [here](https://muzietto.github.io/geiesmonads/MochaGeiesmonadsES6_Reader_Test.htm).

NB - with a big credit due to [Don't Fear the Reader](https://passy.svbtle.com/dont-fear-the-reader).

New with RELEASE 2.1
--------------------
[`Maybe`, `Either a`, `State`](https://muzietto.github.io/geiesmonads/MochaGeiesmonadsES6_Test.htm), [`StateMaybe`](https://muzietto.github.io/geiesmonads/MochaGeiesmonadsES6_StateMaybe_Test.htm) and [`StateEither`](https://muzietto.github.io/geiesmonads/MochaGeiesmonadsES6_StateEither_Test.htm) in ECMAScript 6.

Click on the above links to access the Mocha unit test page (verify whether your browser can run the code).

NB: This repo has been tested on FF 41 and Chrome 57.

Define a State monad that manages errors (in a sense like Maybe):
if an error/problem occurs during the "do" computation, it is signalled and propagated by `bind`.
 - Step 1) The presence of a None indicates an error has occurred -> `StateMaybe` monad
 - Step 2) The error should propagate carrying a string which describes what occurred -> `StateEither` monad

See files:
* [es6/geiesmonads_StateMaybe_StateEither.js](https://github.com/Muzietto/geiesmonads/blob/master/es6/geiesmonads_StateMaybe_StateEither.js)
* [es6/geiesmonads_stateMaybeTest.js](https://github.com/Muzietto/geiesmonads/blob/master/es6/geiesmonads_stateMaybeTest.js)
* [es6/geiesmonads_stateEitherTest.js](https://github.com/Muzietto/geiesmonads/blob/master/es6/geiesmonads_es6_stateEither_test.js)

New with RELEASE 2.0
--------------------
- Minor improvements to the `maybe` monad:
  - introduction of inner functions `some()` and `none()`
  - streamlining of the API
- Major improvements to the `state` monad:
  - monad as pure JS function - see [[7]](http://faustinelli.wordpress.com/2014/06/01/state-monad-goes-to-js-town-and-starts-swinging/)
- Implementation of monadic labeling for a binary tree and its comparison with manual labeling. See [[4]](http://channel9.msdn.com/Shows/Going+Deep/Brian-Beckman-The-Zen-of-Expressing-State-The-State-Monad)
- Usage of the state monad to emulate imperative programming - see [[5]](http://brandon.si/code/the-state-monad-a-tutorial-for-the-confused/)

TRAINING
--------
- We start with experiments with `Identity` and `Maybe` monad. We verify the three laws for both of them.
- We improve on the design and create a chainable `Maybe` monad.
- We implement a state monad along the lines of [[2]](http://jabberwocky.eu/2012/11/02/monads-for-dummies/) and [[3]](http://igstan.ro/posts/2011-05-02-understanding-monads-with-javascript.html) and [verify the three laws also for that](https://muzietto.github.io/geiesmonads/YUIGeiesmonads_TRAIN_Test.htm).
See files [geiesmonads_0.1.js](https://github.com/Muzietto/geiesmonads/blob/master/js/geiesmonads_0.1.js) and [geiesmonads_0.2.js](https://github.com/Muzietto/geiesmonads/blob/master/js/geiesmonads_0.2.js).

ORIGINAL CONTRIBUTION: Implementation of a __chainable state monad__.
---------------------
This monad is a native JS function with type `s -> (s,a)` enriched with a `bind` method.
The present JS implementation of [[4]](http://channel9.msdn.com/Shows/Going+Deep/Brian-Beckman-The-Zen-of-Expressing-State-The-State-Monad) is also available in Java 8 language at [[6]](http://faustinelli.wordpress.com/2014/04/25/the-state-monad-in-java-8-eventually)

See file [geiesmonads_0.2.js](https://github.com/Muzietto/geiesmonads/blob/master/js/geiesmonads_0.2.js) and [related tests](https://muzietto.github.io/geiesmonads/YUIGeiesmonads_Test.htm).

DEBITS AND CREDITS
------------------
- The non-chainable `identity`, `maybe` and `state` monad are just repetitions of implementations given in [[2]](http://jabberwocky.eu/2012/11/02/monads-for-dummies) and [[3]](http://igstan.ro/posts/2011-05-02-understanding-monads-with-javascript.html)

- The chainable maybe monad is a re-elaboration of some old code of mine, written in Java and available [at my blog](http://faustinelli.wordpress.com/2010/07/27/example-maybe-monad-in-java)

- My original contribution (the [chainable state monad](http://faustinelli.wordpress.com/2014/06/01/state-monad-goes-to-js-town-and-starts-swinging/)) is a truly cool thing.

I am in debt with:

[2] http://jabberwocky.eu/2012/11/02/monads-for-dummies/

[3] http://igstan.ro/posts/2011-05-02-understanding-monads-with-javascript.html

I am in DEEP debt with:

[1] http://james-iry.blogspot.it/2007/09/monads-are-elephants-part-1.html (and also part 2,3,4)

[4] http://channel9.msdn.com/Shows/Going+Deep/Brian-Beckman-The-Zen-of-Expressing-State-The-State-Monad

[5] http://brandon.si/code/the-state-monad-a-tutorial-for-the-confused/

A bit of self-promotion:

[6] http://faustinelli.wordpress.com/2014/04/25/the-state-monad-in-java-8-eventually/

[7] http://faustinelli.wordpress.com/2014/06/01/state-monad-goes-to-js-town-and-starts-swinging/

Every feedback is welcome.

--------------------------
Released under MIT License.

repository: Muzietto/geiesmonads

repo_name: Muzietto/geiesmonads


text:
# Overview

This example shows how to use [@opentelemetry/sdk-metrics](https://github.com/open-telemetry/opentelemetry-js/tree/main/packages/opentelemetry-sdk-metrics) to instrument a simple Node.js application and export metrics to [Google Cloud Monitoring](https://cloud.google.com/monitoring/).

## Installation

```sh
# from root of repo, build all packages
npm install
```

## Run the Application

```sh
# from this directory
npm start
```

## View metrics

https://console.cloud.google.com//monitoring/metrics-explorer?project=your-project-id

1. Select the Metric from the dropdown. You should see it under the resource "Generic Task":

2. View the timeseries:

## Useful links
- For more information on OpenTelemetry, visit: <https://opentelemetry.io/>
- For more information on metrics, visit: <https://opentelemetry.io/docs/concepts/signals/metrics/>

## LICENSE

Apache License 2.0

gha_language: TypeScript


text:
# Get live updates on COVID-19

This Python program will collect COVID-19 worldwide stats and send it to your mobile phone in text message.

### Demo

### Twilio Account

You will need your own _Twilio phone number_, _Account SID_ and _Authentication Token_ in order to send SMS using [Twilio API](https://www.twilio.com/). Fill in the credentials to `config.py` file under the following section:

```python
TO = ['{TO_NUMBER}', '{TO_NUMBER}', '{TO_NUMBER}']
FROM_ = '{YOUR_TWILIO_NUMBER}'
ACCOUNT_SID = '{YOUR_ACCOUNT_SID}'
AUTH_TOKEN = '{YOUR_AUTH_TOKEN}'
```

### Choose Countries

You can configure which countries' stats to include in the SMS message. Add the list of desired countries in `config.py` file like below:

For example

```python
# Country List
countries = ['China', 'U.K.', 'USA', 'Australia', 'Canada', 'Japan']
```

### How-To Guide

To see how to set up this Python program as an automated serverless function using **Azure Functions**, follow this easy-to-read blog on my blog site https://jixjia.com/2020/02/18/python-serverless-function

### Credit

Special thanks to www.worldometers.info for kindly providing reliable digest information on the 2019-nCoV update sourced from CDC and WHO.

gha_language: Python


text:
# Entangle-Python [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)

Did you ever think syncing variables between two processes (anywhere in the world) is difficult?
Entangle-Python is your solution.
It enables you to entangle two variables across processes.
One needs to launch an entanglement server and one an entanglement client.
You can connect entanglements even cross programming language.

You can see the documentation below or simply look at some examples.

A python server and client in one script can be found [here](https://github.com/penguinmenac3/entangle-python/blob/master/example.py).
If you want only a server to which for example [entangle-js](https://github.com/penguinmenac3/entangle-js) can connect to, check out [this script](https://github.com/penguinmenac3/entangle-python/blob/master/example_server.py).

## Install

Simply pip install the package.

```bash
pip install entangle-python
```

### Creating an SSL Certificate

SSL Certificates are required for SSL encryption (this is optional but highly recommended).

Create a folder where your certs should live and create a password with or without a password.

```bash
mkdir certs
cd certs

# with password (secure)
openssl req -x509 -newkey rsa:4096 -keyout key.pem -out cert.pem -days 365
# or without passwort (insecure)
#openssl req -x509 -nodes -newkey rsa:4096 -keyout key.pem -out cert.pem -days 365
```

## Usage

### Entanglement Server

Listen for entanglement requests and handle them.
Inside the callback you can do whatever you want, it is a new thread and does not hinder new entanglements from happening.
Note that an entanglement object corresponds to a client.

```python
import entangle

# Define a callback for every new entanglement
def on_entangle(entanglement):
    def rprint(x):
        print(x)
        entanglement.test = x

    entanglement.rprint = rprint

# Listen for entanglements (listenes in blocking mode)
entangle.listen(host="localhost", port=12345, password="42", callback=on_entangle, ssl_root="certs")
```

### Entanglement Client

If your script wants to connect to an entanglement server use the following.
The connect function connects asynchronously to a server.
Once an entanglement is established your callback gets called.

```python
import entangle

def on_entangle(entanglement):
  entanglement.remote_fun("rprint")("Hello Universe!")
  entanglement.close()

# asynchronously connect to a client (entanglement spawns a daemon thread)
entangle.connect(host="localhost", port=12345, password="42", callback=on_entangle, use_ssl=True)
```


text:
# ESP8266-based-9-channel-Wi-Fi-relay

You can find the code and a circuit of this device here:  https://github.com/Northstrix/ESP8266-based-9-channel-Wi-Fi-relay

To build this device you need:
1) One ESP8266
2) Two ULN2003
3) Nine relays
4) Power source(s) that can provide 12 volts and enough current for relays as well as supply ESP8266 (3.3V or 5V)

Note: If you're using 5 volts power supply then you should put "+" of your power supply to the "Vin" pin.

If you're using 3.3 volts power supply then put "+" of your power supply to the "3V3" pin.

In both cases you have to put "-" of your power supply to the "GND" pin.

The state of each channel is individually controlled and completely independent from one another.

It's not a dimmer. Each channel has only two states "ON" and "OFF".

You can expand the number of channels up to 11, but I wouldn't recommend you to do so.


text:
---
name: Query-Use Case
about: New query from Jackie
title: "[Query]"
labels: 21Q*-D4
assignees: dcarsey

---

**Query**
Source of Query: Jackie
Query description:

**Describe the solution you'd like**
A clear and concise description of what you want to happen.

**Describe alternatives you've considered**
A clear and concise description of any alternative solutions or features you've considered.

**Additional context**
Add any other context or screenshots about the feature request here.

**In order to close this ticket:**
- [ ] Write SQL to answer queries, identify missing fields [Data Modeler]
- [ ] Write script to answer queries with CTMD, identify missing proposal_table fields, and if join is needed, missing tools[Data Modeler]
- [ ] Add missing fields to dashboard proposal table [Developer]
- [ ] Review/compare answers with expected [PM/Data Modeller/Vandy/Duke]
- [ ] Write tickets for any new Features/Tools requested from above [PM]
- [ ]  Add SQL and dashboard tests to automated tests, update expected output of existing tests with cut-off submission date as current date  [Developer]
- [ ] If a new field has been created, confirm with Jackie whether that field should be added as a tickbox to CTMD

repository: RENCI/ctmd

repo_name: RENCI/ctmd


text:
# mnaidoo2018

[![CI Status](https://img.shields.io/travis/miinnie19/mnaidoo2018.svg?style=flat)](https://travis-ci.org/miinnie19/mnaidoo2018)
[![Version](https://img.shields.io/cocoapods/v/mnaidoo2018.svg?style=flat)](https://cocoapods.org/pods/mnaidoo2018)
[![License](https://img.shields.io/cocoapods/l/mnaidoo2018.svg?style=flat)](https://cocoapods.org/pods/mnaidoo2018)
[![Platform](https://img.shields.io/cocoapods/p/mnaidoo2018.svg?style=flat)](https://cocoapods.org/pods/mnaidoo2018)

## Example

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

## Requirements

## Installation

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

```ruby
pod 'mnaidoo2018'
```

## Author

miinnie19<EMAIL_ADDRESS>
## License

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


text:
# twitter-promotion-dapp

### Deploy TwitterTask contract - Testnet (Kovan)

1. Create a file by name `.env` inside the root directory of this project. Paste the following lines inside this .env file

```
ALCHEMY_API_KEY = 'YOUR_ALCHEMY_API_KEY"
WALLET_PRIVATE_KEY = 'YOUR_WALLET_PRIVATE_KEY'
```

2. Replace `YOUR_ALCHEMY_API_KEY` with API key created using Alchemy

3. Replace `YOUR_WALLET_PRIVATE_KEY` with private key obtained by following these steps

    1. Click on metamask plugin icon in the browser
    2. Select `Account details`
    3. Click `Export Private Key` button and confirm your password

4. Run the following command to deploy faucet on kovan network

    `npx hardhat run scripts/deploy.js --network kovan`

5. Copy the contract address printed to console and replace the already existing address in `src/constants.js` with it.

**Note:** You can skip the contract deployment steps and by default the setup would use an already deployed contract.

### Run Project

1. Install dependencies

    `npm install`

2. Run app

    `npm start`


text:
<!--
    PropsExpedition adheres to the [JS Foundation Code of Conduct](https://js.foundation/community/code-of-conduct).

    This template is for bug reports. If you are reporting a bug, please continue on. If you are here for another reason, please see below:

    - To propose a new feature: [Contributing](./CONTRIBUTING.md)

    Note that leaving sections blank will make it difficult for us to troubleshoot and we may have to close the issue.
-->

**Tell us about your environment**

* **Package Version:**
* **Node Version:**
* **npm/yarn Version:**

**What did you do? Please include the actual source code causing the issue.**

<!-- Paste the source code below: -->
```js

```

**What did you expect to happen?**

**What actually happened?**

repository: jdolle/props-expedition

repo_name: jdolle/props-expedition


text:
# minifill.js - the essential polyfill
Ever wondered how to fix old browsers, improve scripting execution performance, simplify scripting and improve overall code quality all without using jQuery? The answer is polyfills.

[![jsDeliver](https://data.jsdelivr.com/v1/package/npm/minifill/badge)](https://www.jsdelivr.com/package/npm/minifill)
[![CDNJS](https://img.shields.io/cdnjs/v/minifill.svg?style=flat-square)](https://cdnjs.com/libraries/minifill)

The polyfills come from various sources to which I give full credits:
* [Financial Times](https://polyfill.io/) polyfill service
* Remy Sharp (the one who came with the name of `polyfill`)
* Mozilla Developer Network

When you use the above service, there is a certain amount of delay involved when executing the polyfill queries, as well as some unexplained in page script execution lags, a case where it's best to just host your own polyfills, and here comes minifill handy.

TIP: My other libraries such as [bootstrap.native](https://github.com/thednp/bootstrap.native) and [KUTE.js](https://github.com/thednp/kute.js) work best with minifill.

## A minimal polyfill with most essential stuff:

* **this.Document** - IE8 doesn't know who is `this.Document`, it's `this.HTMLDocument`
* **this.Window** - older Safari doesn't know who is `this.Window`, it's `this`
* **window.HTMLElement** - IE8 doesn't know who is `window.Element`, it's `window.HTMLElement`
* **window.Node** - IE8 doesn't know who is `window.Node`, it's `window.Element`

* **Object.defineProperty** - important for the below `classList`
* **Object.keys** - returns an array populated with the object's keys

* **Array.from** - creates a new, shallow-copied `Array` instance from an array-like or iterable object, usually `NodeList`, `HTMLCollection`
* **Array.prototype.every** - tests whether all elements in the array pass the test implemented by the provided function
* **Array.prototype.find** - returns the value of the first element in the provided array that satisfies the provided testing function
* **Array.prototype.forEach** - executes a provided function once for each array element.
* **Array.prototype.flat** - creates a new array with all sub-array elements concatenated into it recursively up to the specified depth.
* **Array.prototype.includes** - determines whether an array includes a certain value among its entries
* **Array.prototype.map** - *creates a new array* populated with the results of calling a provided function on every element in the calling array
* **Array.prototype.some** - tests whether at least one element in the array passes the test implemented by the provided function

* **Multi.prototype.indexOf** - checks inside strings and arrays for particular values
* **Multi.addEventListener** - uses the deprecated `attachEvent` API to help legacy browsers
* **Multi.getElementsByClassName** - a `querySelectorAll` based polyfill for `document`/`Element`
* **Multi.Event** - the complete polyfill, implements `createEvent` or `createEventObject` to make HTML4 browsers as well as IE8-IE11 work properly with today's standard `Event`
* **Multi.CustomEvent** - the complete polyfill, makes use of the above `new Event()` for stuff like unsupported events types or user defined events like `my.custom.event`, this also works with IE8-IE11
* **Multi.dispatchEvent** - uses the deprecated `fireEvent` API on legacy browsers

* **Element.prototype.matches** - the complete `matches` polyfill
* **Element.prototype.classList** - class manipulation mostly for IE8 and other HTML4 browsers, inspired by [Remy's](https://github.com/remy/polyfills/blob/master/classList.js) `classList`
* **Element.prototype.closest** - uses the above `matches` to find the closest parent element that matches the selector

* **Date.now** - required by the below `requestAnimationFrame` and other stuff, uses the `new Date().getTime()` synthax to return the current time
* **String.prototype.includes** - a quick fill by MDN
* **String.prototype.trim** - yeah `trim` eventually
* **Node.prototype.contains** - checks for parental relation between elements
* **NodeList.prototype.forEach** - simple `forEach` polyfill, executes a provided function once for each element in a `Nodelist`.

* **window.getComputedStyle** - the complete `getComputedStyle` polyfill, returns the true dimensions, spacing, or other browser supported properties
* **window.performance.now** - required for KUTE.js and other stuff, when accuracy is required for the current time
* **window.requestAnimationFrame** - also required for KUTE.js

## What is minifill.js for
* HTML4 browsers that don't support/recognize these methods/objects
* all IE browsers don't have any/enough support for the today's standard `Event`
* busting the myth of `write less, do more`

## How to use minifill.js
* Download or copy link from jsdelivr or cdnjs
* Add one of the following to your head tag

```html
<!-- if you wanna use it locally -->
<script nomodule type="text/javascript" src="../assets/js/minifill.min.js"></script>

<!-- if you wanna use JSDELIVR -->
<script nomodule type="text/javascript"<EMAIL_ADDRESS>
<!-- if you wanna use CDNJS -->
<script nomodule type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/minifill/0.0.4/minifill.min.js"></script>
```

## Custom builds
You can create your own builds specific to your application bundles, but make sure to keep the same order as for the `minifill.js`.
* create a new file `/path-to/your-file.js`
* copy contents of the `minifill.js`
* edit out the polyfills you don't need
* run `npm run custom INPUTFILE:path-to/your-file.js,OUTPUTFILE:path-to/your-build.js,FORMAT:esm,MIN:false`
  **  `INPUTFILE` - allows you to specify the source file path
  **  `OUTPUTFILE` - allows you to specify the output file path
  **  `MIN` - when true, it will compress the output
  **  `FORMAT` - umd|cjs|esm and any format you specify or configure your rollup for

## Examples
Class Manipulation

```javascript
// check for a class
var docHasClass = myElement.classList.contains('someClass'); // return true|false

// add a class
myElement.classList.add('someClass');

// remove a class
myElement.classList.remove('someClass');

// toggle a class
myElement.classList.toggle('someClass');
```

String / Array checks

```javascript
// indexOf
string.indexOf('looking for this'); // returns the index of 'looking for this' within the string OR -1 if not found
// or
array.indexOf(myElement); // returns the index of an element within the array OR -1 if not found
```

Get current computed style for an element

```javascript
// getComputedStyle
var elStyle = window.getComputedStyle(myElement); // returns the current computed style for myElement
var width = elStyle.width; // returns the current computed width
```

Get the exact current time

```javascript
// window.performance.now
var timeNow = window.performance.now(); // returns a number with the exact current time
```

Create Native Events

Instead of writing

```javascript
// typical triggering events these days
if ( 'createEventObject' in document ) {
	myChangeEvent = document.createEventObject();
	myChangeEvent.type = type;
	myChangeEvent.bubbles = bubbles;
	myChangeEvent.cancelable = cancelable;
} else {
	myChangeEvent = document.createEvent('Event');
	myChangeEvent.initEvent(type, bubbles, cancelable);
}
```
you can simply write

```javascript
// Event
var myChangeEvent = new Event('change'); // creates 'change' Event Element / Object (legacy browsers)
```
to do it all for you.

Create Custom Events

```javascript
// CustomEvent
var myCustomEvent = new CustomEvent('my.custom.event.name'); // creates 'my.custom.event.name' CustomEvent Element / Object (legacy browsers)
```

Triggering/Dispatching Events

```javascript
myElement.dispatchEvent(myChangeEvent); // dispatches the native 'change' event for myElement, defined above
myElement.dispatchEvent(myCustomEvent); // dispatches a CustomEvent event for myElement, defined above
```

Adding Event Handlers

```javascript
// addEventListener
window.addEventListener('scroll',handler,false); // adds a new handler to the window `scroll` event
// OR
myButton.addEventListener('click',handler,false); // adds a 'click' (or any other supported/custom event) handler for any HTML element
```

Removing Event Handlers

```javascript
// removeEventListener
window.removeEventListener('scroll',handler,false); // removes a handler bound to the window `scroll` event
// OR
myButton.removeEventListener('click',handler,false); // removes a handler bound to 'click' (or any other supported/custom event) handler for any HTML element
```
NOTE: if the `removeEventListener` call is not in the same context with `addEventListener`, it will produce no effect. If you would like to autoremove a handler, you would need to write your code like this:

```javascript
window.addEventListener('scroll', function handlerWrapper(e){
  handler(e);
  window.removeEventListener('scroll', handlerWrapper, false);
},false);
```

## License
minifill.js is licensed under MIT License.

repository: thednp/minifill

repo_name: thednp/minifill


text:
# New Open Source Maintainer Onboarding

New OSM's will be formally onboarded.

In traditional open source a new contributor comes to a project <oven ready> knowing the programming language, development tools and infrastrucuture from some other life.

For this OSM programme the new developer cannot be expected to have any knowledge of these things - and the onboarding reflects that.

## What The Onboarding Will Cover

The scope of this onboarding is:

* stuff you need
    * an Erlang book
    * an APL keyboard
* development tools
    * what we use
    * why we use them
    * how to install them
    * how to use them
* short introduction to Erlang
    * how to learn Erlang
    * what you don't need to learn
        * Pometo is a purely functional project there is no use of:
             * OTP, gen servers
             * message passing/the actor model/concurrency
* introduction to the language toolchain

The onboarding will self-paced with checkpoints.

## Step 1: Read All The Things

You should read the following pages:

* read the [Code Of Conduct](./pometo_contributors_code_of_conduct.md)
* read the [language roadmap](./the_language_roadmap.md)
    * have a play with the Dyalog [live REPL](https://tryapl.org/)
* [our development environment](./our_development_environment.html)
* read about the [development cycle](./the_development_cycle.md)

***Checkpoint***: a discussion with your mentor about what you have learned

## Step 2: Install All The Things

* [the software](./our_development_environment.md)
* [the fonts](./eek_how_do_I_even_type_this.md)

***Checkpoint***: a screen-share with your mentor to make sure everything works well

## Step 3: Play With Erlang

You will have been bought a modern Erlang book. You need to spend a bit of time writing simple Erlang programmes.

There are two aspects to Erlang programming:

* using the basic language
* leveraging the BEAM infrastructue and OTP to build highly-available and concurrent software

`pometo` only requires the first. In Joe Armstrong's book *Programming Erlang* he only devotes 55 pages out of 500 to the basic language. That's all you need. It is small, if slightly unfamiliar.

For this stage you will use an Erlang shell running inside the installed Docker environment that you created for developing `pometo`.

***Checkpoint***: a screenshare with your mentor exploring the language.

If necessary this step can be repeated.

## Step 4: Your First Test

You need to write a simple test like `1 + 2` and then run it.

***Checkpoint***: a screnshare with your mentor

## Step 5: Your First Commit

We have a number of functions are are oven ready and simple to write, including:

* `*` the power function
* `⌈` the maximum and `⌊` the minimum functions
* the relationship functions `<`, `≤`, `=`, `≥`, `>` and `≠`

To implement a function, you:

* write the docs page for it as a work in progress
* raise a PR for that
* get a PR review
* implement the function
   * making sure the function tests past
   * making sure all the other tests past
* create a final PR for approval which
   * adds the WIP docs page to the main docs repo
   * makes it public

There are no checkpoints in this stage - it all happens in the PRs.

## Step 6: Introduction To The Toolchain

![The toolchain](../images/simple_toolchain.png)

***Presentation***: a presentation walking through the toolchain:

* multi-stage lexer
* parser
* interpreter
* compiler
* runtime

The simple getting-started tasks will only involve tiny changes to the lexer and then building functions in the runtime. The parser, interpreter and compiler will just ensure new symbols are mapped to the appropriate function in the runtime.

This presentation will also include bugs, features and other project housekeeping.

## Fly My Pretties, Fly

You are now a fully fledged contributor. There will be weekly meetings with your mentor but most stuff will happen in the repo, the PRs, the code comments, the issues, bugs

repository: cannadayr/pometo

repo_name: cannadayr/pometo