text:
# em-calibration
Electron microscopy image calibration utilities for grids and measurements

## Usage
Use python 3.6 or later

## GridProcessor Usage
1. Initialize the GridProcessor:
Grid Processor accept two parameters: 1. the path of the image, 2. size of each grid(in nanomaters)

```
path = 'C:\\Users\\08_01615.tif'
processor = GridProcessor(path, '463nm')
```

2. Calculate the average distance among grid lines (nanometers per pixel)
```
print(processor.get_scalar())
```

## GridIdentifier Usage
This is a fast identifier to help you quickly identify if an image is a grid image is not.
For example:
```
from grid_identifier import is_grid
path = 'C:\\Users\\08_01615.png'
print(if_grid(path))
```

repository: najafian-lab/em-calibration

repo_name: najafian-lab/em-calibration


text:
# Note-Taker Application
### Description
This application was designed with the intention of providing the user with a means of efficiently creating, saving, and deleting notes on a local server. In launching this application on a localhost address, the user is presented with a clean interface that allows them to title their note, provide content, and save this note which will appear in a column on the left side, in the order in which they're created. Following this initial step, users are able to select their previously completed notes and choose to edit or delete notes from their local server.

![alt text](https://github.com/ChristineClemens/NoteTakerApplication/blob/master/Assets/NoteTakerApplication.PNG)

### Table of Contents
- [Installation](#Installation)
- [Usage](#Usage)
- [License](#License)
- [Contributors](#Contributors)
- [Questions](#Questions)

### Installation
- node.js (https://nodejs.org/en/)
- fs (npm install fs)
- express (npm install express)

### Usage
In order to use this application effectively, please download the files stored in the Git repository listed below. Be sure to have the node.js server environment installed as well as the fs and express modules that can be downloaded by entering “npm install <module>” in the command line. Enter "node server.js" in the command line to ensure that you are listening on the correct port, then type "localhost:8080" into the url search bar in your browser. You should be met with a functional application!

Alternatively, you may use the functional deployed application at: https://aqueous-dusk-95036.herokuapp.com/

### License
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

    Copyright (c) 2020 Christine Clemens

    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.
### Contributors
There are currently no contributions to this project. If you would like to become a contributor, please contact me at the email address specified below!

### Questions
| Please direct your inquiries here! |
| :---: |
| ![alt text](https://avatars2.githubusercontent.com/u/64107231?v=4 "Github Profile Picture") |
| <a href=<EMAIL_ADDRESS>target="_blank">Contact Me |
**This project was created by Christine Clemens.**

*GitHub Repository:* https://github.com/ChristineClemens/NoteTakerApplication

license: MIT

repository: ChristineClemens/NoteTakerApplication

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: ChristineClemens/NoteTakerApplication


text:
# Reddit Dataset (Preprocessed for Oort)

## Organization

The [dataset](https://fedscale.eecs.umich.edu/dataset/reddit.tar.gz) is splited into training and testing set. Random ids were assigned to each client and client ids are encoded in the file name.

# References
This dataset is covered in more detail at [https://github.com/TalwalkarLab/leaf/tree/master/data/reddit](https://github.com/TalwalkarLab/leaf/tree/master/data/reddit) and Its original location is at
[https://files.pushshift.io/reddit/](https://files.pushshift.io/reddit/).


text:
# Carbon Aware CLI

The CLI is best for use with systems you can not change the code in but can
invoke command line. For example - build pipelines.

The CLI exposes the primary `getEmissionsByLocationsAndTime` SDK methods via
command line and outputs the results as json to stdout.

> You can use the CLI via a docker image.

- [Carbon Aware CLI](#carbon-aware-cli)
  - [Build and Install](#build-and-install)
  - [Using the CLI](#using-the-cli)
  - [emissions](#emissions)
    - [Description](#description)
    - [Usage](#usage)
    - [Options](#options)
    - [Examples](#examples)
      - [Single Location Emissions](#single-location-emissions)
      - [Multiple Location Emissions](#multiple-location-emissions)
      - [Emissions with Start and End Times](#emissions-with-start-and-end-times)
  - [emissions-forecasts](#emissions-forecasts)
    - [Description](#description)
    - [Usage](#usage)
    - [Options](#options)
    - [Examples](#examples)
      - [Single Location Current Forecast](#single-location-current-forecast)
      - [Multiple Location Current Forecasts](#multiple-location-current-forecasts)
      - [Filtered Data and Window Size Forecast](#filtered-data-and-window-size-forecast)
      - [Historical Forecast](#historical-forecast)

## Build and Install

Build the CLI using the `dotnet publish` command:

```bash
dotnet publish ./src/CarbonAware.CLI/src/CarbonAware.CLI.csproj -c Release -o <your desired installation path>
```

> By default this will build for your host operating system. To build for a
> platform other than your host platform you can specify the target runtime like
> this, using any valid
> [Runtime ID](https://docs.microsoft.com/en-us/dotnet/core/rid-catalog#using-rids)
> (EG `win-x64`, `linux-x64`, `osx-x64`):
>
> ```bash
> dotnet publish .\src\CarbonAware.CLI\src\CarbonAware.CLI.csproj -c Release -r <RuntimeID> --self-contained -o <your desired installation path>
> ```

## Using the CLI

To use the CLI for the first time, navigate to your installation directory and
run the binary with the `-h` flag to see the help menu.

On Windows:

```bash
.\caw.exe -h
```

On MacOS/Linux:

```bash
.\caw -h
```

## emissions

### Description

Retrieve emissions data from specified locations and time periods.

### Usage

`caw emissions [options]`

### Options

```text
  -l, --location <location> (REQUIRED)  A named location
  -s, --start-time <startTime>          Start time of emissions data
  -e, --end-time <endTime>              End time of emissions data
  -b, --best                            Filter results down to the best (typically lowest) data point.
  -a, --average                         Outputs the weighted average of all data points within the start and end time boundaries.
  -?, -h, --help                        Show help and usage information
```

### Examples

#### Single Location Emissions

command:

```bash
.\caw.exe emissions -l eastus
```

output:

```json
[
  {
    "Location": "eastus",
    "Time": "2022-08-30T12:45:11+00:00",
    "Rating": 65,
    "Duration": "08:00:00"
  },
  {
    "Location": "eastus",
    "Time": "2022-08-30T20:45:11+00:00",
    "Rating": 65,
    "Duration": "08:00:00"
  },
  // ...
  {
    "Location": "eastus",
    "Time": "2022-09-06T04:45:11+00:00",
    "Rating": 73,
    "Duration": "08:00:00"
  },
  {
    "Location": "eastus",
    "Time": "2022-09-06T12:45:11+00:00",
    "Rating": 84,
    "Duration": "08:00:00"
  }
]
```

#### Multiple Location Emissions

command:

```bash
.\caw emissions -l eastus -l westus
```

output:

```json
[
  {
    "Location": "eastus",
    "Time": "2022-08-30T12:45:11+00:00",
    "Rating": 65,
    "Duration": "08:00:00"
  },
  {
    "Location": "eastus",
    "Time": "2022-08-30T20:45:11+00:00",
    "Rating": 65,
    "Duration": "08:00:00"
  },
  // ...
  {
    "Location": "westus",
    "Time": "2022-09-06T04:45:11+00:00",
    "Rating": 73,
    "Duration": "08:00:00"
  },
  {
    "Location": "westus",
    "Time": "2022-09-06T12:45:11+00:00",
    "Rating": 84,
    "Duration": "08:00:00"
  }
]
```

#### Emissions with Start and End Times

command:

```bash
.\caw emissions -l eastus --start-time 2022-07-01T00:00:00Z --end-time 2022-07-31T23:59:59Z --best
```

output:

```json
[
  {
    "Location": "eastus",
    "Time": "2022-07-01T04:45:11+00:00",
    "Rating": 65,
    "Duration": "08:00:00"
  },
  {
    "Location": "eastus",
    "Time": "2022-07-01T12:45:11+00:00",
    "Rating": 65,
    "Duration": "08:00:00"
  },
  // ...
  {
    "Location": "eastus",
    "Time": "2022-07-31T12:45:11+00:00",
    "Rating": 73,
    "Duration": "08:00:00"
  },
  {
    "Location": "eastus",
    "Time": "2022-07-31T20:45:11+00:00",
    "Rating": 84,
    "Duration": "08:00:00"
  }
]
```

#### Best Emissions

command:

```bash
.\caw emissions -l eastus -l westus --start-time 2022-07-01T00:00:00Z --end-time 2022-07-31T23:59:59Z --best
```

output:

```json
[
  {
    "Location": "eastus",
    "Time": "2022-07-08T04:45:11+00:00",
    "Rating": 48,
    "Duration": "08:00:00"
  }
]
```

#### Average Emissions

command:

```bash
.\caw emissions -l eastus -l westus --start-time 2022-07-09T00:00:00Z --end-time 2022-07-09T12:00:00Z --average
```

output:

```json
[
  {
    "Location": "eastus",
    "Time": "2022-07-09T00:00:00+00:00",
    "Rating": 79.357,
    "Duration": "12:00:00"
  },
  {
    "Location": "westus",
    "Time": "2022-07-09T00:00:00+00:00",
    "Rating": 86.91243,
    "Duration": "12:00:00"
  }
]
```

## `emissions-forecasts`

### Description

Forecasted emissions

### Usage

`caw emissions-forecasts [options]`

### Options

```text
  -l, --location <location> (REQUIRED)  A list of locations
  --data-start-at <startTime>           Filter out forecasted data points before start at time.
  --data-end-at <endTime>               Filter out forecasted data points after end at time.
  -w, --window-size <INT>                   The estimated duration (in minutes) of the workload being forecasted. Defaults to the duration of a single forecast data point
  --requested-at                        Datetime of a previously generated forecast.  Returns the most current forecast if not provided.
  -?, -h, --help                        Show help and usage information
```

### Examples

#### Single Location Current Forecast

command:

```bash
.\caw emissions-forecasts -l northeurope
```

output:

```json
[{
  "requestedAt": "2022-07-19T13:37:49+00:00",
  "generatedAt": "2022-07-19T13:35:00+00:00",
  "location": "northeurope",
  "dataStartAt": "2022-07-19T14:00:00Z",
  "dataEndAt": "2022-07-20T04:38:00Z",
  "windowSize": 5,
  "optimalDataPoint": {
    "location": "IE",
    "timestamp": "2022-07-19T18:45:00+00:00",
    "duration": 5,
    "value":<PHONE_NUMBER>375
  },
  "forecastData": [
    {
      "location": "IE",
      "timestamp": "2022-07-19T14:00:00+00:00",
      "duration": 5,
      "value":<PHONE_NUMBER>6
    },
    ...
    {
      "location": "IE",
      "timestamp": "2022-07-20T04:30:00+00:00",
      "duration": 5,
      "value":<PHONE_NUMBER>001667
    }
  ]
}]
```

#### Multiple Location Current Forecasts

command:

```bash
.\caw emissions-forecasts -l eastus -l westus
```

output:

```json
[
  {
    "requestedAt": "2022-06-01T12:01:00+00:00"
    "generatedAt": "2022-06-01T12:00:00+00:00",
    "optimalDataPoint": {
      "location": "PJM_ROANOKE",
      "timestamp": "2022-06-01T16:45:00+00:00",
      "duration": 5,
      "value":<PHONE_NUMBER>375
    },
    "forecastData": [ ... ] // all relevant forecast data points
    "location": "eastus",
    "dataStartAt": "2022-06-01T14:05:00+00:00",
    "dataEndAt": "2022-06-02T14:00:00+00:00",
    "windowSize": 5,
  },
  {
    "requestedAt": "2022-06-01T12:01:00+00:00"
    "generatedAt": "2022-06-01T12:00:00+00:00",
    "optimalDataPoint": {
      "location": "CAISO_NORTH",
      "timestamp": "2022-06-13T09:25:00+00:00",
      "duration": 5,
      "value": 328.178478
    },
    "forecastData": [ ... ] // all relevant forecast data points
    "location": "westus",
    "dataStartAt": "2022-06-01T14:05:00+00:00",
    "dataEndAt": "2022-06-02T14:00:00+00:00",
    "windowSize": 5,
  }
]
```

#### Filtered Data and Window Size Forecast

> Note: For current forecasts, since the data filters must fall within the
> forecasted data points, it is advisable to create them dynamically.

Example command:

```bash
TIME_TWO_HOURS_FROM_NOW=$(date --date='2 hours' --utc --iso-8601='seconds')

TIME_NINETEEN_HOURS_FROM_NOW=$(date --date='19 hours' --utc --iso-8601='seconds')

.\caw emissions-forecasts -l northeurope -l westus --data-start-at TIME_TWO_HOURS_FROM_NOW --data-end-at TIME_NINETEEN_HOURS_FROM_NOW -w 10
```

Example output:

```json
[{
  "requestedAt": "2022-07-19T13:37:49+00:00",
  "generatedAt": "2022-07-19T13:35:00+00:00",
  "location": "northeurope",
  "dataStartAt": "2022-07-19T15:37:49+00:00",
  "dataEndAt": "2022-07-20T08:37:49+00:00",
  "windowSize": 10,
  "optimalDataPoint": {
    "location": "IE",
    "timestamp": "2022-07-19T18:45:00+00:00",
    "duration": 10,
    "value":<PHONE_NUMBER>375
  },
  "forecastData": [
    {
      "location": "IE",
      "timestamp": "2022-07-19T15:40:00+00:00",
      "duration": 10,
      "value":<PHONE_NUMBER>6
    },
    ...
    {
      "location": "IE",
      "timestamp": "2022-07-20T08:30:00+00:00",
      "duration": 10,
      "value":<PHONE_NUMBER>001667
    }
  ]
},
{
  "requestedAt": "2022-07-19T13:37:49+00:00",
  "generatedAt": "2022-07-19T13:35:00+00:00",
  "location": "westus",
  "dataStartAt": "2022-07-19T15:37:49+00:00",
  "dataEndAt": "2022-07-20T08:37:49+00:00",
  "windowSize": 10,
  "optimalDataPoint": {
    "location": "CAISO_NORTH",
    "timestamp": "2022-07-19T18:45:00+00:00",
    "duration": 10,
    "value":<PHONE_NUMBER>6
  },
  "forecastData": [
    {
      "location": "CAISO_NORTH",
      "timestamp": "2022-07-19T15:40:00+00:00",
      "duration": 10,
      "value":<PHONE_NUMBER>
    },
    ...
    {
      "location": "CAISO_NORTH",
      "timestamp": "2022-07-20T08:30:00+00:00",
      "duration": 10,
      "value":<PHONE_NUMBER>57
    }
  ]
}]
```

#### Historical Forecast

command:

```bash
.\caw emissions-forecasts -l northeurope -l westus --requested-at 2022-06-15T18:31:00Z
```

output:

```json
[{
  "requestedAt": "2022-06-15T18:31:00+00:00",
  "generatedAt": "2022-06-15T18:30:00+00:00",
  "location": "northeurope",
  "dataStartAt": "2022-06-15T18:35:00+00:00",
  "dataEndAt": "2022-06-16T18:30:00+00:00",
  "windowSize": 5,
  "optimalDataPoint": {
    "location": "IE",
    "timestamp": "2022-06-15T23:40:00+00:00",
    "duration": 5,
    "value":<PHONE_NUMBER>375
  },
  "forecastData": [
    {
      "location": "IE",
      "timestamp": "2022-06-15T18:35:00+00:00",
      "duration": 5,
      "value":<PHONE_NUMBER>6
    },
    ...
    {
      "location": "IE",
      "timestamp": "2022-06-16T18:25:00+00:00",
      "duration": 5,
      "value":<PHONE_NUMBER>001667
    }
  ]
},
{
  "requestedAt": "2022-06-15T18:31:00+00:00",
  "generatedAt": "2022-06-15T18:30:00+00:00",
  "location": "westus",
  "dataStartAt": "2022-06-15T18:35:00+00:00",
  "dataEndAt": "2022-06-16T18:30:00+00:00",
  "windowSize": 5,
  "optimalDataPoint": {
    "location": "CAISO_NORTH",
    "timestamp": "2022-06-15T23:40:00+00:00",
    "duration": 5,
    "value":<PHONE_NUMBER>375
  },
  "forecastData": [
    {
      "location": "CAISO_NORTH",
      "timestamp": "2022-06-15T18:35:00+00:00",
      "duration": 5,
      "value":<PHONE_NUMBER>6
    },
    ...
    {
      "location": "CAISO_NORTH",
      "timestamp": "2022-06-16T18:25:00+00:00",
      "duration": 5,
      "value":<PHONE_NUMBER>008
    }
  ]
}]
```

##### Locations

command: `.\caw locations`

output:

```json
{
  "eastus": {
    "Latitude": 37.3719,
    "Longitude": -79.8164,
    "Name": "eastus"
  },
  ...
  "switzerlandnorth":{
    "Latitude": 47.451542,
    "Longitude": 8.564572,
    "Name": "switzerlandnorth"
  },
  ...
}
```

branch_name: refs/heads/dev

gha_language: C#

gha_license_id: MIT


text:
# Invoicer

Invoicer is a simple tool to construct invoices. Invoices are saved in
JSON format.

## Planned Features:
* Support for invoices billing by hour, billing by item, and a mixture
  of the two.
* Create Invoices by inputting information about yourself, the client,
  billing rates and line items.
* Export to PDF, TeX and Markdown
* Preview invoices in PDF format
<!--
## Dependencies
You will have to install development headers for the following:
* bzip2-devel
* freetype-devel
* glib2-devel
* glibc-devel
* graphite2-devel
* harfbuzz-devel
* libX11-devel
* libXau-devel
* libXext-devel
* libgcrypt-devel
* libglvnd-devel
* libgpg-error-devel
* libicu-devel
* libpng-devel
* libxcb-devel
* lz4-devel
* pcre-devel
* pcre2-devel
* qt5-qtbase-devel
* systemd-devel
* xz-devel
* zlib-devel
-->
<!--
* bzip2-devel
* freetype-devel
* glib2-devel
* glibc-devel
* graphite2-devel
* harfbuzz-devel
* libX11-devel
* libXau-devel
* libXext-devel
* libgcrypt-devel
* libglvnd-devel
* libgpg-error-devel
* libicu-devel
* libpng-devel
* libxcb-devel
* lz4-devel
* pcre-devel
* pcre2-devel
* qt5-qtbase-devel
* systemd-devel
* xz-devel
* zlib-devel
-->
<!--
**Fedora**
```
sudo dnf install freetype-devel glib2-devel glibc-devel graphite2-devel \
harfbuzz-devel libX11-devel libXau-devel libXext-devel libgcrypt-devel \
libglvnd-devel libgpg-error-devel libicu-devel libpng-devel libxcb-devel \
lz4-devel pcre-devel pcre2-devel qt5-qtbase-devel systemd-devel xz-devel \
zlib-devel
```
**Ubuntu**
```
sudo apt-get install freetype-devel glib2-devel glibc-devel graphite2-devel \
harfbuzz-devel libX11-devel libXau-devel libXext-devel libgcrypt-devel \
libglvnd-devel libgpg-error-devel libicu-devel libpng-devel libxcb-devel \
lz4-devel pcre-devel pcre2-devel qt5-qtbase-devel systemd-devel xz-devel \
zlib-devel
```

## Instructions

Install
-->


text:
# Install base system

* Download Arch ISO https://archlinux.org/download/
* Create Boot USB flash:
```
   cat /path/to/archlinux-version-x86_64.iso > /dev/path/to/usb/flash
```
* Boot from USB flash
* Switch to DE keyboard:
```
   loadkeys de-latin1
```
* Connect to the internet, for Wi-Fi authenticate to the wireless network use "iwctl"
* Install git:
```
   pacman -S git
```
* Git clone this repo
* Go to this directory:
```
   cd ansible_personal_automation/dell_xps_15_9500/
```
* Run script:
```
   bash base.sh
```

branch_name: refs/heads/main


text:
---
type: rule
archivedreason:
title: Do you add a prefix on blog posts titles?
guid: 523c60ac-19a5-4fe6-b8aa-9334135de8d7
uri: prefix-on-blog-posts-titles
created: 2018-02-22T17:29:57.0000000Z
authors:
- title: Adam Cogan
  url: https://ssw.com.au/people/adam-cogan
related: []
redirects:
- do-you-add-a-prefix-on-blog-posts-titles

---

The prefix is used to give context to your blog posts (or other type of content), so users know what to expect.

<!--endintro-->

Example 1: Use " **CODE:"** when your blog post is about coding   or " **VIDEO:"** when it has a video.

::: greybox
Northwind Traders with Entity Framework Core

:::

::: bad
Figure: Bad example - Post title with no prefix

:::

::: greybox
CODE: Northwind Traders with Entity Framework Core

:::

::: good
Figure: Good example - Using a prefix in the post title

:::

Example 2: Use prefixes (based on the content) for grouping and a better scanning:

::: greybox
Configure your SSW Email on your mobile (for Android users)
Configure your SSW Email on your mobile (for iPhone users)
Mobile Phone Answering Message
Install the Control4 App on your phone (Sydney Only)
Configure Skype for Business (Not for China office)
Configure Skype
Link your Azure & Azure DevOps (was VSTS) benefits to your SSW Organizational Account
Request Access to VSTS Projects
Do you know how to find stuff?
Setup and Create a timesheet in TimePRO
Setup your HR Records (Not for Work Experience)
Your details on payroll system CRM - Add your details to CRM
How to find an employee’s phone number?
Make a small code change on SugarLearning.com (Developers only)
:::

::: bad
Figure: Bad example - Data list with no prefixes

:::

::: greybox
Phone - Configure your SSW Email on your mobile (for Android users)
Phone - Configure your SSW Email on your mobile (for iPhone users)
Phone - Mobile Phone Answering Message
Phone - Install the Control4 App on your phone (Sydney Only)
PC - Configure Skype for Business (Not for China office)
PC - Configure Skype
DevOps - Link your Azure & Azure DevOps (was VSTS) benefits to your SSW Organizational Account
DevOps - Request Access to VSTS Projects
Intranet - Do you know how to find stuff?
TimePro - Setup and Create a timesheet in TimePRO
CRM - Setup your HR Records (Not for Work Experience)
CRM - Your details on payroll system CRM - Add your details to CRM
CRM - How to find an employee’s phone number?
Exercise - Make a small code change on SugarLearning.com (Developers only)

:::

::: good
Figure: Good example - Using a prefix in data

:::


text:
# Diplodia gleditschiae var. leguminum Sacc. VARIETY

#### Status
ACCEPTED

#### According to
Index Fungorum

#### Published in
Syll. fung. (Abellini) 3: 335 (1884)

#### Original name
Diplodia gleditschiae var. leguminum Sacc.

### Remarks
null

repository: mdoering/backbone

repo_name: mdoering/backbone


text:
A guide to our Swift style and conventions.

This is an attempt to encourage patterns that accomplish the following goals (in
rough priority order):

 1. Increased rigor, and decreased likelihood of programmer error
 1. Increased clarity of intent
 1. Reduced verbosity

#### Whitespace

 * Just use the default editor settings in Xcode.
 * End files with a newline.
 * Make concise use of vertical whitespace to divide code into logical chunks. Prefer MARK comments over multiple newlines, to denote sections.
 * Don’t leave trailing whitespace.
   * Not even leading indentation on blank lines.

#### Method Naming Guidelines ####

Refer to https://swift.org/documentation/api-design-guidelines/

#### Prefer `let`-bindings over `var`-bindings wherever possible

Use `let foo = …` over `var foo = …` wherever possible (and when in doubt). Only use `var` if you absolutely have to (i.e. you *know* that the value might change, e.g. when using the `weak` storage modifier).

_Rationale:_ The intent and meaning of both keywords are clear, but *let-by-default* results in safer and clearer code.

A `let`-binding guarantees and *clearly signals to the programmer* that its value will never change. Subsequent code can thus make stronger assumptions about its usage, especially with value types.

It becomes easier to reason about code. Had you used `var` while still making the assumption that the value never changed, you would have to manually check that.

Accordingly, whenever you see a `var` identifier being used, assume that it will change and ask yourself why.

#### Return and break early

When you have to meet certain criteria to continue execution, try to exit early. So, instead of this:

```swift
if n.isNumber {
    // Use n here
} else {
    return
}
```

use this:
```swift
guard n.isNumber else {
    return
}
// Use n here
```

You can also do it with `if` statement, but using `guard` is preferred, because `guard` statement without `return`, `break` or `continue` produces a compile-time error, so exit is guaranteed.

#### Avoid Using Force-Unwrapping of Optionals

If you have an identifier `foo` of type `FooType?` or `FooType!`, don't force-unwrap it to get to the underlying value (`foo!`) if possible.

Instead, prefer this:

```swift
if let foo = foo {
    // Use unwrapped `foo` value in here
} else {
    // If appropriate, handle the case where the optional is nil
}
```

Alternatively, you might want to use Swift's Optional Chaining in some of these cases, such as:

```swift
// Call the function if `foo` is not nil. If `foo` is nil, ignore we ever tried to make the call
foo?.callSomethingIfFooIsNotNil()
```

_Rationale:_ Explicit `if let`-binding of optionals results in safer code. Force unwrapping is more prone to lead to runtime crashes.

#### Avoid Using Implicitly Unwrapped Optionals

Where possible, use `let foo: FooType?` instead of `let foo: FooType!` if `foo` may be nil (Note that in general, `?` can be used instead of `!`).

_Rationale:_ Explicit optionals result in safer code. Implicitly unwrapped optionals have the potential of crashing at runtime.

#### Prefer implicit getters on read-only properties and subscripts

When possible, omit the `get` keyword on read-only computed properties and
read-only subscripts.

So, write these:

```swift
var myGreatProperty: Int {
	return 4
}

subscript(index: Int) -> T {
    return objects[index]
}
```

… not these:

```swift
var myGreatProperty: Int {
	get {
		return 4
	}
}

subscript(index: Int) -> T {
    get {
        return objects[index]
    }
}
```

_Rationale:_ The intent and meaning of the first version are clear, and results in less code.

#### Always specify access control explicitly for top-level definitions

Top-level functions, types, and variables should always have explicit access control specifiers:

```swift
public var whoopsGlobalState: Int
internal struct TheFez {}
private func doTheThings(things: [Thing]) {}
```

However, definitions within those can leave access control implicit, where appropriate:

```swift
internal struct TheFez {
	var owner: Person = Joshaber()
}
```

_Rationale:_ It's rarely appropriate for top-level definitions to be specifically `internal`, and being explicit ensures that careful thought goes into that decision. Within a definition, reusing the same access control specifier is just duplicative, and the default is usually reasonable.

#### When specifying a type, always associate the colon with the identifier

When specifying the type of an identifier, always put the colon immediately
after the identifier, followed by a space and then the type name.

```swift
class SmallBatchSustainableFairtrade: Coffee { ... }

let timeToCoffee: NSTimeInterval = 2

func makeCoffee(type: CoffeeType) -> Coffee { ... }
```

_Rationale:_ The type specifier is saying something about the _identifier_ so
it should be positioned with it.

Also, when specifying the type of a dictionary, always put the colon immediately
after the key type, followed by a space and then the value type.

```swift
let capitals: [Country: City] = [sweden: stockholm]
```

#### Explicitly refer to `self`, except when it adversely impacts readability

When accessing properties or methods on `self`, make the reference to `self` explicit by default:

```swift
private class History {
	var events: [Event]

	func rewrite() {
		self.events = []
	}
}
```

Only omit the explicit keyword when it hinders readability:

```swift
private class CustomView {
	let subview = UIView()
	let otherSubview = UIView()
	let thirdSubview = UIView()

	init() {
		[subview, otherSubview, thirdSubview].forEach(self.addSubview)
		// looks much better than [self.subview, self.otherSubview, self.thirdSubview].forEach(self.addSubview)
	}
}
```

_Rationale:_ This makes the semantics of instance vars more explicit, while the caveat that you can omit `self` at your discretion when it impacts readability allays verbosity concerns.

**You can be liberal with the "adversely impacts readability" rule.** However, when writing instance variables, you should generally explicitly specify `self` as that will prevent any potenetial issues with in-scope name shadowing, and generally should not introduce verbosity the way variable reads do.

#### Decide whether to use structs or classes based on whether you want value semantics

Unless you require functionality that can only be provided by a class (like identity or deinitializers), implement a struct instead.

Note that inheritance is (by itself) usually _not_ a good reason to use classes, because polymorphism can be provided by protocols, and implementation reuse can be provided through composition.

However, note that _not_ using inheritance is also _not_ a good reason to use structs, as structs have value semantics, which can be expensive, and lead to unpleasant surprises.

_Rationale:_ If you understand value semantics, and can reason about both class and value types, you are better placed to make a decision than if we just made one arbitrary guideline.

#### Use whitespace around operator definitions

Use whitespace around operators when defining them. Instead of:

```swift
func <|(lhs: Int, rhs: Int) -> Int
func <|<<A>(lhs: A, rhs: A) -> A
```

write:

```swift
func <| (lhs: Int, rhs: Int) -> Int
func <|< <A>(lhs: A, rhs: A) -> A
```

_Rationale:_ Operators consist of punctuation characters, which can make them difficult to read when immediately followed by the punctuation for a type or value parameter list. Adding whitespace separates the two more clearly.

#### Do not use extra spaces around method calls

Do not use extra spaces around the parentheses in method calls. Commas should have no space before, and one space after.

**Undesirable**:

```sin ( a, b )```

```sin( a, b )```

```sin (a, b)```

**Desirable**:

```sin(a, b)```

#### Use lowerCamelCase naming for all methods and variables, but namespace when it makes sense

Prefer to use lowerCamelCase naming for all methods and variables, even global functions, constants, and global variables.

However, when you have several variables that have the same role within a few different concepts, e.g. model, view, and projection matrices for two cameras, feel free to use snake case to break them up and namespace them.

`sceneSpace_modelViewProjectionMatrix` and `screenSpace_modelViewProjectionMatrix`

read better than:

`sceneSpaceModelViewProjectionMatrix` and `screenSpaceModelViewProjectionMatrix`.

Generally this exception should only be made in graphics and algorithm code. Consider a GPU operation where you are operating on groups of images at two or three defined resolutions (e.g. to save on heavier kernel execution time by making heavier kernels execute on downscaled textures). You may want to define a variable naming scheme that reads like this:

```swift
let upscaled_brightmapTexture = ...
let downscaled_blurTexture = ...
let downscaled_brightmapTexture = ...
let upscaled_brightmapTexture = ...
let upscaled_finalTexture = ...
```

In this scheme, the snake case helps to group the textures and allows the user to determine which textures have similarity across groups, drastically reducing the potential for programmer error when changing code in the future.

#### Do not abbreviate variable or method names unless they significantly impact readability

Terseness does not confer any performance benefit. Xcode's fuzzy autocomplete is good enough that you can afford to name your variables with fully-readable names. If you are having readability issues because of long variable names, first check that you are not organizing poorly. For example, you may be tempted to write shorter variable names so you avoid lines like:

```
let transformIntoWorldSpace = ...
let finalTransform = SCNMatrix4Mult(transformIntoWorldSpace, SCNMatrix4Rotate(SCNMatrix4Invert(SCNMatrix4Mult(cameraProjection, cameraTransform), Double.pi / 2, 0, 0, 1)))
```

If you rewrote it with shorter variable names, it would be much smaller and could read something like this:

```
let tw = ...
let t = SCNMatrix4Mult(tw, SCNMatrix4Rotate(SCNMatrix4Invert(SCNMatrix4Mult(cp, ct), Double.pi / 2, 0, 0, 1)))
```

But realistically, you should first check if you can fix this by refactoring the code itself:

```
let transformIntoWorldSpace = ...
let composedCameraTransform = SCNMatrix4Mult(cameraProjection, cameraTransform)
let landscapeTransformFromCamera = SCNMatrix4Invert(composedCameraTransform)
let portraitTransformFromCamera = SCNMatrix4Rotate(landscapeTransformFromCamera, Double.pi / 2, 0, 0, 1)
let finalTransform = SCNMatrix4Mult(transformIntoWorldSpace, portraitTransformFromCamera)
```

The final code essentially documents itself and is significantly easier to reason about and refactor if needed.

repository: dennislysenko/swift-style-guide

repo_name: dennislysenko/swift-style-guide


text:
---
layout: default-edit
title: Provided Resources
parent: Developer Training
grand_parent: Training
nav_order: 3
---

# Provided Resources

To follow this course you must have access to a:

 - Running Nuvla service and

 - "Target" Docker Swarm infrastructure.

If you're participating in a **formal, organized training course**
with an instructor, access to these will be provided.  If you're
following this course **on your own**, you may need to deploy those
services. Instructions are available [elsewhere in the
documentation](/administrators.html), but require significant service
administration experience.

repository: nuvla/documentation

gha_language: JavaScript

repo_name: nuvla/documentation


text:
Swift Explorer
========

User-friendly tool to manage files in an OpenStack Storage system (SWIFT). Please, visit [619.io/swift-explorer](http://www.619.io/swift-explorer) for further details.

gha_language: Java


text:
## Tips About Writing to Auth0

### Originality

Guest Authors have to produce **original articles**. That is, the content has be written with the authors' words and **no plagiarism will be accepted**. It is normal and totally ok to use and quote external references. Actually, this is desired, as it makes the article more reliable from an SEO perspective (articles will rank better when linking trustworthy sources of information).

However, authors have to study, learn, and understand the technologies involved to a point where they can explain these topics with their own words. Authors also have to strive to produce explanations better than those found on the web. This is what it makes an article valuable.

### Grammatical Person

Choose one grammatical person and stick with it. Usually, writers tend to stick with "we" (first-person plural) when writing articles. For example:

- "Now, we have to create a new file...";
- "Let's use this nice package to help us ...";

### Punctuation

Writers usually forget to give the proper attention to punctuation. Punctuation helps readers to understand what the author is trying to say. So, please, **do use** commas, full stops, colons, parentheses, and so on where appropriate. Not using punctuation generally leads to [run-on sentences](http://grammar.ccc.commnet.edu/grammar/runons.htm) that are hard to understand.

### Capitalization

Please, capitalize the words appropriately. There are two cases where you need to capitalize:

1. when starting new sentences;
2. when referring to proper nouns.

For example, _GitHub_ has two uppercase letters. So, it's important not to write _Github_ nor _github_. _JavaScript_ is another similar example. It is not _Javascript_ nor _javascript_.

**Note that** these are just two examples. Please, search how a proper noun is written and follow the convention.

### Formatting

Learn the different types of formatting on Markdown files and use them. Take special care when adding blocks of code. The following cheatsheets can help you learn how to format your article:

- [_Markdown Cheatsheet_](https://github.com/auth0/blog/blob/master/post-cheat-sheet.markdown)
- [_Auth0 Markdown Cheatsheet_](https://github.com/auth0/blog/blob/master/post-cheat-sheet.markdown)

repository: coderonfleek/guest-writer

repo_name: coderonfleek/guest-writer


text:
# Docker PHP-FPM Image

Basic docker image for PHP and Laravel development.

Versions
---
<versions>
- [`latest`, `7`](https://github.com/lukzgois/docker-nginx-php-fpm/blob/master/7/Dockerfile)
</versions>

## Detailed info

Detailed info of image contents and usage are located in the version folder:

[`latest`, `7`](https://github.com/lukzgois/docker-nginx-php-fpm/blob/master/7/README.md)

## License

This images is distributed under the [MIT License][license]

[license]: https://github.com/lukzgois/docker-php-fpm/blob/master/LICENSE

repository: lukzgois/docker-nginx-php-fpm

repo_name: lukzgois/docker-nginx-php-fpm


text:
# pdns-api-proxy
The api proxy sits in front of the powerdns primary api. It will generate zone events from api interaction with the
primary api and publish them by using the distributed message broker nats. The microservice will automatically create self signed certificates for the exposed api listener,
if no certificate will be [configured](../operation/configuration.md).

## Workflows
### Main Workflow
1. Listen for API / HTTPS requests
2. Extract event type and zone from request
3. Publish an event through message broker
4. Forward request to powerdns primary api and respond to the querying client

repository: gbvitrano/pdns-distribute

repo_name: gbvitrano/pdns-distribute


text:
---
layout: page
excerpt: "About Me..."
---

I am about to graduate with Bachelor's degree in Computer Software Engineering from Qazvin Azad University.\
I am highly interested in Computer Science, Artificial intelligence, Computer Vision, Robotics and especially in Deep Reinforcement Learning where the learning process most nearly reflects our real life!\
I am currently Head of Software Development at [MRL-HSL](https://sites.google.com/view/mrl-hsl) Humanoid Robotic Team.\
My CV could be found [here](https://soheilkhatibi.github.io/documents/cv.pdf).

## My Research Interests:

- Reinforcement Learning
- Artificial Intelligence
- Robotics
- Machine Learning


text:
# quantum-stable-matching
This project is a proof of concept demo of the paper [Quantum Dating Market](https://arxiv.org/abs/1003.1153) by O.G. Zabaleta and C.M. Arizmendi. This project is submitted as the term project of Simon Fraser University's Introduction to Quantum Computing (CMPT 409 - Special Topics in Theoretical Computing Science) in Summer 2021.

## Getting Started
### Prerequisites
```
python --version
>> Python 3
```

### Installing dependencies and required libraries
```
pip install -r requirements.txt
```

## References

[Quantum Dating Market](https://arxiv.org/abs/1003.1153)
[Qiskit Grover's Algorithm](https://qiskit.org/textbook/ch-algorithms/grover.html)
[Qiskit Introduction to Qubit States](https://qiskit.org/textbook/ch-states/representing-qubit-states.html)
[Add virtual environment to jupyter notebook kernel](https://towardsdatascience.com/creating-and-using-virtual-environment-on-jupyter-notebook-with-python-db3f5afdd56a)


text:
vagrant_user
============

Role that helps to create and configure Vagrant user on a VirtualBox VM.

The configuration of the role is done in such way that it should not be necessary
to change the role for any kind of configuration. All can be done either by
changing role parameters or by declaring completely new configuration as a
variable. That makes this role absolutely universal. See the examples below for
more details.

Please report any issues or send PR.

Example
-------

```yaml
---

# Example of basic usage
- hosts: myhost
  roles:
    - vagrant_user
```

Role variables
--------------

List of variables used by the role:

```yaml
# Vagrant user name
vagrant_user_name: vagrant

# Vagrant user UID
vagrant_user_uid: 17935

# Vagrant password
vagrant_user_password: "{{ 'vagrant' | password_hash('sha512', 'vagsalt') }}"

# Vagrant group
vagrant_user_group: users

# Sudo settings
vagrant_user_sudo: |
    Defaults !requiretty
    vagrant ALL=(ALL) NOPASSWD: ALL

# Vagrant insecure key
# (https://github.com/mitchellh/vagrant/blob/master/keys/vagrant.pub)
vagrant_user_public_key: ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAQEA6NF8iallvQVp22WDkTkyrtvp9eWW6A8YVr+kz4TjGYe7gHzIw+niNltGEFHzD8+v1I2YJ6oXevct1YeS0o9HZyN1Q9qgCgzUFtdOKLv6IedplqoPkcmF0aYet2PkEDo3MlTBckFXPITAMzF8dJSIFo9D8HfdOV0IAdx4O7PtixWKn5y2hMNG0zQPyUecp4pzC6kivAIhyfHilFR61RGL+GPXQ2MWZWFYbAGjyiYJnAmCP3NOTd0jMZEnDkbUvxhMmBYSdETk1rRgm+R4LOzFUGaHqHDLKLX+FIPKcF96hrucXzcWyLbIbEgE98OHlnVYCzRdK8jlqm8tehUc9c9WhQ== vagrant insecure public key
```

Dependencies
------------

- [vbox_additions](https://github.com/jtyr/ansible-vbox_additions) (optional)

License
-------

MIT

Author
------

Jiri Tyr


text:
### Project Overview

 The project is a summary of the various tasks involved during the data preprocessing tasks, data cleaning, missing values imputation, encoding categorical data, etc

### Learnings from the project

 Upon the course of the project I got an overview of the various tasks involved in the data preparation phase, checking the data for null values, treating missing values(using mean, median), methods of encoding categorical data using label encoder, treating skewness using log transformation

### Approach taken to solve the problem

 The approach I followed is fixing the data by features one at a time

### Challenges faced

 Fixing the data was a bit tedious in the beginning but upon practice it was good

### Additional pointers

 Prior knowledge of python strings and various string operations would be helpgul in treating the data


text:
# Laravel 5 Followers
[![Build Status](https://travis-ci.org/skybluesofa/laravel-followers.svg?branch=master)](https://travis-ci.org/skybluesofa/laravel-followers) [![Code Climate](https://codeclimate.com/github/skybluesofa/laravel-followers/badges/gpa.svg)](https://codeclimate.com/github/skybluesofa/laravel-followers) [![Test Coverage](https://codeclimate.com/github/skybluesofa/laravel-followers/badges/coverage.svg)](https://codeclimate.com/github/skybluesofa/laravel-followers/coverage) [![Total Downloads](https://img.shields.io/packagist/dt/skybluesofa/laravel-followers.svg?style=flat)](https://packagist.org/packages/skybluesofa/laravel-followers) [![Version](https://img.shields.io/packagist/v/skybluesofa/laravel-followers.svg?style=flat)](https://packagist.org/packages/skybluesofa/laravel-followers) [![Software License](https://img.shields.io/badge/license-MIT-brightgreen.svg?style=flat)](LICENSE)

Gives Eloquent models the ability to manage their followers.

## Models can:
- Send Follow Requests
- Accept Follow Requests
- Deny Follow Requests
- Block Another Model

## Installation

First, install the package through Composer.

```php
composer require skybluesofa/laravel-followers
```

Then include the service provider inside `config/app.php`.

```php
'providers' => [
    ...
    Skybluesofa\Followers\ServiceProvider::class,
    ...
];
```
Publish config and migrations

```
php artisan vendor:publish --provider="Skybluesofa\Followers\ServiceProvider"
```
Configure the published config in
```
config\followers.php
```
Finally, migrate the database
```
php artisan migrate
```

## Setup a Model
```php
use Skybluesofa\Followers\Traits\Followable;
class User extends Model
{
    use Followable;
    ...
}
```

## How to use
[Check the Test file to see the package in action](https://github.com/skybluesofa/laravel-followers/blob/master/tests/FollowersTest.php)

### Methods

#### Send a Follow Request

Will trigger a `Skybluesofa\LaravelFollowers\Events\FollowRequest` event.
```php
$user->follow($recipient);
```

#### Accept a Follow Request

Will trigger a `Skybluesofa\LaravelFollowers\Events\FollowRequestAccepted` event.
```php
$recipient->acceptFollowRequestFrom($user);
```

#### Deny a Follow Request

Will trigger a `Skybluesofa\LaravelFollowers\Events\FollowRequestDenied` event.
```php
$recipient->denyFollowRequestFrom($user);
```

#### Remove Follow

Will trigger a `Skybluesofa\LaravelFollowers\Events\Unfollow` event.
```php
$user->unfollow($recipient);
```

#### Block a User

Will trigger a `Skybluesofa\LaravelFollowers\Events\FollowingBlocked` event.
```php
$user->blockBeingFollowedBy($recipient);
```

#### Unblock a User

Will trigger a `Skybluesofa\LaravelFollowers\Events\FollowingUnblocked` event.
```php
$user->unblockBeingFollowedBy($recipient);
```

#### Check if User is Following another User
```php
$user->isFollowing($recipient);
```

#### Check if User is being Followed by another User
```php
$recipient->isFollowedBy($user);
```

#### Check if User has a pending Follow request from another User
```php
$recipient->hasFollowRequestFrom($user);
```

#### Check if User sent a pending Follow request to another User
```php
$user->hasSentFollowRequestTo($recipient);
```

#### Check if User has blocked another User
```php
$recipient->hasBlockedBeingFollowedBy($user);
```

#### Check if User is blocked by another User
```php
$user->isBlockedFromFollowing($recipient);
```

#### Get a single friendship
```php
$user->getFriendship($recipient);
```

#### Get a list of all Friendships
```php
$user->getAllFriendships();
```

#### Get a list of pending Friendships
```php
$user->getPendingFriendships();
```

#### Get a list of accepted Friendships
```php
$user->getAcceptedFriendships();
```

#### Get a list of denied Friendships
```php
$user->getDeniedFriendships();
```

#### Get a list of blocked Friendships
```php
$user->getBlockedFriendships();
```

#### Get a list of pending Friend Requests
```php
$user->getFriendRequests();
```

#### Get the number of Friends
```php
$user->getFriendsCount();
```

## Friends
To get a collection of friend models (ex. User) use the following methods:
#### Get Friends
```php
$user->getFriends();
```

#### Get Friends Paginated
```php
$user->getFriends($perPage = 20);
```

### Events

These events are triggered during the lifecycle of following/unfollowing/accept/deny followers:

```php
Skybluesofa\LaravelFollowers\Events\FollowingBlocked(Model $recipient, Model $sender);
Skybluesofa\LaravelFollowers\Events\FollowingUnblocked(Model $recipient, Model $sender);
Skybluesofa\LaravelFollowers\Events\FollowRequest(Model $recipient, Model $sender);
Skybluesofa\LaravelFollowers\Events\FollowRequestAccepted(Model $recipient, Model $sender);
Skybluesofa\LaravelFollowers\Events\FollowRequestDenied(Model $recipient, Model $sender);
Skybluesofa\LaravelFollowers\Events\Unfollow(Model $recipient, Model $sender);
```

To listen for and react to these events, follow the [instructions available in the Laravel Documentation](https://laravel.com/docs/7.x/events#defining-listeners).

## Thank you
The basis of this code was garnered from [https://github.com/hootlex/laravel-friendships](https://github.com/hootlex/laravel-friendships). Although it was a jumping off point, much of the code has been rewritten to allow for Following as opposed to Mutual Friendship.

## Contributing
See the [CONTRIBUTING](CONTRIBUTING.md) guide.

repository: skybluesofa/laravel-followers

gha_language: PHP

repo_name: skybluesofa/laravel-followers


text:
# DICE HTTP Proxy

This is a simple transparent HTTP proxy that detects common search engine queries, and puts query data into a MongoDB database.

Written by [Julien Ponge](http://julien.ponge.info/).

## License

    Copyright 2012 Julien Ponge, Institut National des Sciences Appliquées de Lyon.

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

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

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

## Supported sites

* Google
* Bing
* Yahoo!
* Wikipedia

## What works and not

* The proxy works for any HTTP connection. It also detects requests on other ports than 80.
* It does not support HTTPS connections.
* Some streaming / websocket connections as used by sites such as Youtube won't work through this proxy.

## Dependencies

Runtime:

* [Scala 2.9.1](http://www.scala-lang.org/)
* [MongoDB](http://www.mongodb.org/)

Development:

* [Apache BuildR](http://buildr.apache.org/)
* [Ruby](http://www.ruby-lang.org/) (required to run BuildR)
* [Twitter Finagle](http://twitter.github.com/finagle/) (automatically fetched by BuildR)
* [Netty](http://netty.io/) (automatically fetched by BuildR as Finagle dependency)
* [Casbash](http://api.mongodb.org/scala/casbah/current/) (automatically fetch by BuildR)
* (other misc. dependencies fetched as dependencies of the projects above)

Those are fairly easy to install dependencies.

Apache BuildR can be installed using Ruby gems: `gem install buildr`. Scala is automatically downloaded by BuildR to compile, but it remains best to install it system-wide for the runtime.

If you are on MacOSX using [Homebrew](http://mxcl.github.com/homebrew/), then installing the dependencies is as simple as:

    brew install scala
    brew install mongodb
    gem install buildr

## Building

Building is based on the common BuildR tasks, such as `buildr compile` or `buildr package`.

Other tasks are available too (see `buildr -T` to list them all):

* `buildr execute` launches the application
* `buildr dist` will create a distributable ZIP image of the application along with a `run.sh` script.

## Running

Use the distributable image and launch `run.sh`.

Alternatively you may assemble a classpath from the dependencies being put in the exploded image folder, and run the `dice.searchengine.httpproxy.SearchEngineHttpProxy` main class.

You will also need a working MongoDB instance. In development mode, I suggest that you use it with the provided configuration file called `mongod.conf`:

    mkdir db-mongodb
    mongod run --config=mongod.conf

You can tweak the MongoDB configuration as you want to add replication and sharding support. This is all transparent to the HTTP proxy application, and you can even start a cluster of those!

## Use it with a web browser

If you don't know how to configure a proxy for your web browser then Google is your friend.

## Recognizing new search engines

A search engine is defined as a partial function through the following trait:

```scala
trait SearchEngineProcessor extends PartialFunction[String, SearchEngineQuery] {

  /**
   * Regular expression to check is a URI corresponds to those a given search engine.
   */
  def searchEngineTest: Regex

  /**
   * Regular expression to extract a query string from a URI.
   */
  def queryExtractor: Regex

  /**
   * Regular expression to split a query string into keywords.
   */
  def keywordSplitter: Regex

  /**
   * Symbolic name for the search engine.
   */
  def name: String

  def isDefinedAt(uri: String) = searchEngineTest.findFirstIn(uri).isDefined

  def apply(uri: String): SearchEngineQuery = {
    val query = queryExtractor.findFirstMatchIn(uri).get.group(1)
    val keywords = keywordSplitter.split(query)

    SearchEngineQuery(query, keywords)
  }
}
```

The variance is captured by regular expressions. For example here is how Google queries can be captured:

```scala
class GoogleSearch extends SearchEngineProcessor {
  val searchEngineTest = "www.google.*q=.*".r
  val queryExtractor = "q=([^&]*)".r
  val keywordSplitter = "(%20)|(\\+)".r
  val name = "google"
}
```

Processors can then be elegantly chained as partial functions, then lifted to form a single function returning an optional type, such as in:

```scala
val searchEngineProcessor = (google orElse bing orElse yahoo orElse wikipedia).lift
```

Thus:

```scala
searchEngineProcessor("http://www.autosport.com/")
=> None

searchEngineProcessor("http://www.google.com/?q=les+muscles+merguez+party")
=> Some(SearchEngineQuery(
     "les+muscles+merguez+party",
     Seq("les", "muscles", "merguez", "party"),
     "google"
   ))
```

## Why *xyz*?

* Twitter Finagle: because it is a fairly well-tested asynchronous server stack, and it works on the JVM.
* Scala: because of Twitter Finagle and that their Java API was much more verbose. At last, there are people who write maintainable Scala code, see [Effective Scala](http://twitter.github.com/effectivescala/).
* BuildR: because I can't get my head around Scala's SBT, and because Maven was just too rigid for the need.
* MongoDB: because it is a solid NoSQL database, and that their Scala driver API (Casbah) is so easy.

repository: dynamid/dice-proxy

repo_name: dynamid/dice-proxy


text:
Handling data

Elm passes data in the form you specify. Use `Html.Attributes.attribute` to pass it as an attribute and `Html.Attributes.property` to pass it as a property.

Handling events

Elm can listen to native DOM events dispatched from Custom Elements. It supports all styles of events (lowercase, camelCase, kebab-case, etc).

repository: omijs/custom-elements-everywhere

gha_license_id: NOASSERTION

repo_name: omijs/custom-elements-everywhere


text:
# Npm plugin for [PHPCI](https://www.phptesting.org)

A plugin for PHPCI to download and install npm packages required by your application.

### Install the Plugin

1. Navigate to your PHPCI root directory and run `composer require rna-code/npm-cache-phpci-plugin`
2. If you are using the PHPCI daemon, restart it
3. Update your `phpci.yml` in the project you want to deploy with

### Prerequisites

1. [npm-cache](https://www.npmjs.com/package/npm-cache) needs to be installed.

### Plugin Options
- **command** _[string, require]_ - Command name. See [docs](https://docs.npmjs.com/)
- **directory** _[string, optional]_ - Relative path to run npm-cache in.
- **flags** _[list, optional]_ - Command flags

### PHPCI Config

```yml
    RNACode\PHPCI\NpmCache:
        command: install
```

repository: RNACode/phpci-npm-cache

repo_name: RNACode/phpci-npm-cache


text:
# Post Builder

Posts \(contributions\) can be build using the Quill editor or plain text. Each post can be filled with different content elements like embeds, videos, images, lists, paragraphs, headings, gallery, polls and many more.

Current stage of the Feature: As of now we have 2 types of posts **post** and **can do** as shown in the image below. In the future we want to change this by moving "can do" to the list of content elements.

![](../.gitbook/assets/posts.png)

The Post builder should be easy to understand and work with for non-tech users. Quill is the current WYSIWYG editor implemented and it's toolbar can be customized.

repository: Toverto/Documentation

repo_name: Toverto/Documentation


text:
# Pyong

A simple "paddle and ball" game in the spirit of pong. Written in Python with a Tkinter GUI.

Target runtime is Python 3 or later, to play just execute your system's call.

i.e. `python game.py` or `python3 game.py`

Premise of the game is to bounce the ball off the wall (top of canvas) with your paddle. Don't mess up.

![Game screenshot](https://raw.githubusercontent.com/araddula/python-paddle-ball-game/main/screenshot.png)

## Credits
https://github.com/gingeleski/pyong.

repository: araddula/python-paddle-ball-game

repo_name: araddula/python-paddle-ball-game


text:
# Typescript Server Template

In development, watch and auto-compile TS src with

`yarn watch`

and re-run compiled JS server with (in another terminal)

`yarn dev`

In production, build with

`yarn build`

Run the server without watching changes with

`yarn start`

The template comes with a hello-world HTTP + HTTPS server plus some logic for TLS certificates to start you off. It tries to find a Let's Encrypt certificate in `/etc/letsencrypt/live/example.com` (change the domain!) and falls back to an auto-generated self-signed certificate. You can test that it works with

```sh
curl -k https://localhost
```

In production, get a real certificate and remove the HTTP server. Also, you might want to configure node.js to sit behind NGINX, in which case the TLS stuff moves to NGINX and is not needed here (but I think it's still great for a quicker start).

## Using the template

You can base a new Github repo on this template with the Github cli:

```sh
gh repo create my-repo --private --template mitschabaude/typescript-server-template
cd my-repo
git pull origin master
yarn
```

On the other hand, more often you want to start developing without publishing to Github. To do so, simply clone the repo and remove the .git folder.

```sh
git clone git@github.com:mitschabaude/typescript-server-template.git my-repo
cd my-repo
rm -rf .git
yarn
```

repository: mitschabaude/typescript-server-template

repo_name: mitschabaude/typescript-server-template


text:
Checks that [Javadoc summary
sentence](https://www.oracle.com/technical-resources/articles/java/javadoc-tool.html#firstsentence)
does not contain phrases that are not recommended to use. Summaries that
contain only the `{@inheritDoc}` tag are skipped. Summaries that contain
a non-empty {@code {@return}} are allowed. Check also violate Javadoc
that does not contain first sentence, though with {@code {@return}} a
period is not required as the Javadoc tool adds it.

repository: codacy/codacy-checkstyle

gha_language: Scala

repo_name: codacy/codacy-checkstyle


text:
# abci_tutorial
Learn how to use ABCI(https://abci.ai/ja/) step by step
Resources
- [User Guide](https://docs.abci.ai/ja/)

## Use jupyter in interactive job
[Jupyter tutorial](jupyter_tutorial.md)
## Batch job
[Train CNN on MNIST with batch job](batch_job_tutorial.md)
## Monitor experiment results
[Monitor batch job's experiment results using wandb](experiment)
## Multiple-GPU
[Hyperparameter search with wandb sweep using multiple-gpus](multi_gpu)
## Use docker image with Singularity
[Use docker image with Singularity](https://github.com/kenoharada/abci_tutorial/blob/main/docker_image_with_singularity.md)
## Use conda env in batch job
[Use conda env in batch job](conda_env_in_batch_job.md)


text:
---
title: Getting Started
---

# Overview

The rover-js-base library is the lowest-level rover helper library. It can be used in a browser or in node.js. It is mainly used to read, create and
sign [transactions](http://rover.network/developers/guides/concepts/transactions.html). This library is used and exposed by
[rover-js-sdk](https://github.com/laxmicoinofficial/rover-js-sdk) but you can use it by itself if you don't need to communicate with Orbit.

* [Building and Installing](../README.md) rover-js-base
* [Building Transactions](./reference/building-transactions.md)
* [Examples](./reference/base-examples.md)

rover-js-base exposes the following classes:
* [Account](https://github.com/laxmicoinofficial/rover-js-base/blob/master/src/account.js)
* [Asset](https://github.com/laxmicoinofficial/rover-js-base/blob/master/src/asset.js)
* [Keypair](https://github.com/laxmicoinofficial/rover-js-base/blob/master/src/keypair.js)
* [Memo](https://github.com/laxmicoinofficial/rover-js-base/blob/master/src/memo.js)
* [Operation](https://github.com/laxmicoinofficial/rover-js-base/blob/master/src/operation.js)
* [Transaction](https://github.com/laxmicoinofficial/rover-js-base/blob/master/src/transaction.js)
* [TransactionBuilder](https://github.com/laxmicoinofficial/rover-js-base/blob/master/src/transaction_builder.js)

repository: laxmicoinofficial/rover-js-base

repo_name: laxmicoinofficial/rover-js-base


text:
# dataknead
**Fluent conversion between data formats like JSON, XML and CSV**

[Read the docs](https://hay.github.io/dataknead/)

Ever sighed when you wrote code to convert CSV to JSON for the thousandth time?

```python
import csv
import json

data = []

with open("cities.csv") as f:
    reader = csv.DictReader(f)

    for row in reader:
        data.append(row)

with open("cities.json", "w") as f:
    json.dump(data, f)
```

Stop sighing and use `dataknead`. Fetch it with `pip`:

```bash
$ pip install dataknead
```

And use it like this:

```python
from dataknead import Knead
Knead("cities.csv").write("cities.json")
```

Or make it even easier on the command line:

```bash
knead cities.csv cities.json
```

`dataknead` has inbuilt loaders for CSV, Excel, JSON, TOML and XML and you can easily write your own.

Piqued your interest? [Read the docs!](https://hay.github.io/dataknead/).

repository: ookgezellig/dataknead

repo_name: ookgezellig/dataknead


text:
GWT goodies
================
This repository provides GWT/JSInterop/JACL  wrappers for useful and popular JS libraries and utility projects.
All projects are Apache 2.0 licensed, contributions are welcome!

### JS-Cookie
A wrapper for [JS Cookie](github.com/js-cookie) JS library for easy handling of cookies.
[More ...](gwt-cookies/README.md)

### Tabulator
A wrapper for the [Tabulator](tabulator.info) JS grid component.
[More ...](gwt-tabulator/README.md)

### Stripe
A Stripe API wrapper.
[More ...](gwt-stripe/README.md)

### UIKIT
A wrapper for the very nice [UiKit](https://getuikit.com/) web site framework.
[More ...](gwt-uikit/README.md)

### reCaptcha
A wrapper for Google reCaptcha.
[More ...](gwt-recaptcha/README.md)

### JWT
A JWT wrapper for various providers (Auth0 for now, Okta and Keycloak to come ...)
[More ...](gwt-jwt/README.md)

### Utils
Utility code used in some of the other modules
[More ...](gwt-utils/README.md)

## How to build

To build all projects:
> gradlew assemble

To build all projects:
> gradlew clean

To deploy all projects into local Maven repository with:
> gradlew publishLocal

You can also build individual projects, for example:
> gradlew -p gwt-jwt assemble

repository: peruncs/gwt

repo_name: peruncs/gwt


text:
# Description of examples catalogue content

examples/simulations
--------------------

  codes of GATE simulations

examples/goja
-------------

  code of C++ app that reads .root output from GATE software and
  converts hits to set of coincidences saved in plain text files

examples/python_scripts
-----------------------

  python scripts that are used to analyze output of the GOJA app;
  the scripts are used mainy to filter and sort data and to plot
  figures

repository: Alvarness/j-pet-gate-tools

repo_name: Alvarness/j-pet-gate-tools


text:
# Project Name

  GithubSearch

# Author Information

  Muthoni Njuguna

## Description

  This project was generated with Angular CLI version 9.0.7. It allows users to search through the github Api for user profiles and repositories.

## Specifications

The program has the following user behavior specifications:

User Behaviour: User decides to search for User-Profile.
Input: Write user name on search form.
Output: The profile details of the user appears.
User Behaviour: User decides to search for repositories.
Input - Click on repositories tab.
      - Enter name of repository on search form.
Output - Opens repositories page.
        - List of repositories appear.

## Technologies Used

  - TypeScript
  - HTML
  - CSS
  - Angular CLI version 9.0.7

## Setup/Installation Requirements

  1. Before running this application on your local machine, ensure that you have npm and Angular installed.
  2. Once you are done with the step above, proceed to clone the application by running git clone https://github.com/Brenda-M/Github-Search-Application-with-Angular-9.git on the teminal.
  3. Navigate to the project’s directory through your terminal.
  4. Run ng serve --open, which should initiate and open a server that will display the application on your browser.

## Link to the Deployed Page

https://brenda-m.github.io/Github-Search-Application-with-Angular-9/

## Contact Information

In case of any feedback, you can reach me through:
<EMAIL_ADDRESS>
## License

The MIT License (MIT)
Copyright (c) 2020 Muthoni Njuguna.

gha_language: TypeScript


text:
# Getting Ready to Program Clyde

By now you've received your Clyde and you've played with its basic functionality.

Here's how you get started programming it.  If you want to play by the rules, you can can follow [the official Fabule instructions](https://fabule.com/clyde/getting-started-software) instead.

## Preparing your computer

1. [Download Arduino software](http://arduino.cc/en/Main/Software).
1. [Download Clyde libraries as a zip file](https://github.com/fabule/Clyde/archive/master.zip).
1. Open the zip file.
1. Copy all of the folders in `software/arduino/libraries` to your `arduino/libraries` directory (usually in your home directory on your PC).  If the `arduino/libraries` folder doesn't exist, create it.  You'll need to copy **Clyde**, **SerialCommand**, and **MPR121**.
1. [Download kroimon's SerialCommand](https://github.com/kroimon/Arduino-SerialCommand/archive/master.zip).
1. Delete the existing `arduino/libraries/SerialCommand` and replace it with the unzipped folder from kroimon's SerialCommand.
1. Copy `software/arduino/hardware/1.0.5` to your `ardunio/hardware` directory.
1. Open up the Arduino application.
1. Under `Tools > Board`, select **Clyde**.
1. Open `File > Examples > Clyde > Examples > ClydeOriginal`.

## Preparing Clyde

1. Plug Clyde in.  Yes, I know this sounds weird because you'll be connecting Clyde to your computer, but the USB simply isn't powerful enough to make Clyde work.  Don't worry, the power supply is isolated.
1. Plug USB in.
1. Test the Clyde is still doing his factory default behavior by pressing the eye a few times.
1. Set your serial port under `Tools > Serial Port` to match the USB device that appeared when you plugged Clyde in.  When in doubt, select the last `tty` option.

## Program Clyde for the First Time

1. Press the **Upload** button, second from the top left to upload code to Clyde.
1. When it says "Done uploading.", Clyde will flash once.
1. Test that you can still turn on/off Clyde's eye and light by pressing the eye.

**Congratulations!** You've uploaded your first Clyde application.  Let's get on to building applications for Clyde.

## Troubleshooting

If Clyde doesn't do anything when pressing the eye, make sure that both the power and USB cords are connected to Clyde.

If there's an error compiling `ClydeOriginal`, it may be because you haven't copied over all _three_ libraries.  Remember that after you add or delete Arduino libraries, you need to restart the Arduino application

repository: polastre/clyde-book

path: /01-Getting Ready.md

filename: 01-Getting Ready.md

repo_name: polastre/clyde-book


text:
# Burndown

Burndown is a little app to help you keep tabs on your Lighthouse projects. It shows you how many tickets you open and close every day, along with a chart showing the progress along a milestone.

## Deployment

If you want to make your life easy, go ahead and just deploy to [Heroku](http://heroku.com).  Burndown is ready to go for a deployment to Heroku, cron jobs and all!  If you want to set it up on your own, you'll need to make sure that `rake app:update_milestones` gets run once a day (preferably as late as possible in the day).  Running it multiple times a day has no negative impact.

## Getting started

Once you deploy the app, follow the instructions to set up some burndown charts. Then... wait! Burndown works by tracking progress every day. Which means you may have to wait a few days for your data to be interesting.

extension: markdown


text:
# Cacheable

Gem for caching in Wego Rails apps

## Installation

Add this line to your application's Gemfile:

```ruby
gem 'cacheable'
```

And then execute:

    $ bundle

Or install it yourself as:

    $ gem install cacheable

## Usage

To include the caching feature for of the gem in your Rails apps models, create config/initializer/cacheable.rb with the following line:
```ruby
ActiveRecord::Base.send(:include, Cacheable::ActiveRecordExtensions)

Cacheable::CacheVersion.namespace = 'application_name'
Cacheable::CacheVersion.init
```
In your model, add the functions that you want to cache the data
```ruby
caches_method :method_name
caches_method :method_name, expires_in: 1.day #defalut expires_in is 1 day
caches_method :method_name, include_locale: true #default include_locale is false
```

In order to prevent too many request sent to caching storate (memcache) we will store cache in-memory by default. In-memory storage is only available per request. If you want to disable in-memory can set like this
```ruby
caches_method :method_name, memoized: false
```

### Notice
Need to use two separate define functions for instance and class methods (singeton methods)

```
class Test
    caches_method :a_defined_method
    caches_class_method :a_defined_class_method

    def a_defined_method
      #
    end

    def self.a_defined_class_method
      #
    end
end

```
## Generate methods
`caches_method :method_name` or `caches_class_method :method_name` will only generate cached method with same name `method_name` for caching and `delete_method_name_cache` for clearing cache.

## Contributing

1. Fork it ( https://github.com/[my-github-username]/cacheable/fork )
2. Create your feature branch (`git checkout -b my-new-feature`)
3. Commit your changes (`git commit -am 'Add some feature'`)
4. Push to the branch (`git push origin my-new-feature`)
5. Create a new Pull Request

repository: wego/wego-cacheable

gha_language: Ruby

repo_name: wego/wego-cacheable


text:
---
layout: page
title: Program

---
------

### Day 1

*Morning*

Introduction to neural Networks
Lecture & Lab

*Afternoon*

Deep Neural networks and their relevance for psychology
Lecture & Lab

### Day 2

*Morning*

Training convolutional Deep Neural Networks (data-sets, training and fine-tuning, effects of data-set curation)
Lecture & Lab

*Afternoon*

Relating neural networks to neural data
Lecture & Lab

### Day 3

*Morning*

Informative AI, analysing network behavior
Lecture & Lab

*Afternoon*

Recurrent Neural Networks
Lecture & Lab

### Day 4

Symposium


text:
---
layout: post
title:  "Wording, Lana"
date:   2017-01-05 11:11:11 -0500
categories: jekyll update
---

-----
-----

+ (Who, Whom) is going to the party?
+ I need to make (fewer, less) mistakes.
+ I want to go, (two, to, too).
+ Put the box over (their, there, they’re).
+ She (lead, led) the children in a song.

-----
-----

+ (Can, May) I have another cookie?
+ I need (your, you’re) telephone number.
+ The toy has lost (its, it’s) batteries.
+ The park is (by, buy, bye) the lake.
+ I am going (two, to, too) the show.

-----
-----

+ (Their, There, They’re) going to be here soon.
+ Are you talking to (I, me)?
+ (Who, Whom) should I say is calling?
+ I want to put (fewer, less) sugar in my tea.
+ (Its, It’s) time to go.

-----
-----

+ (Your, You’re) going to be late.
+ I know you (can, may) do it all by yourself.
+ We need to (by, buy, bye) some milk.
+ The school (principal, principle) came in to the room.
+ She was happy to (accept, except) her award.

-----
-----

+ We went before the teen (council, counsel).
+ I like all (accept, except) the blue one.
+ This is a (stationary, stationery) bike.
+ Most drugs have side (affects, effects).
+ Warm bread (compliments, complements) any meal.

-----
-----

+ My daughter likes purple (stationary, stationery).
+ Everybody likes to receive (compliments, complements).
+ Voting can help (affect, effect) change.
+ You should always stand by your (principals, principles).
+ He will (council, counsel) me to help me make the right decision.


text:
# Social-Planner
An app that allows you to plan activites and invite friends to come with you!

## Main screen
This is the main screen of the app

![alt tag](https://github.com/ConMur/Social-Planner/blob/master/Screenshots/Main%20screen%20-%20free.png)

## Adding an activity
By pressing the add button you are able to add a new activity to the list

![alt tag](https://github.com/ConMur/Social-Planner/blob/master/Screenshots/add%20activity.png)

There it is!

![alt tag](https://github.com/ConMur/Social-Planner/blob/master/Screenshots/after%20adding%20activity.png)

## Bringing a friend along
Tapping on an activity will bring you to a screen where you can ask a friend to come along with you

![alt tag](https://github.com/ConMur/Social-Planner/blob/master/Screenshots/plan%20event%20pt1.png)
![alt tag](https://github.com/ConMur/Social-Planner/blob/master/Screenshots/plan%20event%20pt2.png)

license: Unlicense

repository: ConMur/Social-Planner

repo_name: ConMur/Social-Planner


text:
# Kickoff Rule Changes for 2018

## http://www.nfl.com/news/story/0ap3000000933891/article/owners-approve-changes-to-kickoff-use-of-helmet

Some key takeaways for the new kickoff guidelines:

1. Players on the kicking team cannot line up more than one yard from the point of the kickoff. The previous rule allowed players to line up five yards from the restraining line (typically 35-yard line), allowing them to have more of a running start before the kick.

2. The wedge block has been eliminated. Only players who line up in the setup zone (between their own 40 and opponents' 45-yard line) can put together double-team blocks.

3. Until the ball is touched or hits the ground, no player on the receiving team may cross the restraining line (typically its 45) or initiate a block. This forces blockers on the receiving team to run back and block, which greatly decreases the chance of an "attack" block that can result in a high-speed collision.

4. When the ball hits the end zone, it's immediately ruled a touchback. There is no need for a player to down the ball in the end zone to initiate a touchback.

repository: RobMulla/kaggle-nfl

repo_name: RobMulla/kaggle-nfl


text:
---
meta:
  - name: title
    content: Fairwinds Insights Slack Integration
  - name: description
    content: Fairwinds Insights has an integration with Slack, so you can get notifications about critical changes to your clusters.
  - name: keywords
    content: Fairwinds Insights, Kubernetes Audit, Kubernetes configuration validation, Slack Integration
---
# Slack Notifications

Fairwinds Insights has an integration with Slack, so you can get notifications
about critical changes to your clusters.

There are two types of Slack notifications:
* Realtime: we'll send an alert every time one of your reports generates new Action Items.
This is good for production clusters, which deserve more attention and should be relatively stable.
* Daily Digest: we'll send one alert per day highlighting any new Action Items that have appeared
in your cluster

Notifications can be configured for your entire organization, or for individual clusters.

<img :src="$withBase('/img/slack.png')" alt="slack settings">

Read our [privacy policy](https://www.fairwinds.com/privacy-policy) to learn more about how Fairwinds Insights handles user data.

# Installation
To set up Slack notifications, visit your organization's settings page and go to the `Integration` tab.
Click `Add Integration` under Slack. Once you have Slack setup, you can then choose which channels you'd like notifications to be
sent to in the `Notifications` tab.

repository: baderbuddy/insights-docs

repo_name: baderbuddy/insights-docs


text:
# Cosmos SDK Documentation

## Get Started

-  **[SDK Intro](./intro/README.md)**: High-level overview of the Cosmos SDK.
-  **[SDK application tutorial](https://github.com/cosmos/sdk-application-tutorial)**: A tutorial to learn the SDK. It showcases how to build an SDK-based blockchain from scratch, and explains the basic principles of the SDK in the process.

## Resources

- [Specifications](./spec/README.md): Specifications of modules and other parts of the Cosmos SDK.
- [SDK API Reference](https://godoc.org/github.com/pocblockchain/pocc): Godocs of the Cosmos SDK.
- [REST API spec](https://cosmos.network/rpc/): List of endpoints to interact with a `gaia` full-node through REST.

## Creating a new SDK project

To create a new project, you can either:

- Fork [this repo](https://github.com/cosmos/sdk-application-tutorial/). Do not forget to remove the `nameservice` module from the various files if you don't need it.
- Use community tools like [chainkit](https://github.com/blocklayerhq/chainkit).

## Cosmos Hub

The Cosmos Hub (`gaia`) docs have moved [here](https://github.com/cosmos/gaia/tree/master/docs).

## Languages

The Cosmos-SDK is currently written in [Golang](https://golang.org/), though the
framework could be implemented similarly in other languages.
Contact us for information about funding an implementation in another language.

## Contribute

See [this file](https://github.com/pocblockchain/pocc/blob/master/docs/DOCS_README.md) for details of the build process and
considerations when making changes.

## Version

 This documentation is built from the following commit:

repository: pocblockchain/pocc

repo_name: pocblockchain/pocc


text:
# Running The Dragons Graph
This tutorial explains how to run the Dragons graph sample distrib application on top of the Opensearch engine using the docker-compose.

The next [docker-compose](docker-compose-os.yml) is used to run the next services
 - OpenSearch
 - OpenSearch-dashboards
 - Fuse - (The Dragons Graph engine)

## Building
First we need to build the distribution folder that includes the dragons assemble.
run the next bash script `./buildDocker.sh Dragons` [here](runDocker.sh)
> Note: to make the script executable run `chmod +x start-fuse-service.sh`

Running this will result in the following steps:
- It will take the tag name (Dragons) given by the command line to create the docker image (`yangdb/yang.db:Dragons`)
- It will run the maven build command (`mvn clean install -DskipTests=true install -P core,dragons-assembly`)
- It will generate the target folder (distrib/dragons) which include the jars and script for running the graph engine (Fuse)
- It will generate the docker image based on the above folder

Once this process is complete - Run the docker-compose command:

## Running the Docker-compose services
The docker compose command `docker-compose -f docker-compose-os.yml up -d` will start all the relevant services
 - OpenSearch - http://localhost:9200
 - OpenSearch-Dashboard - http://localhost:5601
 - Fuse-Graph - http://localhost:8888

Once all services are up - navigate to the http://localhost:8888/swagger# url to verify the correctness of the Graph engine.

## Swagger API
The next API references allows access to all the Graph's functionality and configuration.
 - See [Docs](../docs/info/api.md)

![](../docs/info/img/swagger.png)

### Calling the Get Info API
Navigate to the next URL `http://localhost:8888/swagger#/API/get_` and call the `execute `

The next response is expected:
```json5
{
  "requestId": "FR870994186772480000",
  "elapsed": "00000080",
  "renderElapsed": "00000313",
  "totalElapsed": "00000393",
  "data": {
    "resourceUrl": "/fuse",
    "resourceId": null,
    "healthUrl": "/fuse/health",
    "internal": "/fuse/internal",
    "queryStoreUrl": "http://<IP_ADDRESS>:8888/fuse/query",
    "searchStoreUrl": "/fuse/search",
    "catalogStoreUrl": "http://<IP_ADDRESS>:8888/fuse/catalog/ontology"
  }
}
```
## Dragons Tutorial
For more advanced usage and tutorial please refer to the [Tutorials folder](../docs/tutorial)
- [Dragons Tutorial Installation](../docs/tutorial/sample/dragons/installation.md)
- [Dragons Tutorial Ontology](../docs/tutorial/sample/dragons/create-ontology.md)
- [Dragons Tutorial Data](../docs/tutorial/sample/dragons/load-data.md)
- [Dragons Tutorial Query](../docs/tutorial/sample/dragons/query-the-data.md)
- [Dragons Tutorial Projections](../docs/tutorial/sample/dragons/projection-and-count.md)

repository: YANG-DB/yang-db

branch_name: refs/heads/dev-opensearch

repo_name: YANG-DB/yang-db


text:
# API

The primary classes and functions exported by seltest are: `Base`, `url`,
`waitfor`, `waitforjs`, `dontwaitfor`, and `hide`.

All test classes must inherit from `Base`. All test methods within `Base` have
signature `(self, driver)`, and cannot start with an underscore (if they do,
they won't be run; this is useful for helper methods).

At the module and class level, the following attributes may be defined
(class-level attributes overriding the module-level attributes).

* `host`
  - The webserver host, e.g. `localhost:5050` under test.
  - This **must** be defined at either the module or the class level.
* `base_url`
  - (`str`) the URL relative to which all tests will be run. No `http://` required.
* `window_size`
  - (`[WIDTH, HEIGHT]`) sets the window size of the browser.

At the class level, you may set the following.

* `wait_for`
  - (`{"css_selector": SELECTOR_STRING, "classes": [CLASSNAME1, ..], "text":
    TEXT}`) before the screenshot is taken, seltest will wait for the conditions
    in `wait_for` to be satisfied.
    - `css_selector` is a typical CSS rule to select an element, e.g. `".classname
      div.anotherclass .etc"`
    - `classes`, optional is a list of classes we wait for the element to have.
    - `text`, optional, is the text we wait for the element to have.
  - You can set `wait_fors = [{..}]` instead, for a list of elements (and
    class/text conditions to wait for)

Decorators to be used on test methods are the following.

* `@url(URL_STRING)`
  - The URL the test should be run at, relative to the `base_url`, if any.
* `@waitfor(css_selector, text=None, classes=None)`
  - Elements to wait for (see `wait_for` above) on this particular test before
    taking the screenshot.
  - You can add as many of these to a single test as you'd like.
* `@waitforjs(js_string)`
  - Decorator which executes `js_string` on the page, and waits until it returns
    true before taking a screenshot.
  - e.g. `return window.height > 20`
* `@dontwaitfor(css_selector)`
  - If there is a class-level `wait_for` or `wait_fors`, ignore it for this test.
* `@hide(css_selector)`
  - Removes all elements matching `css_selector` before the screenshot is taken.
  - You can add as many of these to a single test as you'd like.

# Examples

This example comes from a real use of seltest.

```python
# -*- coding: utf-8 -*-
from seltest import url, waitfor, dontwaitfor, hide, Base
from selenium.webdriver.support.ui import Select
from selenium.webdriver.common.action_chains import ActionChains

host = 'localhost:5001'
window_size = [1280, 800]

class Website(Base):
    @url('/about')
    def about_page(self, driver):
        """The about/API documentation page."""
        pass

    @url('/comments')
    @hide('span.time')
    def comments(self, driver):
        """Initial view of the comments page."""
        pass

class Runs(Base):
    def page(self, driver):
        """Initial view of the runs page."""
        pass

    def info(self, driver):
        """Showing an expanded run row and information."""
        run = driver.find_element_by_css_selector('tr.run')
        run.click()

    def bams(self, driver):
        """Showing the list of BAMs in a project."""
        bam_btn_sel = 'div.project:last-child .project-stats a:first-child'
        bams = driver.find_element_by_css_selector(bam_btn_sel)
        bams.click()

class Examine(Base):
    base_url = base_url + '/runs/1/examine'
    wait_for = {'css_selector': '.query-status', 'classes': ['good']}

    def base(self, driver):
        """Initial view of a fully-loaded Examine page."""
        pass

    @waitfor('tr:first-child td:nth-child(20)', text='0')
    def sorted(self, driver):
        """Examine page sorted by decreasing Normal Read Depth."""
        rd = driver.find_element_by_css_selector('[data-attribute="sample:RD"] a')
        rd.click()

    def tooltip(self, driver):
        """Examine page showing a Normal Read Depth tooltip."""
        dp = driver.find_element_by_css_selector('[data-attribute="sample:RD"]')
        ActionChains(driver).move_to_element(dp).perform()

    @url('?query=sample_name+%3D+NORMAL+AND+info%3ADP+%3E+50+ORDER+BY+info%3ADP%2C+sample%3ARD+DESC')
    def filter(self, driver):
        """Examine page showing a filtered view."""
        pass

    def comments_view(self, driver):
        """Examine page showing a comment in view mode."""
        row = driver.find_element_by_css_selector('tbody tr')
        row.click()

    def comments_edit(self, driver):
        """Examine page showing a comment in edit mode."""
        row = driver.find_element_by_css_selector('tbody tr')
        row.click()
        btn = driver.find_elements_by_css_selector('.comment-edit')[1]
        btn.click()

    @dontwaitfor('.query-status')
    @waitfor('.query-status', classes=['bad'])
    def bad_query(self, driver):
        """Examine page showing a poorly formed query."""
        input = driver.find_element_by_css_selector('input[type="text"].tt-input')
        input.send_keys('bad query is so bad')

    @waitfor('tr:nth-child(12) td:nth-child(2)', text=u'✓')
    def validation(self, driver):
        """Examine page with a validation."""
        select = Select(driver.find_element_by_tag_name('select'))
        select.select_by_visible_text('file:///tmp/truthy-snv.vcf')
```

repository: pombredanne/seltest

repo_name: pombredanne/seltest


text:
# Amazon Reviews: Sentiment Analysis

## Table of Content
  * [Overview](#overview)
  * [Motivation](#motivation)
  * [Technical Aspects](#technical-aspects)
  * [Results](#result)
  * [Technologies](#technologies)
  * [To Do](#to-do)
  * [File List](#file-list)
  * [Credits](#credits)

## Overview
In this project, I loaded and processed titles of Amazon reviews to predict the review scores. I compared the performances of 3 models (Tensorflow):
* classification model with an LTSM layer
* regression model with an LTSM layer
* regression model with a 1D convolutional layer

In the end, the classifications made by these 3 models were compared with the classification made by a human being through AWS Sagemaker Ground Truth to understand whether the models were further improvable.

## Motivation
The book [Hands-On Machine Learning with Scikit-Learn, Keras & Tensorflow](https://www.oreilly.com/library/view/hands-on-machine-learning/9781492032632/) written by the author of Keras and most scientific articles recommend using classification models to perform sentiment analysis or score prediction. However, by doing so, we consider each score as a distinct class and lose the information of the sorting. To preserve this information I wanted to train a regression model and a classification model, with similar complexity, on the same data to see the difference in accuracy and MAE.

Moreover, I was curious to understand the potential of Tensorflow models with LTSM layers. In other words, I wanted to understand whether a simple model with few layers was able to reach the same performance of a human being in the identification of score ratings.

## Technical Aspect
In this project, I used the classical Keras functions for text preprocessing and tokenization i.e. *Tokenizer* and *pad_sequence*. Models were built in Tensorflow and performances visualization was made by *sklearn.confusion_matrix*.

The most original aspects are :
* The custom Keras metric *ordinal_accuracy* made to monitor accuracy during the training phase of regression models
* The output layer of regression models built with Lamba layer. It allows to bound output between -0.5 and 4.5.
* The *make_confusion_matrix* function used to visualize and understand confusion matrixes

## Result
The confusion matrixes obtained from the predictions of the 4 analyzed models are the following:

I noticed that:
1. The classification model provides a higher accuracy even if some predictions are heavily wrong (i.e. a lot of "5" in place of "1" or vice versa). The MAE is the highest because classes are independent and sorting information is not used.
2. Even if the regression models have the same complexity of the classification model, they do not provide so high accuracy. However, thanks to the optimization function used in the training phase, prediction errors are often lower.
3. Both classification and regression models, even if they are very simple, allow reaching the same precision of a human being. It is a proof of the potential of LSTM layers and convolutional layers in neural networks.

## Technologies
I used *nltk* library for text preprocessing, *Tensorflow* for model building and *AWS Ground Truth* to make data classified by human beings.

## To Do
* Since the accuracy of the model is similar to the accuracy of a human classifier, we may try to create a model only for reviews of a particular kind of object to obtain better performance.
* We may analyze full reviews and see whether performances improve or not.
* We may train the model on the full dataset (the number of reviews to load has been limited to speed up model training)

## File List
* **main.py** Data loading, data preprocessing, model training and model evaluation.
* **my_utils.py** Useful functions to load data and plot confusion matrixes

## Credits
* [DTrimarchi10](https://github.com/DTrimarchi10) - Thanks for the confusion_matrix function I took inspiration from
* [Hands-On Machine Learning with Scikit-Learn, Keras & Tensorflow](https://www.oreilly.com/library/view/hands-on-machine-learning/9781492032632/) - Thansk of the authors of the book for the advice about model building
* [Xiang Zhang](https://figshare.com/articles/dataset/Amazon_Reviews_Full/13232537/1) - Thanks for the complete dataset of Amazon reviews


text:
# BallotReady Polling Places

BallotReady collects polling places for elections across the United States. Please use these to help voters find their polling places. Email<EMAIL_ADDRESS>with any feedback.

## Usage

* Refer to `data/elections.json` for available elections.
* Find each elections polling places in the file referenced by `path`.

## Disclaimer

Data provided by respective state and county governments, and is subject to change. BallotReady is not responsible for errors, omissions or changes by government provided list.


text:
# google drive

api reference: https://developers.google.com/drive/api/v3/reference/
permissions used: "https://www.googleapis.com/auth/drive"
* permissions level doc: https://developers.google.com/drive/api/v2/about-auth

# google sheets

permissions:
doc:

# gmail

permissions:
doc:

# google docs

permissions:
doc:

# app scrips

# General things

A shareable URL of a Google Form is of the form

`https://docs.google.com/forms/d/{ID}/viewform`

where id is the ID associated with the file containing the form.
We can obtain that id via API.

repository: manuartero/evalytics

repo_name: manuartero/evalytics


text:
# Microfleet DLock Plugin

Wrapper for [Distributed callback queue](https://github.com/AVVS/distributed-callback-queue).

## Install

`yarn add @microfleet/plugin-dlock`

## Configuration

To make use of the plugin adjust microfleet configuration in the following way:

```ts
exports.plugins = [
  ...,
  'redisCluster', // or 'redisSentinel'
  'dlock',
  ...
]

exports.dlock = {
  // pubsubChannel: string;
  // lock?: {
  //   timeout?: number;
  //   retries?: number;
  //   delay?: number;
  // };
  // lockPrefix: string;
}
```

## Interface

Microfleet DLock Plugin extends service interface with the following methods:

### service.dlock: type of 'dlock'

Initialized instance. Look at the docs here - https://github.com/AVVS/distributed-callback-queue

repository: microfleet/core

repo_name: microfleet/core


text:
# ChainDB

![Issues Tracker](https://img.shields.io/github/issues/Montessquio/ChainDB)
![MIT License](https://img.shields.io/github/license/Montessquio/ChainDB)

ChainDB is a searchable PDF Database featuring an attractive front-end, user accounts, and tag-based as well as full text search.

## Features

- [ ] Upload, tag, and search for documents all from one convenient web UI.
- [ ] Add user-defined tags to documents.
- [ ] Restrict which users can upload, edit tags, and delete records.
- [ ] Deploy Easily with Docker and Compose.

## Installation

ChainDB can be run as a standalone executable, or within a docker container.

## Deploy with Docker

**Docker compatibility is currently a work in progress. [See Tracking Issue (#2)](https://github.com/Montessquio/ChainDB/issues/2)**

Deploying with Docker is as simple as pulling and running the image.
You must already have an elasticsearch server running ([https://www.elastic.co/](https://www.elastic.co/)).

```bash
docker pull montessquio/ChainDB

docker run -d -p 80:80 \
-v HOST/DATA/PATH:/chain_data \
-e ES_URL="http://<elastic_url>:9200" \
--name chainDB montessquio/ChainDB
```

The following environment variables are available:

- `ES_URL` - The URL of the ElasticSearch database. Passed to the `-e` CLI Flag.
- `DOMAIN` - The domain that this utility is served under. Valid values include <IP_ADDRESS>:80, app.example.net, and example.net. Passed to the `-r` CLI Flag.
- `ROOT` - The subdirectory of the domain this utility will be served under. If this is set to "db" then the page found normally at example.com/a.html will instead be found at example.com/db/a.html. Passed to the `-s` CLI Flag.

## Deploy with Docker-Compose

Deploying with Docker-Compose is easy. Download the compose file available at the root of the repo: [https://github.com/Montessquio/ChainDB/blob/master/docker-compose.yml](https://github.com/Montessquio/ChainDB/blob/master/docker-compose.yml)

Then, edit the file to suit your needs. All environment variables available in normal docker deployment are also available in docker-compose.

```bash
curl https://raw.githubusercontent.com/Montessquio/ChainDB/master/docker-compose.yml > docker-compose.yml

# Edit the docker file
vim docker-compose.yml

docker-compose up -d
```

ChainDB will be accessible via WebUI on port 80 by default.

## Deploy From Repo

### Compiling

Make sure you have the latest version of the Go toolchain installed: [https://golang.org/doc/install](https://golang.org/doc/install) as well as a functioning ElasticSearch instance: [https://www.elastic.co/](https://www.elastic.co/).

---

First, clone the repository to wherever you would like to run the server.

```plaintext
git clone https://github.com/Montessquio/ChainDB

cd ChainDB
```

Install all dependencies using `go get`

```plaintext
go get -v ./...
```

And then build the executable:

```plaintext
go build
```

The built executable should be found in the project root.

### Running

ChainDB needs two CLI arguments at minimum to run:

```plaintext
ChainDB -d <directory to store uploaded files> -e <ElasticSearch Server URL>
```

More configuration options can be found using `ChainDB -h`:

```plaintext
Usage of ChainDB:
  -d string
        Data directory to serve files from.
  -e string
        The URL of the ElasticSearch server.
  -p int
        Port to serve on (default 80)
  -r string
        The domain that this utility is served under. Valid values include <IP_ADDRESS>:80, app.example.net, and example.net
  -s string
        The subdirectory of the domain this utility will be served under. If this is set to "db" then the page found normally at example.com/a.html will instead be found at example.com/db/a.html
```

ChainDB will be accessible via WebUI on port 80 by default.

repository: Montessquio/ChainDB

repo_name: Montessquio/ChainDB


text:
# bigint

Elm's native integer type uses raw JavaScript integers which are limited in size ([MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER)). Sometimes, we want more.

This package provides a `BigInt` type and associated functions so that you can work with integers of unlimited size at the cost of some speed. Benchmarks included.

## Contributions
are very welcome!

## Aknowledgements

- Thank you [Javier Casas](https://github.com/javcasas) whose [elm-integer](https://github.com/javcasas/elm-integer) is the basis for this fork.
- Thank you [gilbertkennen](https://github.com/gilbertkennen) whose [bigint](https://github.com/gilbertkennen/bigint) is basically the verbatim basis for this repository.
- Thank you [hickscorp](https://github.com/hickscorp) whose [bigint](https://github.com/hickscorp/bigint) for the further work on top of the original BigInt library.

repository: cmditch/elm-bigint

gha_language: Elm

repo_name: cmditch/elm-bigint


text:
# qiwi-bill-payments-go-sdk [![GoDoc](https://pkg.go.dev/badge/github.com/RinatNamazov/qiwi-bill-payments-go-sdk)](https://pkg.go.dev/github.com/RinatNamazov/qiwi-bill-payments-go-sdk)

Golang SDK for QIWI Payments.

## Installation

```bash
go get github.com/RinatNamazov/qiwi-bill-payments-go-sdk
```

## Example

```go
package main

import (
	"fmt"
	"time"

	"github.com/RinatNamazov/qiwi-bill-payments-go-sdk"
	"github.com/google/uuid"
)

func main() {
	qiwiApi := qiwi.NewQiwiBillPaymentsAPI("SecretKey")

	billInfo := qiwi.CreateBillInfo{
		BillId:             uuid.New().String(),
		Comment:            "Donation for coffee.",
		ExpirationDateTime: time.Now().Add(time.Hour),
	}
	billInfo.Amount.SetValueNumber(100)
	billInfo.Amount.Currency = "RUB"

	billResp, err := qiwiApi.CreateBill(billInfo)
	if err != nil {
		fmt.Println(err)
	} else {
		fmt.Println("Amount: " + billInfo.Amount.Value + " " + billInfo.Amount.Currency +
			"\nBill ID: " + billInfo.BillId +
			"\nFor payment follow the link:\n" + billResp.PayUrl)
	}
}
```

## License
The code in this repository is licensed under MIT.
```
Copyright (c) 2021 RINWARES, Rinat Namazov

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

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

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


text:
# Localize PSDs / images for iOS apps

[![License](https://img.shields.io/cocoapods/l/KapabelSDK.svg?style=flat)](https://opensource.org/licenses/MIT)
[![Website](https://img.shields.io/badge/Website-oyvkva.com-green.svg)](http://oyvkva.com)

This AppleScript translates PSDs into all Apple App store languages and places the translations in the correct language folders.

You also need this Shell script:
https://github.com/soimort/translate-shell

repository: oyvkva/Localize-PSDs

repo_name: oyvkva/Localize-PSDs


text:
# To Do list

## General:

- Make documentation and clean objects;
- Improve Quick-Start;
- Improve CLI/make GUI.

## Loggers

- Add one logging message for each function/method call;
- Add more details about connected clients and connections setup;

## CLI

- Use `blessed` package;

## bot_manager.py:

- Start automatically several `StrategyManager` clients on several process;

## \_order.py:

- Use WebSockets instead of REST API.

## strategy_manager.py:

- Choose invested value in quote or base currency.