text:
# single-spa-cycle
a single-spa plugin for cycle.js applications (adapted from [CanopyTax/single-spa-react](https://github.com/CanopyTax/single-spa-react))

Generic lifecycle hooks for Cycle.js applications that are registered as [child applications](https://github.com/CanopyTax/single-spa/blob/master/docs/child-applications.md) of [single-spa](https://github.com/CanopyTax/single-spa).

## Quickstart

First, in the child application, run `npm install --save @pcmnac/single-spa-cycle`. Then, in your [child app's entry file](https://github.com/CanopyTax/single-spa/blob/docs-1/docs/configuring-child-applications.md#the-entry-file), do the following:

```js

import {run} from '@cycle/run'
import {makeDOMDriver} from '@cycle/dom'
import singleSpaCycle from '@pcmnac/single-spa-cycle';
import rootComponent from './root.component.js';

const cycleLifecycles = singleSpaCycle({
	run,
	rootComponent,
	drivers: { DOM: makeDOMDriver(document.getElementById('main-content'))}, // or { DOM: makeDOMDriver('#main-content')}
});

export const bootstrap = [
	cycleLifecycles.bootstrap
];

export const mount = [
	cycleLifecycles.mount
];

export const unmount = [
	cycleLifecycles.unmount
];
```

## Options

All options are passed to single-spa-cycle via the `opts` parameter when calling `singleSpaCycle(opts)`. The following options are available:

- `run`: (required) Cycle.js run function.
- `drivers`: (required) Drivers (including DOM Driver) to be used by your Cycle.js root component.
- `rootComponent`: (required) The top level Cycle.js component which will be rendered

repository: joeldenning/single-spa-cycle

repo_name: joeldenning/single-spa-cycle


text:
Evelyn-Flickr-Downloader
=======================

A Command line script to download the original-size photo from Flickr photo set, promoted by [小敬] (http://www.facebook.com/people/%E8%99%9E%E6%88%90%E6%95%AC/100001603870154)

Usage:
-----------------------

* Download directly with a Flickr photo set URL.

        $ Evelyn.pl 'http://www.flickr.com/photos/piazta/sets/72157630883766410/with/7474160854/'

* Download from a list of Flickr photo set URL.

        $ cat photo.txt
        http://www.flickr.com/photos/piazta/sets/72157630883766410/with/7474160854/
        http://www.flickr.com/photos/jup3nep/sets/72157594560896483/
        http://www.flickr.com/photos/batiks/sets/72157624657197522/
        $ Evelyn.pl photo.txt

Feature:
-----------------------

* Continue to download from last session.
* Each photo set will be stored into a single directory.

Copyright:
----------------------

FreeBSD License

repository: linpc/Evelyn-Flickr-Downloader

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: linpc/Evelyn-Flickr-Downloader


text:
# README

[![Crates.io](https://img.shields.io/crates/v/nu.svg)](https://crates.io/crates/nu)
[![Build Status](https://dev.azure.com/nushell/nushell/_apis/build/status/nushell.nushell?branchName=main)](https://dev.azure.com/nushell/nushell/_build/latest?definitionId=2&branchName=main)
[![Discord](https://img.shields.io/discord/601130461678272522.svg?logo=discord)](https://discord.gg/NtAbbGn)
[![The Changelog #363](https://img.shields.io/badge/The%20Changelog-%23363-61c192.svg)](https://changelog.com/podcast/363)
[![@nu_shell](https://img.shields.io/badge/twitter-@nu_shell-1DA1F3?style=flat-square)](https://twitter.com/nu_shell)
![GitHub commit activity](https://img.shields.io/github/commit-activity/m/nushell/nushell)
![GitHub contributors](https://img.shields.io/github/contributors/nushell/nushell)

## Nushell

A new type of shell.

![Example of nushell](images/nushell-autocomplete5.gif "Example of nushell")

## Status

This project has reached a minimum-viable product level of quality.
While contributors dogfood it as their daily driver, it may be unstable for some commands.
Future releases will work to fill out missing features and improve stability.
Its design is also subject to change as it matures.

Nu comes with a set of built-in commands (listed below).
If a command is unknown, the command will shell-out and execute it (using cmd on Windows or bash on Linux and macOS), correctly passing through stdin, stdout, and stderr, so things like your daily git workflows and even `vim` will work just fine.

## Learning more

There are a few good resources to learn about Nu.
There is a [book](https://www.nushell.sh/book/) about Nu that is currently in progress.
The book focuses on using Nu and its core concepts.

If you're a developer who would like to contribute to Nu, we're also working on a [book for developers](https://www.nushell.sh/contributor-book/) to help you get started.
There are also [good first issues](https://github.com/nushell/nushell/issues?q=is%3Aopen+is%3Aissue+label%3A%22good+first+issue%22) to help you dive in.

We also have an active [Discord](https://discord.gg/NtAbbGn) and [Twitter](https://twitter.com/nu_shell) if you'd like to come and chat with us.

You can also find information on more specific topics in our [cookbook](https://www.nushell.sh/cookbook/).

Try it in Gitpod.

[![Open in Gitpod](https://gitpod.io/button/open-in-gitpod.svg)](https://gitpod.io/#https://github.com/nushell/nushell)

## Installation

### Local

Up-to-date installation instructions can be found in the [installation chapter of the book](https://www.nushell.sh/book/installation.html). **Windows users**: please note that Nu works on Windows 10 and does not currently have Windows 7/8.1 support.

To build Nu, you will need to use the **latest stable (1.51 or later)** version of the compiler.

Required dependencies:

-   pkg-config and libssl (only needed on Linux)
    -   On Debian/Ubuntu: `apt install pkg-config libssl-dev`

Optional dependencies:

-   To use Nu with all possible optional features enabled, you'll also need the following:
    -   On Linux (on Debian/Ubuntu): `apt install libxcb-composite0-dev libx11-dev`

To install Nu via cargo (make sure you have installed [rustup](https://rustup.rs/) and the latest stable compiler via `rustup install stable`):

```shell
cargo install nu
```

To install Nu via the [Windows Package Manager](https://aka.ms/winget-cli):

```shell
winget install nu
```

You can also build Nu yourself with all the bells and whistles (be sure to have installed the [dependencies](https://www.nushell.sh/book/installation.html#dependencies) for your platform), once you have checked out this repo with git:

```shell
cargo build --workspace --features=extra
```

### Docker

#### Quickstart

Want to try Nu right away? Execute the following to get started.

```shell
docker run -it quay.io/nushell/nu:latest
```

#### Guide

If you want to pull a pre-built container, you can browse tags for the [nushell organization](https://quay.io/organization/nushell)
on Quay.io. Pulling a container would come down to:

```shell
docker pull quay.io/nushell/nu
docker pull quay.io/nushell/nu-base
```

Both "nu-base" and "nu" provide the nu binary, however, nu-base also includes the source code at `/code`
in the container and all dependencies.

Optionally, you can also build the containers locally using the [dockerfiles provided](docker):
To build the base image:

```shell
docker build -f docker/Dockerfile.nu-base -t nushell/nu-base .
```

And then to build the smaller container (using a Multistage build):

```shell
docker build -f docker/Dockerfile -t nushell/nu .
```

Either way, you can run either container as follows:

```shell
docker run -it nushell/nu-base
docker run -it nushell/nu
/> exit
```

The second container is a bit smaller if the size is important to you.

### Packaging status

[![Packaging status](https://repology.org/badge/vertical-allrepos/nushell.svg)](https://repology.org/project/nushell/versions)

#### Fedora

[COPR repo](https://copr.fedorainfracloud.org/coprs/atim/nushell/): `sudo dnf copr enable atim/nushell -y && sudo dnf install nushell -y`

## Philosophy

Nu draws inspiration from projects like PowerShell, functional programming languages, and modern CLI tools.
Rather than thinking of files and services as raw streams of text, Nu looks at each input as something with structure.
For example, when you list the contents of a directory, what you get back is a table of rows, where each row represents an item in that directory.
These values can be piped through a series of steps, in a series of commands called a 'pipeline'.

### Pipelines

In Unix, it's common to pipe between commands to split up a sophisticated command over multiple steps.
Nu takes this a step further and builds heavily on the idea of _pipelines_.
Just as the Unix philosophy, Nu allows commands to output to stdout and read from stdin.
Additionally, commands can output structured data (you can think of this as a third kind of stream).
Commands that work in the pipeline fit into one of three categories:

-   Commands that produce a stream (e.g., `ls`)
-   Commands that filter a stream (eg, `where type == "Dir"`)
-   Commands that consume the output of the pipeline (e.g., `autoview`)

Commands are separated by the pipe symbol (`|`) to denote a pipeline flowing left to right.

```shell
> ls | where type == "Dir" | autoview
───┬────────┬──────┬───────┬──────────────
 # │ name   │ type │ size  │ modified
───┼────────┼──────┼───────┼──────────────
 0 │ assets │ Dir  │ 128 B │ 5 months ago
 1 │ crates │ Dir  │ 704 B │ 50 mins ago
 2 │ debian │ Dir  │ 352 B │ 5 months ago
 3 │ docker │ Dir  │ 288 B │ 3 months ago
 4 │ docs   │ Dir  │ 192 B │ 50 mins ago
 5 │ images │ Dir  │ 160 B │ 5 months ago
 6 │ src    │ Dir  │ 128 B │ 1 day ago
 7 │ target │ Dir  │ 160 B │ 5 days ago
 8 │ tests  │ Dir  │ 192 B │ 3 months ago
───┴────────┴──────┴───────┴──────────────
```

Because most of the time you'll want to see the output of a pipeline, `autoview` is assumed.
We could have also written the above:

```shell
> ls | where type == Dir
```

Being able to use the same commands and compose them differently is an important philosophy in Nu.
For example, we could use the built-in `ps` command to get a list of the running processes, using the same `where` as above.

```shell
> ps | where cpu > 0
───┬────────┬───────────────────┬──────────┬─────────┬──────────┬──────────
 # │ pid    │ name              │ status   │ cpu     │ mem      │ virtual
───┼────────┼───────────────────┼──────────┼─────────┼──────────┼──────────
 0 │    435 │ irq/142-SYNA327   │ Sleeping │  7.5699 │      0 B │      0 B
 1 │   1609 │ pulseaudio        │ Sleeping │  6.5605 │  10.6 MB │   2.3 GB
 2 │   1625 │ gnome-shell       │ Sleeping │  6.5684 │ 639.6 MB │   7.3 GB
 3 │   2202 │ Web Content       │ Sleeping │  6.8157 │ 320.8 MB │   3.0 GB
 4 │ 328788 │ nu_plugin_core_ps │ Sleeping │ 92.5750 │   5.9 MB │ 633.2 MB
───┴────────┴───────────────────┴──────────┴─────────┴──────────┴──────────
```

### Opening files

Nu can load file and URL contents as raw text or structured data (if it recognizes the format).
For example, you can load a .toml file as structured data and explore it:

```shell
> open Cargo.toml
────────────────────┬───────────────────────────
 bin                │ [table 18 rows]
 build-dependencies │ [row serde toml]
 dependencies       │ [row 29 columns]
 dev-dependencies   │ [row nu-test-support]
 features           │ [row 19 columns]
 package            │ [row 12 columns]
 workspace          │ [row members]
────────────────────┴───────────────────────────
```

We can pipeline this into a command that gets the contents of one of the columns:

```shell
> open Cargo.toml | get package
───────────────┬────────────────────────────────────
 authors       │ [table 1 rows]
 default-run   │ nu
 description   │ A new type of shell
 documentation │ https://www.nushell.sh/book/
 edition       │ 2018
 exclude       │ [table 1 rows]
 homepage      │ https://www.nushell.sh
 license       │ MIT
 name          │ nu
 readme        │ README.md
 repository    │ https://github.com/nushell/nushell
 version       │ 0.32.0
───────────────┴────────────────────────────────────
```

Finally, we can use commands outside of Nu once we have the data we want:

```shell
> open Cargo.toml | get package.version
0.32.0
```

Here we use the variable `$it` to refer to the value being piped to the external command.

### Configuration

Nu has early support for configuring the shell. You can refer to the book for a list of [all supported variables](https://www.nushell.sh/book/configuration.html).

To set one of these variables, you can use `config set`. For example:

```shell
> config set line_editor.edit_mode "vi"
> config set path $nu.path
```

### Shells

Nu will work inside of a single directory and allow you to navigate around your filesystem by default.
Nu also offers a way of adding additional working directories that you can jump between, allowing you to work in multiple directories simultaneously.

To do so, use the `enter` command, which will allow you to create a new "shell" and enter it at the specified path.
You can toggle between this new shell and the original shell with the `p` (for previous) and `n` (for next), allowing you to navigate around a ring buffer of shells.
Once you're done with a shell, you can `exit` it and remove it from the ring buffer.

Finally, to get a list of all the current shells, you can use the `shells` command.

### Plugins

Nu supports plugins that offer additional functionality to the shell and follow the same structured data model that built-in commands use.
This allows you to extend nu for your needs.

There are a few examples in the `plugins` directory.

Plugins are binaries that are available in your path and follow a `nu_plugin_*` naming convention.
These binaries interact with nu via a simple JSON-RPC protocol where the command identifies itself and passes along its configuration, making it available for use.
If the plugin is a filter, data streams to it one element at a time, and it can stream data back in return via stdin/stdout.
If the plugin is a sink, it is given the full vector of final data and is given free reign over stdin/stdout to use as it pleases.

## Goals

Nu adheres closely to a set of goals that make up its design philosophy. As features are added, they are checked against these goals.

-   First and foremost, Nu is cross-platform. Commands and techniques should carry between platforms and offer consistent first-class support for Windows, macOS, and Linux.

-   Nu ensures direct compatibility with existing platform-specific executables that make up people's workflows.

-   Nu's workflow and tools should have the usability in day-to-day experience of using a shell in 2019 (and beyond).

-   Nu views data as both structured and unstructured. It is a structured shell like PowerShell.

-   Finally, Nu views data functionally. Rather than using mutation, pipelines act as a means to load, change, and save data without mutable state.

## Commands

You can find a list of Nu commands, complete with documentation, in [quick command references](https://www.nushell.sh/book/command_reference.html).

## Progress

Nu is in heavy development and will naturally change as it matures and people use it. The chart below isn't meant to be exhaustive, but rather helps give an idea for some of the areas of development and their relative completion:

| Features      | Not started | Prototype | MVP | Preview | Mature | Notes                                                                |
| ------------- | :---------: | :-------: | :-: | :-----: | :----: | -------------------------------------------------------------------- |
| Aliases       |             |           |  X  |         |        | Aliases allow for shortening large commands, while passing flags     |
| Notebook      |             |     X     |     |         |        | Initial jupyter support, but it loses state and lacks features       |
| File ops      |             |           |  X  |         |        | cp, mv, rm, mkdir have some support, but lacking others              |
| Environment   |             |           |  X  |         |        | Temporary environment and scoped environment variables               |
| Shells        |             |     X     |     |         |        | Basic value and file shells, but no opt-in/opt-out for commands      |
| Protocol      |             |           |  X  |         |        | Streaming protocol is serviceable                                    |
| Plugins       |             |     X     |     |         |        | Plugins work on one row at a time, lack batching and expression eval |
| Errors        |             |           |  X  |         |        | Error reporting works, but could use usability polish                |
| Documentation |             |           |  X  |         |        | Book updated to latest release, including usage examples             |
| Paging        |             |     X     |     |         |        | Textview has paging, but we'd like paging for tables                 |
| Functions     |             |           |  X  |         |        | Functions and aliases are supported                                  |
| Variables     |             |           |  X  |         |        | Nu supports variables and environment variables                      |
| Completions   |             |           |  X  |         |        | Completions for filepaths                                            |
| Type-checking |             |           |  X  |         |        | Commands check basic types, but input/output isn't checked           |

## Current Roadmap

We've added a `Roadmap Board` to help collaboratively capture the direction we're going for the current release and capture some important issues we'd like to see in Nushell. You can find the Roadmap [here](https://github.com/nushell/nushell/projects/2).

## Contributing

See [Contributing](CONTRIBUTING.md) for details.

Thanks to all the people who already contributed!

## License

The project is made available under the MIT license. See the `LICENSE` file for more information.

license: MIT

repository: seanwallawalla-forks/nushell

branch_name: refs/heads/main

gha_license_id: MIT

repo_name: seanwallawalla-forks/nushell


text:
# Java for Kubernetes 101

## Lab 1 Setup Kubernetes Cluster

In this lab we will setup a free Kuberentes cluster running on IBM Cloud (IKS).

To start this lab click [here](https://labs.cognitiveclass.ai/tools/theiadocker/?md_instructions_url=https%3A%2F%2Fcf-courses-data.s3.us.cloud-object-storage.appdomain.cloud%2FIBMDeveloperSkillsNetwork-JV0104EN-SkillsNetwork%2Flabs%2Flab1_setup_cloud%2Finstructional-labs.md).

## Lab 2 Deploy to Kubernetes

In this lab we will connect to a Kubernetes cluster and deploy a simple application.

To start this lab click [here](https://labs.cognitiveclass.ai/tools/theiadocker/?md_instructions_url=https%3A%2F%2Fcf-courses-data.s3.us.cloud-object-storage.appdomain.cloud%2FIBMDeveloperSkillsNetwork-JV0104EN-SkillsNetwork%2Flabs%2Flab2_deploy_to_k8s%2Finstructional-labs.md).

## Lab 3 Hands-on with Kubectl

In this lab we will get hands-on with Kubectl, using to it to search for resources, debug applications, and updates resources.

To start this lab click [here](https://labs.cognitiveclass.ai/tools/theiadocker/?md_instructions_url=https%3A%2F%2Fcf-courses-data.s3.us.cloud-object-storage.appdomain.cloud%2FIBMDeveloperSkillsNetwork-JV0104EN-SkillsNetwork%2Flabs%2Flab3_working_kubectl%2Finstructional-labs.md).

## Lab 4 Design Applications for Kubernetes

In this lab we will look at some of the design considerations to make when writing applications that will be running in a Kubernetes environment.

To start this lab click [here](https://labs.cognitiveclass.ai/tools/theiadocker/?md_instructions_url=https%3A%2F%2Fcf-courses-data.s3.us.cloud-object-storage.appdomain.cloud%2FIBMDeveloperSkillsNetwork-JV0104EN-SkillsNetwork%2Flabs%2Flab4_design_applications_for_k8s%2Finstructional-labs.md).

## Lab 5 Working with Volumes and Environment Variables

In this lab we will look at ways of providing configuration information and environmental values through Kubernetes.

To start this lab click [here](https://labs.cognitiveclass.ai/tools/theiadocker/?md_instructions_url=https%3A%2F%2Fcf-courses-data.s3.us.cloud-object-storage.appdomain.cloud%2FIBMDeveloperSkillsNetwork-JV0104EN-SkillsNetwork%2Flabs%2Flab5_config_in_k8s%2Finstructional-labs.md).


text:
## [1.0.2] - 2019-06-11

### Fixed
- npm build

## [1.0.1] - 2019-06-07

### Added
- infura.io network test

### Fixed
- wrong package path
- README

## [1.0.0] - 2019-06-07

Breaking API changes (constructor parameters).

### Added
- unicode support
- new tests to handle non-existed names #21

### Changed
- constructor parameters. Now parameters is optional #13
Default network is https://eth.gateway.whoisens.org and networkId is taken from JSON-RPC call.
- migrated to [JSON-RPC3](https://github.com/industral/JSON-RPC3)
- improved tests
- moved common tests #22

## [1.0.0-beta.8] - 2019-05-31

### Added
- dependencies & devDependencies shields
- build dist for browsers `npm run build:browser`
- added test for browsers as well

### Changed
- updated dependencies
- separated browser and nodejs tests

### Fixed
- CommonJS doesn't work #14
- Add unit test in real browser #12

## [1.0.0-beta.7] - 2019-05-30

### Changed
- updated `whoisens-test-dataset`
- updated README
- execute tests before npm publish

## [1.0.0-beta.6] - 2019-05-23

### Changed
- changed target from es2018 to es2017, so Edge understands it
- changed http to https

## [1.0.0-beta.5] - 2019-05-22

### Changed
- switched tests from infura to internal one http://eth.gateway.whoisens.org

## [1.0.0-beta.4] - 2019-05-21

### Added
- addressType to output

## [1.0.0-beta.3] - 2019-05-21

### Changed
- used external dataset
- returns errors if JSON RCP has one
- other small fixes

## [1.0.0-beta.2] - 2019-05-20

### Added

- ability to set custom network url endpoint #2
- integrated Travis CI

## [1.0.0-beta.1] - 2019-05-17

API is changed.

### Changed
- lot of code refactoring. API is changed.

### Added
- integration tests #1
- added support for subdomains #3
- new info in result object for JSON RCP, including contract address, method, payload, parameters, etc...
- support for ems and cjs
- documentation

## [0.0.7] - 2019-05-15

### Changed
- fixed TS errors

## [0.0.2] - 2019-05-15

### Changed
- code refactoring
- ESM compatible

## [0.0.1] - 2019-05-11

Initial version

repository: whoisens/whoisens-lib

gha_language: TypeScript

repo_name: whoisens/whoisens-lib


text:
# CordBot
> An Open-Source Multi-Purpose Discord Bot

```bash
git clone https://github.com/LukasDoesDev/cordbot
cd cordbot

echo "SECRET_TOKEN=abcdef" > .env

npm install
npm run dev
```

repository: LukasDoesDev/cordbot

repo_name: LukasDoesDev/cordbot


text:
# Popup generator Demo

## Features
- Adding elements such as Headings, Text, Images, Form with e-mail type
- Drag n Drop elements
- Creating another canvas
- Real-time testing your Popup
- Generating script and storage on our vps hosting
 (so no worries about coding and programming )
 Just attach link with ready script in head section
- Saving your current progress via localStorage API

### Live demo
[http://vps476880.ovh.net:4000/](http://vps476880.ovh.net:4000/)

### Form element
If you would like offer some products or receive e-mail of your customers you can provide endpoint in **Form** field.
The data will be available as a object with this structure ` {mail<EMAIL_ADDRESS>For testing this up set up your endpoint with `http://vps476880.ovh.net:4000/test` and check response in console browser.

[![](https://iv.pl/images/80054974847721630161.png)](https://iv.pl/images/80054974847721630161.png)

### Another Canvas

If you added Form element, default behavior after clicking submit button is alert with 'Thank you' text. Instead this you can simply add Another Canvas for customize this message as like as you wish.

### Usage
- Login with google+ account
- Add some elements
- When you done click Generate script in elements section
- Copy and paste script into your **HEAD** section in your webpage
e.g.
```html
<!DOCTYPE html>
<html>
    <head>
        <mate charest="utf-8" />
        <title>Hello world!</title>
		<script async src="http://vps476880.ovh.net:4000/script/7dbf80dfff9e"></script>
    </head>
    <body>
        <h1>Hello world!</h1>
    </body>
</html>
```
- Enjoy :)

### Small mention
As you can see the title contains **demo** .  So this project you should treat as a demo :D
I can not give you a guarantee that it will be works correctly and constantly. I built this project just for develop my programming skills

#### License
The MIT License.

repository: sebekgr/notificationScriptGenerator

repo_name: sebekgr/notificationScriptGenerator


text:
# Description

**Type:** Distributed
**Requires CredSSP:** No

This resource is used to create or remove a SPTrustedSecurityTokenIssuer in
a SharePoint farm.

It requires to specify either a MetadataEndPoint or a certificate.

The certificate can be specified by setting either parameter
SigningCertificateThumbPrint or SigningCertificateFilePath. If specifying
both SigningCertificateThumbPrint and SigningCertificateFilePath, the
certificate thumbprint from the file will be verified with the specified
SigningCertificateThumbPrint. If the thumbprints doesn't match an exception
will be thrown when configuring the resource.

The SigningCertificateThumbPrint must be the thumbprint of the signing
certificate stored in the certificate store LocalMachine\My of the server.
If SigningCertificateFilePath is also specified it must be the same
thumbrint as the certificate file.

The SigningCertificateFilePath must be the file path to the public key of
the signing certificate.

Properties RegisteredIssuerNameIdentifier and RegisteredIssuerNameRealm
compose the RegisteredIssuerName. If RegisteredIssuerNameRealm is ommitted,
it will be set with the realm of the farm.

The default value for the Ensure parameter is Present. When not specifying this
parameter, the token issuer is created.

repository: ykuijs/SharePointDsc

gha_language: C#

repo_name: ykuijs/SharePointDsc


text:
# 275. H-Index II [M]
Follow up for [H-Index](https://leetcode.com/problems/h-index/): What if the citations array is sorted in ascending order? Could you optimize your algorithm?

##### Hint:

- Expected runtime complexity is in O(log n) and the input is sorted.

# Code:
```c++
class Solution
{
public:
    int hIndex(vector<int>& citations)
    {
        // binary search.
        int begin = 0, end = citations.size() - 1;
        while (begin <= end)
        {
            int mid = begin + (end - begin) / 2;
            if (citations[mid] < citations.size() - mid)
                begin = mid + 1;
            else
                end = mid - 1;
        }

        return citations.size() - begin;
    }
};
```

path: /algorithm/275.H-Index II.md

filename: 275.H-Index II.md


text:
### Project Overview

 Collection of data and then analysis to get a result

### Learnings from the project

 I have learned about working with Lists, Dictionary in Python.

### Approach taken to solve the problem

 Simple we learn to make a data analysis.

### Challenges faced

 I have learned to work with Lists and Dictionaries and also to concatinate two strings and give space between them.


text:
# paster
A place to store code, snippets, useful commands, and other useful text on the internet.

## Software to Install on the Host (Need to find a good deployment plan - maybe integrate contianers)
nginx, sbcl (common lisp), build-essentials (make), roswell (CL env), git

## Config Files
- TODO
- touch ~/.config/common-lisp/source-registry.conf.d/rzm-user.conf
```
(:tree "/home/rzm/dev/")
```

repository: ryanmarion/paster

repo_name: ryanmarion/paster


text:
---
title: Timers in Node.js
layout: docs.hbs
---

# Timers in Node.js and beyond

The Timers module in Node.js contains functions that execute code after a set
period of time. Timers do not need to be imported via `require()`, since
all the methods are available globally to emulate the browser JavaScript API.
To fully understand when timer functions will be executed, it's a good idea to
read up on the Node.js
[Event Loop](/en/docs/guides/event-loop-timers-and-nexttick/).

## Controlling the Time Continuum with Node.js

The Node.js API provides several ways of scheduling code to execute at
some point after the present moment. The functions below may seem familiar,
since they are available in most browsers, but Node.js actually provides
its own implementation of these methods. Timers integrate very closely
with the system, and despite the fact that the API mirrors the browser
API, there are some differences in implementation.

### "When I say so" Execution ~ *`setTimeout()`*

`setTimeout()` can be used to schedule code execution after a designated
amount of milliseconds. This function is similar to
[`window.setTimeout()`](https://developer.mozilla.org/en-US/docs/Web/API/WindowTimers/setTimeout)
from the browser JavaScript API, however a string of code cannot be passed
to be executed.

`setTimeout()` accepts a function to execute as its first argument and the
millisecond delay defined as a number as the second argument. Additional
arguments may also be included and these will be passed on to the function. Here
is an example of that:

```js
function myFunc(arg) {
  console.log(`arg was => ${arg}`);
}

setTimeout(myFunc, 1500, 'funky');
```

The above function `myFunc()` will execute as close to 1500
milliseconds (or 1.5 seconds) as possible due to the call of `setTimeout()`.

The timeout interval that is set cannot be relied upon to execute after
that *exact* number of milliseconds. This is because other executing code that
blocks or holds onto the event loop will push the execution of the timeout
back. The *only* guarantee is that the timeout will not execute *sooner* than
the declared timeout interval.

`setTimeout()` returns a `Timeout` object that can be used to reference the
timeout that was set. This returned object can be used to cancel the timeout (
see `clearTimeout()` below) as well as change the execution behavior (see
`unref()` below).

### "Right after this" Execution ~ *`setImmediate()`*

`setImmediate()` will execute code at the end of the current event loop cycle.
This code will execute *after* any I/O operations in the current event loop and
*before* any timers scheduled for the next event loop. This code execution
could be thought of as happening "right after this", meaning any code following
the `setImmediate()` function call will execute before the `setImmediate()`
function argument.

The first argument to `setImmediate()` will be the function to execute. Any
subsequent arguments will be passed to the function when it is executed.
Here's an example:

```js
console.log('before immediate');

setImmediate((arg) => {
  console.log(`executing immediate: ${arg}`);
}, 'so immediate');

console.log('after immediate');
```

The above function passed to `setImmediate()` will execute after all runnable
code has executed, and the console output will be:

```
before immediate
after immediate
executing immediate: so immediate
```

`setImmediate()` returns an `Immediate` object, which can be used to cancel
the scheduled immediate (see `clearImmediate()` below).

> Don't get `setImmediate()` confused with `process.nextTick()`. There are
> some major ways they differ. The first is that `process.nextTick()` will run
> *before* any `Immediate`s that are set as well as before any scheduled I/O.
> The second is that `process.nextTick()` is non-clearable, meaning once
> code has been scheduled to execute with `process.nextTick()`, the execution
> cannot be stopped, just like with a normal function. Refer to [this guide](/en/docs/guides/event-loop-timers-and-nexttick/#process-nexttick)
> to better understand the operation of `process.nextTick()`.

### "Infinite Loop" Execution ~ *`setInterval()`*

If there is a block of code that should execute multiple times, `setInterval()`
can be used to execute that code. `setInterval()` takes a function
argument that will run an infinite number of times with a given millisecond
delay as the second argument. Just like `setTimeout()`, additional arguments
can be added beyond the delay, and these will be passed on to the function call.
Also like `setTimeout()`, the delay cannot be guaranteed because of operations
that may hold on to the event loop, and therefore should be treated as an
approximate delay. See the below example:

```js
function intervalFunc() {
  console.log('Cant stop me now!');
}

setInterval(intervalFunc, 1500);
```

In the above example, `intervalFunc()` will execute about every 1500
milliseconds, or 1.5 seconds, until it is stopped (see below).

Just like `setTimeout()`, `setInterval()` also returns a `Timeout` object which
can be used to reference and modify the interval that was set.

## Clearing the Future

What can be done if a `Timeout` or `Immediate` object needs to be cancelled?
`setTimeout()`, `setImmediate()`, and `setInterval()` return a timer object
that can be used to reference the set `Timeout` or `Immediate` object.
By passing said object into the respective `clear` function, execution of
that object will be halted completely. The respective functions are
`clearTimeout()`, `clearImmediate()`, and `clearInterval()`. See the example
below for an example of each:

```js
const timeoutObj = setTimeout(() => {
  console.log('timeout beyond time');
}, 1500);

const immediateObj = setImmediate(() => {
  console.log('immediately executing immediate');
});

const intervalObj = setInterval(() => {
  console.log('interviewing the interval');
}, 500);

clearTimeout(timeoutObj);
clearImmediate(immediateObj);
clearInterval(intervalObj);
```

## Leaving Timeouts Behind

Remember that `Timeout` objects are returned by `setTimeout` and `setInterval`.
The `Timeout` object provides two functions intended to augment `Timeout`
behavior with `unref()` and `ref()`. If there is a `Timeout` object scheduled
using a `set` function, `unref()` can be called on that object. This will change
the behavior slightly, and not call the `Timeout` object *if it is the last
code to execute*. The `Timeout` object will not keep the process alive, waiting
to execute.

In similar fashion, a `Timeout` object that has had `unref()` called on it
can remove that behavior by calling `ref()` on that same `Timeout` object,
which will then ensure its execution. Be aware, however, that this does
not *exactly* restore the initial behavior for performance reasons. See
below for examples of both:

```js
const timerObj = setTimeout(() => {
  console.log('will i run?');
});

// if left alone, this statement will keep the above
// timeout from running, since the timeout will be the only
// thing keeping the program from exiting
timerObj.unref();

// we can bring it back to life by calling ref() inside
// an immediate
setImmediate(() => {
  timerObj.ref();
});
```

## Further Down the Event Loop

There's much more to the Event Loop and Timers than this guide
has covered. To learn more about the internals of the Node.js
Event Loop and how Timers operate during execution, check out
this Node.js guide: [The Node.js Event Loop, Timers, and
process.nextTick()](/en/docs/guides/event-loop-timers-and-nexttick/).

gha_license_id: NOASSERTION


text:
# ADD the Log Class

If you want to add a log window:
* Copy log.h and the log.cpp file into your directory and add them to the cmake text file
* Reconfigure and regenerate your project

To use it in your scene:
* Include ```"log.h"```
* Create a Log variable  like that   ``` Log log;  ```
* In your scene update do  ``` log.Draw(); ```

To add info to the logs use  ```log.addInfo(my_message); ```
The variable my_message is of type string

You can Save in the file  ```log.txt ```  with
 ``` log.save(); ```
 or by using the save button in the menu of the log window

 You can also clear the logs by using
  ```log.clear(); ```
or by using  the clear button in the menu

You can also save at each draw by ticking the autosave checkbox
or by using  ```log.setAutoSave(true); ```


text:
# Go SDK for Azure - Examples
Some raw/basic examples of using the Go SDK for Azure to deploy various resources

These have been created/tested with Go v1.12 (using modules), I don't know or care if they work with older versions of Go before they introduced modules

## Usage
Create a `.env` file containing all your secrets and place it at the root of this project (i.e. above the `src` directory)
Optionally set these via environmental variables on your system though another means

Example file
```c
AZURE_TENANT_ID="your-tenant-id"
AZURE_SUBSCRIPTION_ID="your-tenant-id"
AZURE_CLIENT_ID="your-service-principal-id"
AZURE_CLIENT_SECRET="your-service-principal-secret-password"
```

## src/webapp
Deploy a Windows App Service Web App (and App Service Plan) and pulls code down from GitHub to deploy a fully functioning site

Takes four parameters
- Resource group name (will be created)
- Azure region location
- App Service site name
- Public Git URL (e.g. GitHub) to deploy to the new Web App

```
cd cmd/webapp
go run main.go myResGrp northeurope demosite2018 https://github.com/benc-uk/nodejs-demoapp.git
```

## src/webapp-container
Deploy a Linux App Service Web App (and App Service Plan) and pulls container image down from Dockerhub to deploy a fully functioning site

Takes four parameters
- Resource group name (will be created)
- Azure region location
- App Service site name
- Dockerhub public image, e.g. `nginx` or one from your own repo

```
cd cmd/webapp-container
go run main.go -g temp.myResGrp -l northeurope -n demosite22 -i bencuk/nodejs-demoapp
```

repository: benc-uk/azure-samples

gha_language: PowerShell

repo_name: benc-uk/azure-samples


text:
---
layout: post
title: "Forsaking Self"
date: 2014-06-16 09:29:09 -0400
comments: true
categories:
---
*or... "Why I Agree With Andy Matuschak, But Would Rather Fix Swift"*

[Justin Spahr-Summers](https://twitter.com/jspahrsummers),
[Andy Matuschak](http://andymatuschak.org), and I had a
[brief Twitter exchange](https://twitter.com/jspahrsummers/status/478055530036875264)
a few days ago about when you should use `self`. These are smart guys who I've
been listening to for a long time now, and I'm not saying they're not right.
I'm just saying it's a mistake in the language that should be fixed.

Some background: Swift currently allows but does not require `self.` to refer
to an object's own properties and methods. So the question is: what rules
should Swift programmers use to decide whether to include `self.`, or should
Swift be changed to require it?

### Some principles

We need to agree first on a few principles. If you disagree with these things,
we're never going to agree on the end result. But I hope these principles
aren't particularly controversial among professional programmers in any
language, and particularly among ObjC developers.

Good coding practices are those that make it easier to...

1. write correct code (i.e. discourage behaviors that are likely to create new bugs)
2. detect incorrect code (i.e. make it easier to code review and debug)
3. understand and modify code, while maintaining its correctness

I consider other concerns secondary. For example, I believe it's much more
important that it be easy to write correct code than it be easy to write fast
code.

So what about "shortness" of code? It's the same as in other kinds of
technical writing (and source code is kind of techincal writing, with an
audience of both programmers and compilers). It should be concise and to the
point, but the first concern is not the number of letters the author must
write. Good code should be the same. Extraneous details, obvious to the
reader, should eliminated. But important details should not be omitted. And as
in technical writing, assume that the reader may have jumped into this section
without reading everything that came before.

So all of this is just to dispel the possible answer "do whichever takes fewer
keystrokes."

repository: rnapier/cocoaphony-blog

extension: markdown

gha_language: CSS

repo_name: rnapier/cocoaphony-blog


text:
# Pinax Command Line Interface

[![](https://img.shields.io/pypi/v/pinax-cli.svg)](https://pypi.python.org/pypi/pinax-cli/)

[![CircleCi](https://img.shields.io/circleci/project/github/pinax/pinax-cli.svg)](https://circleci.com/gh/pinax/pinax-cli)
[![Codecov](https://img.shields.io/codecov/c/github/pinax/pinax-cli.svg)](https://codecov.io/gh/pinax/pinax-cli)
[![](https://img.shields.io/github/contributors/pinax/pinax-cli.svg)](https://github.com/pinax/pinax-cli/graphs/contributors)
[![](https://img.shields.io/github/issues-pr/pinax/pinax-cli.svg)](https://github.com/pinax/pinax-cli/pulls)
[![](https://img.shields.io/github/issues-pr-closed/pinax/pinax-cli.svg)](https://github.com/pinax/pinax-cli/pulls?q=is%3Apr+is%3Aclosed)

[![](http://slack.pinaxproject.com/badge.svg)](http://slack.pinaxproject.com/)
[![](https://img.shields.io/badge/license-MIT-blue.svg)](https://opensource.org/licenses/MIT)

## Table of Contents

* [About Pinax](#about-pinax)
* [Overview](#overview)
  * [Supported Django and Python versions](#supported-django-and-python-versions)
* [Documentation](#documentation)
  * [Installation](#installation)
  * [Usage](#usage)
* [Change Log](#change-log)
* [Contribute](#contribute)
* [Code of Conduct](#code-of-conduct)
* [Connect with Pinax](#connect-with-pinax)
* [License](#license)

## About Pinax

Pinax is an open-source platform built on the Django Web Framework. It is an ecosystem of reusable
Django apps, themes, and starter project templates. This collection can be found at http://pinaxproject.com.

## pinax-cli

### Overview

`pinax-cli` is a command-line interface for installing Pinax starter projects
and learning more about the latest Pinax app releases.

#### Supported Django and Python versions

Django \ Python | 2.7 | 3.4 | 3.5 | 3.6
--------------- | --- | --- | --- | ---
1.11 |  *  |  *  |  *  |  *
2.0  |     |  *  |  *  |  *

## Documentation

### Installation

To install pinax-cli:

```shell
$ pip install pinax-cli
```

### Usage

Invoke pinax-cli with `$ pinax <cmd>` using one of the following commands:

#### `pinax apps`

Show a list of Pinax apps with their release version in the latest Pinax distribution.

```shell
$ pinax apps
```

#### `pinax demos`

Show a list of Pinax demonstration projects with their release version in the latest Pinax distribution.

```shell
$ pinax demos
```

#### `pinax projects`

Show a list of Pinax starter projects and their release version in the latest Pinax distribution.

```shell
$ pinax projects
Release Project
------- ---------------
  4.0.4 account
  4.0.4 blog
  2.0.4 company
        documents
        social-auth
  4.0.4 static
  4.0.4 stripe
        team-wiki
  3.0.4 waitinglist
        wiki
  4.0.4 zero
```

#### `pinax tools`

Show a list of Pinax tools with their release version in the latest Pinax distribution.

```shell
$ pinax tools
```

#### `pinax start <starter_project> <my_project> [--dev] [--location <path>]`

Create a new project based on a specific Pinax starter project.

`<starter_project>` must be one of the project names shown by `pinax projects`.

The `--dev` flag tells pinax-cli to install the latest starter project code from the repository rather than the most recent release.
Use this option if you require the latest version of a starter project.

The `--location <path>` flag tells pinax-cli where to create the new project. By default
the project is created in a sub-directory named `my_project`.

## Change Log

### 1.1.4

* Restore support for Django 1.11 with Python 2.7

### 1.1.3

* Drop support for Python 2.7 and Django < 2.0; require Python 3.4+ and Django 2.0+

### 1.1.2

* Use Django v1.11 for project creation if installed Python == 2.7
* Add usage examples, color, and sub-command short description to help
* Add `crayons` and `django` requirements to setup.py

### 1.1.1

* Fix post-start cleanup path references

### 1.1.0

* Drop Python 3.3 support
* Standardize documentation layout
* Move documentation into README.md
* Convert CI and coverage to CircleCi and CodeCov
* Add PyPi-compatible long description
* Improve .gitignore

### 1.0.0

* Add "apps", "demos", "themes", and "tools" commands.

## Contribute

For an overview on how contributing to Pinax works read this [blog post](http://blog.pinaxproject.com/2016/02/26/recap-february-pinax-hangout/)
and watch the included video, or read our [How to Contribute](http://pinaxproject.com/pinax/how_to_contribute/) section.
For concrete contribution ideas, please see our
[Ways to Contribute/What We Need Help With](http://pinaxproject.com/pinax/ways_to_contribute/) section.

In case of any questions we recommend you join our [Pinax Slack team](http://slack.pinaxproject.com)
and ping us there instead of creating an issue on GitHub. Creating issues on GitHub is of course
also valid but we are usually able to help you faster if you ping us in Slack.

We also highly recommend reading our blog post on [Open Source and Self-Care](http://blog.pinaxproject.com/2016/01/19/open-source-and-self-care/).

## Code of Conduct

In order to foster a kind, inclusive, and harassment-free community, the Pinax Project
has a [code of conduct](http://pinaxproject.com/pinax/code_of_conduct/).
We ask you to treat everyone as a smart human programmer that shares an interest in Python, Django, and Pinax with you.

## Connect with Pinax

For updates and news regarding the Pinax Project, please follow us on Twitter [@pinaxproject](https://twitter.com/pinaxproject)
and check out our [Pinax Project blog](http://blog.pinaxproject.com).

## License

Copyright (c) 2012-2019 James Tauber and contributors under the [MIT license](https://opensource.org/licenses/MIT).

repository: UpToTime/pinax-cli

repo_name: UpToTime/pinax-cli


text:
# Counter Example

[![Demo](https://img.shields.io/website?label=demo&url=https%3A%2F%2Fexamples.yew.rs%2Fcounter)](https://examples.yew.rs/counter)

A simple example of a counter which can be increased or decreased with the press of a button.

## Running

Run a debug version of this application:

```bash
trunk serve
```

Run a release version of this application:

```bash
trunk serve --release
```

## Concepts

Demonstrates the use of messages to update state.

repository: kuy/yew

gha_language: Rust

repo_name: kuy/yew


text:
---
layout: default
---

# 1994-02-08 - Campaign Against Clipper

## Header Data

From: Dave Banisar<EMAIL_ADDRESS>To: Cypherpunks List<EMAIL_ADDRESS>Message Hash: 5b233d625b23af05a935547601eb9a8d48a830e09f2ee51acb216c3cd0214cce

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1994-02-08 04:00:42 UTC

Raw Date: Mon, 7 Feb 94 20:00:42 PST

## Raw message

```
{% raw  %}From: Dave Banisar<EMAIL_ADDRESS>Date: Mon, 7 Feb 94 20:00:42 PST
To: Cypherpunks List<EMAIL_ADDRESS>Subject: Campaign Against Clipper
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

  Campaign Against Clipper

CPSR ANNOUNCES CAMPAIGN TO OPPOSE CLIPPER PROPOSAL

Embargoed until 2 pm, Monday, February 7, 1994

contact<EMAIL_ADDRESS>(202 544 9240)

Washington, DC -- Following the White House decision on Friday to
endorse a secret surveillance standard for the information highway,
Computer Professionals for Social Responsibility (CPSR) today announced
a national campaign to oppose the government plan.

The Clipper proposal, developed in secret by the National Security
Agency, is a technical standard that will make it easier for government
agents to wiretap the emerging data highway.

Industry groups, professional associations and civil liberties
organizations have expressed almost unanimous opposition to the plan
since it was first proposed in April 1993.

According to Marc Rotenberg, CPSR Washington director, the
Administration made a major blunder with Clipper.  "The public does not
like Clipper and will not accept it. This proposal is fatally flawed."

CPSR cited several problems with the Clipper plan:

o The technical standard is subject to misuse and compromise. It would
provide government agents with copies of the keys that protect
electronic communications.  "It is a nightmare for computer security,"
said CPSR Policy Analyst Dave Banisar.

o The underlying technology was developed in secret by the NSA, an
intelligence agency responsible for electronic eavesdropping, not
privacy protection. Congressional investigations in the 1970s disclosed
widespread NSA abuses, including the illegal interception of millions of
cables sent by American citizens.

o Computer security experts question the integrity of the technology.
Clipper was developed in secret and its specifications are classified.
CPSR has sued the government seeking public disclosure of the Clipper
scheme.

o NSA overstepped its legal authority in developing the standard.  A
1987 law explicitly limits the intelligence agency's power to set
standards for the nation's communications network.

o There is no evidence to support law enforcement's claims that new
technologies are hampering criminal investigations. CPSR recently forced
the release of FBI documents that show no such problems.

o The Administration ignored the overwhelming opposition of the general
public. When the Commerce Department solicited public comments on the
proposal last fall, hundreds of people opposed the plan while only a few
expressed support.

CPSR today announced four goals for its campaign to oppose the Clipper
initiative:

o First, to educate the public about the implications of the Clipper
proposal.

o Second, to encourage people to express their views on the Clipper
proposal, particularly through the computer network.

Toward that goal, CPSR has already begun an electronic petition on the
Internet computer network urging the President to withdraw the Clipper
proposal. In less than one week, the CPSR campaign has drawn thousands
of electronic mail messages expressing concern about Clipper. To sign
on, email<EMAIL_ADDRESS>with the message "I oppose clipper"
in the body of the text.

o Third, to pursue litigation to force the public disclosure of
documents concerning the Clipper proposal and to test the legality of
the Department of Commerce's decision to endorse the plan.

o Fourth, to examine alternative approaches to Clipper.

Mr. Rotenberg said "We want the public to understand the full
implications of this plan.  Today it is only a few experts and industry
groups that understand the proposal.  But the consequences of Clipper
will touch everyone.  It will affect medical payments, cable television
service, and everything in between.

CPSR is a membership-based public interest organization.  For more
information about CPSR, send email to<EMAIL_ADDRESS>or call 415 322
3778.  For more information about Clipper, check the CPSR Internet
library CPSR.ORG. FTP/WAIS/Gopher and listserv access are available.

{% endraw %}
```

## Thread

+ Return to [February 1994](/archive/1994/02)

+ Return to "[Dave Banisar <banisar@washofc.cpsr.org>](/authors/dave_banisar_banisar_at_washofc_cpsr_org_)"

+ 1994-02-08 (Mon, 7 Feb 94 20:00:42 PST) - Campaign Against Clipper - _Dave Banisar<EMAIL_ADDRESS>


text:
# JBOSS EAP templates
Work in progress to create functional JBOSS EAP templates

# Troubleshooting deployment
- Look at /var/log/cloud-init-output.log

## To do
- DONE: Create a storage account and container in the template (investigate using the VMSS storage account)
- DONE: Register and attach subscription manager pool & repo
- DONE: Install product
- DONE: Enable service
- DONE: start service
- DONE: Add JBOSS mgmt user
- Automate storage account naming based on VMSS name (cluster name)
- Write the Azure Ping config file in the cloud-init script
- Identify additional JBOSS/JGROUP configuration
- DONE: Update Load Balancer rules for default JBOSS default management port 9090
- DONE: Update Load Balancer rules for default JBOSS default server port 8080
- DONE: Switch VMs to use SSH key for auth
- Update Readme with user guide and reference links


text:
---
title: How OAuth works
---

Authentication Providers in **Auth.js** are OAuth definitions that allow your users to sign in with their favorite preexisting logins. You can use any of our many predefined providers, or write your own custom OAuth configuration.

- [Using a built-in OAuth Provider](#built-in-providers) (e.g Github, Twitter, Google, etc...)
- [Using a custom OAuth Provider](#using-a-custom-provider)

:::note
Auth.js is designed to work with any OAuth service, it supports **OAuth 1.0**, **1.0A**, **2.0** and **OpenID Connect** and has built-in support for most popular sign-in services.
:::

Without going into too much detail, the OAuth flow generally has 6 parts:

1. The application requests authorization to access service resources from the user
2. If the user authorized the request, the application receives an authorization grant
3. The application requests an access token from the authorization server (API) by presenting authentication of its own identity, and the authorization grant
4. If the application identity is authenticated and the authorization grant is valid, the authorization server (API) issues an access token to the application. Authorization is complete.
5. The application requests the resource from the resource server (API) and presents the access token for authentication
6. If the access token is valid, the resource server (API) serves the resource to the application

```mermaid
sequenceDiagram
    participant Browser
    participant App Server
    participant Auth Server (Github)
    Note left of Browser: User clicks on "Sign in"
    Browser->>App Server: GET<br/>"api/auth/signin"
    App Server->>App Server: Computes the available<br/>sign in providers<br/>from the "providers" option
    App Server->>Browser: Redirects to Sign in page
    Note left of Browser: Sign in options<br/>are shown the user<br/>(Github, Twitter, etc...)
    Note left of Browser: User clicks on<br/>"Sign in with Github"
    Browser->>App Server: POST<br/>"api/auth/signin/github"
    App Server->>App Server: Computes sign in<br/>options for Github<br/>(scopes, callback URL, etc...)
    App Server->>Auth Server (Github): GET<br/>"github.com/login/oauth/authorize"
    Note left of Auth Server (Github): Sign in options<br> are supplied as<br/>query params<br/>(clientId, <br/>scope, etc...)
    Auth Server (Github)->>Browser: Shows sign in page<br/>in Github.com<br/>to the user
    Note left of Browser: User inserts their<br/>credentials in Github
    Browser->>Auth Server (Github): Github validates the inserted credentials
    Auth Server (Github)->>Auth Server (Github): Generates one time access code<br/>and calls callback<br>URL defined in<br/>App settings
    Auth Server (Github)->>App Server: GET<br/>"api/auth/github/callback?code=123"
    App Server->>App Server: Grabs code<br/>to exchange it for<br/>access token
    App Server->>Auth Server (Github): POST<br/>"github.com/login/oauth/access_token"<br/>{code: 123}
    Auth Server (Github)->>Auth Server (Github): Verifies code is<br/>valid and generates<br/>access token
    Auth Server (Github)->>App Server: { access_token: 16C7x... }
    App Server->>App Server: Generates session token<br/>and stores session
    App Server->>Browser: You're now logged in!
```

For more details, check out Aaron Parecki's blog post [OAuth2 Simplified](https://aaronparecki.com/oauth-2-simplified/) or Postman's blog post [OAuth 2.0: Implicit Flow is Dead, Try PKCE Instead](https://blog.postman.com/pkce-oauth-how-to/).

license: ISC

repository: nextauthjs/next-auth

gha_license_id: ISC

repo_name: nextauthjs/next-auth


text:
# Wallemiaceae R.T. Moore FAMILY

#### Status
ACCEPTED

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

#### Published in
Rhizoctonia Species (Dordrecht), Taxonomy, Molecular Biology, Ecology, Pathology and Disease Control 20 (1996)

#### Original name
Wallemiaceae R.T. Moore

### Remarks
null

repository: mdoering/backbone

repo_name: mdoering/backbone


text:
---
layout: post
title: From Blogger to Ghost
date: '2013-12-05 04:21:17'
---

## History

I've been using Blogger for quite some time, but over the last several years I've wanted to switch to something that would enable me to use markdown to compose my posts. I had considered switching to [Octopress](http://octopress.org/), but when I first saw the [Ghost Blogging Platform](https://ghost.org/) on [Kickstarter](http://www.kickstarter.com/projects/johnonolan/ghost-just-a-blogging-platform) I knew that is where I wanted to migrate. And of course, since I enjoy JavaScript so much, I like that Ghost is written in Node.js.

## Installation

So, how did I make the transition from Blogger to Ghost? Well, it wasn't too bad. Thankfully Windows Azure has Ghost listed in its web site gallery `New->Compute->Web Site->From Gallary`, which made it really easy to get started.

![](/assets/images/2013/Dec/azure_ghost_PNG.png)

For most of this phase I followed the excellent instructions from Jeremiah Billmann's ([@jbillmann](http://twitter.com/jbillmann)) post entitled [Installing Ghost from the Azure Web Site Gallery](http://www.jbillmann.com/installing-ghost-from-the-azure-web-site-gallery/).

> Note: You may also be interested in setting up Ghost from the command line. If so, Scott Hanselman ([@shanselman](http://twitter.com/shanselman)) covered this in a great post entitled [How to install the nodejs Ghost blogging software on Azure Websites](http://www.hanselman.com/blog/HowToInstallTheNodejsGhostBloggingSoftwareOnAzureWebsites.aspx)

## Migration

The next step was to somehow migrate my posts from Blogger over to Ghost. Unfortuantley, there isn't a straightforward way to do this yet. The next version of Ghost is supposed to have more migration tools and plugins, but for now there is a import from WordPress feature.

So, what I did was create a temporary WordPress blog from the Azure Web Site Gallery and import all of my Blogger posts into it. Then I installed the [Ghost WordPress Plugin](http://wordpress.org/plugins/ghost/), which exports WordPress posts to a JSON format that Ghost can import.

![](/assets/images/2013/Dec/import_blogger_PNG.png)

At that point you can navigate to your Ghost blog... http://yourdomain/ghost/debug/ and  you'll be presented with a simple GUI to import the JSON file you exported from WordPress.

![](/assets/images/2013/Dec/import_tool_PNG.png)

## Visual Studio Online

In order to make modifications to Ghost once I installed it I decided to go ahead and use the new [Visual Studio Online "Monaco" Code Editor](http://www.visualstudio.com/en-us/news/2013-nov-13-vso.aspx) that was recently released.

![](/assets/images/2013/Dec/visual_studio_online_PNG.png)

I've been pleased with my experience thus far and I look forward to see this online tool mature.

You can learn more about this tool from [@jongalloway's](http://twitter.com/jongalloway) recent blog post entitled [A look at the new Visual Studio Online "Monaco" code editor](http://weblogs.asp.net/jgalloway/archive/2013/11/13/a-quick-look-at-the-new-visual-studio-online-quot-monaco-quot-code-editor.aspx#.UoUgE61r09k.google_plusone_share)

## URL Rewrite

The current version of Ghost doesn't have any mechanism for URL Rewritting, so I dug into the `server.js` file and added some custom routes to map my old Blogger URL structure to the new structure. Unfortunately, the slugs on Blogger and Ghost ended up being different so it made the process more manual than I had wanted, but ohh well.

<script src="https://gist.github.com/elijahmanor/7800069.js"></script>

## Disqus

Installing the [Disqus](http://disqus.com/) commenting widget on Ghost wasn't difficult. All had to do is to edit the `content/themes/casper/post.hbs` template and pasted in the following snippet right before the ending `</article>` element.

<script src="https://gist.github.com/elijahmanor/7803796.js"></script>

Trying to match up my Disqus comments from Blogger to Ghost took a bit of work as well since the identifier was the post URL and as I mentioned above that has changed.

Thankully Disqus has some [migration tools](http://help.disqus.com/customer/portal/articles/286778-migration-tools) built to assist with this issue. I used the [URL Mapper](http://help.disqus.com/customer/portal/articles/912757-url-mapper) tool which let me redifine the URLs associated with particular comment threads.

![](/assets/images/2013/Dec/disqus_csv_PNG.png)

You can provide a CSV file mapping the old URL to the new URL and it will change the mappings for you. The following is an example of what one of the lines from the CSV looks like.

<script src="https://gist.github.com/elijahmanor/7804096.js"></script>

## Conclusion

The migration was an interesting exercise and I already enjoy blogging on this platform much better already. Ghost has a lot of growth ahead of it and I look forward to upgrading as new releases are published.

gha_language: JavaScript


text:
# Weighted choice allocation command line tool

## Getting Started

This tool requires [Ruby](https://www.ruby-lang.org/en/).

# Usage

Usage: ruby allocation.rb \[-h\]\[-v\] path/to/file

Format of choices in a .csv file:

```tex
Name,Topic 1,Topic 2
Person 1,w1,w2
Person 2,w3,w4
```

(w1..w4 are weights as real numbers)

Whether the weights are natural numbers, between 0 and 0 or including negative numbers is up to you. The tool works with all.

You can translate preferences into weights by setting all weights of non-preferences to 0 and awarding points e.g. according to:

- a linear scale (first=3, second=2, third=1)
- an exponential scale with base 2 (one choice is double the weight of the next one, first=4, second=2, third=1)
- an exponential scale with base 3 (one choice is triple the weight of the next one, first=9, second=3, third=1)
- …

## Author

- Samuel Hönle<EMAIL_ADDRESS>

repository: samuelhoenle/allocation-cli

repo_name: samuelhoenle/allocation-cli


text:
## ROLE: ca-server
This role generate initial CA certs and push them to vault. Also, it creates the helm release value file for Certificate Authority (CA)

### Tasks
(Variables with * are fetched from the playbook which is calling this role)
#### 1. Check if ca certs already created
This tasks checks if the CA certificates are already created or not.
##### Input Variables

    *VAULT_ADDR: Contains Vault URL, Fetched using 'vault.' from network.yaml
    *VAULT_TOKEN: Contains Vault Token, Fetched using 'vault.' from network.yaml
##### Output Variables

    vault_ca_result: This variable stores the output of ca certificates check query.

#### 2. Ensures crypto dir exists
This task creates the folder to store crypto material

##### Input Variables
    path: The path where to check/create is specified here.
    recurse: Yes/No to recursively check inside the path specified.

#### 2.a Get ca certs and key
This tasks gets the existing CA certs and key from the Vault server.

#### Input Variables

    *VAULT_ADDR: Contains Vault URL, Fetched using 'vault.' from network.yaml
    *VAULT_TOKEN: Contains Vault Token, Fetched using 'vault.' from network.yaml

**when**: It runs when *vault_ca_result*.failed == False, i.e. CA certs are already present.

#### 3. Generate the CA certificate
This task generates initial CA certificates.
##### Input Variables
    *component_name: The name of resource
    *component_type: The type of resource

**shell**: It goes to the specified directory and generates certificates using open ssl commands.
**when**: It runs when *vault_ca_result*.failed == True, i.e. CA certs are not present.

#### 4. Copy the crypto material to Vault
This task copy the CA certificates generated above, to the Vault.
##### Input Variables
    *VAULT_ADDR: Contains Vault URL, Fetched using 'vault.' from network.yaml
    *VAULT_TOKEN: Contains Vault Token, Fetched using 'vault.' from network.yaml
    *component_name: The name of resource
    *component_type: The type of resource
**shell**: It writes the generated certificates to the vault.
**when**:  It runs when *vault_ca_result*.failed == True, i.e. CA certs are not present.

#### 5. Check if ca admin credentials are already created
This tasks checks if the CA admin credentials are already created or not.
##### Input Variables
    *VAULT_ADDR: Contains Vault URL, Fetched using 'vault.' from network.yaml
    *VAULT_TOKEN: Contains Vault Token, Fetched using 'vault.' from network.yaml
    *component_name: The name of resource
##### Output Variables
    vault_caadmin_result: This variable stores the output of ca admin credentials check query.

#### 6. Write the ca server admin credentials to Vault
This task writes the ca server admin credentials to Vault
##### Input Variables
    *VAULT_ADDR: Contains Vault URL, Fetched using 'vault.' from network.yaml
    *VAULT_TOKEN: Contains Vault Token, Fetched using 'vault.' from network.yaml
    *component_name: The name of resource
    *component: The type of resource
**shell**: It writes the generated credentials to the vault.
**when**:  It runs when *vault_caadmin_result*.failed == True, i.e. CA admin credentials are not present.

#### 7. Check Ambassador cred exists
This tasks check if the Check Ambassador credentials exists or not.
##### Input Variables

    kind: This defines the kind of Kubernetes resource
    namespace: The namespace of the component
    *name: Name of the component
    *kubeconfig: The config file of the cluster
    *context: This refer to the required kubernetes cluster context
##### Output Variables

    get_secret: This variable stores the output of Ambassador credentials check query.

#### 8. Create the Ambassador credentials
This task creates the Ambassador TLS credentials.
##### Input Variables
    *component_name: The name of resource
    *component_type: The type of resource
    *kubernetes.config_file: The config file of kubernetes cluster.

**shell**: The specified command creates ambassador credentials.
**when**: It runs when *get_secret.resources* are not found.

#### 9. Create CA server values for Orderer
This task creates the CA value file for Orderer
##### Input Variables
    *name: The name of resource
    type: "ca-orderer"
    *git_url: "The URL of git repo"
    *git_branch: "Git repo branch name"
    *charts_dir: "The path of chart files"

**include_role** : It includes the name of intermediatory role which is required for creating the CA value file for orderer.
**when**: Condition is specified here, runs only when *component_type* is orderer.

#### 10. Create CA server values for Organisations
This task creates the CA value file for organisations
##### Input Variables
    *name: The name of resource
    type: "ca-peer"
    *git_url: "The URL of git repo"
    *git_branch: "Git repo branch name"
    *charts_dir: "The path of chart files"

**include_role** : It includes the name of intermediatory role which is required for creating the CA value file for orderer.
**when**: Condition is specified here, runs only when *component_type* is peer.

#### 11. Git Push
This task pushes the above generated value files to git repo.
##### Input Variables
    GIT_DIR: "The path of directory which needs to be pushed"
    GIT_RESET_PATH: "This variable contains the path which wont be synced with the git repo"
    gitops: *item.gitops* from network.yaml
    msg: "Message for git commit"


text:
Everybody needs a cleaning schedule. At work, at home, you name it. But don't try to print it out on a piece of paper. Do it using Campfire, checking who's online and giving all chores a certain amound of points. And the people who has the least amound of points, will be doing the task.

So you know, you can create your own schedule (and it doesn't need to be cleaning chores persee). But it does require somethings, like [Hubot](http://hubot.github.com/).

![Screenshot](http://cl.ly/image/2J1R0a0P1002/content)

## Try it out

First add the roomnumber it should set as 'main' room (uses these users and will message the person that needs to do something from the schedule). Then create your own schedule, by creating an array with items, that require a todo (method) and certain amount of points.

    schedule[5]['17:30'] =
      todo: (user) ->
        "Hey #{user}, get me a beer!"
      points: 1

## Want more?
Please contact me on [Twitter](http://twitter.com/davidvanleeuwen) or check out my website [David van Leeuwen](http://davidvanleeuwen.nl).

repository: davidvanleeuwen/hubot-clean

repo_name: davidvanleeuwen/hubot-clean


text:
# Terraform::AWS::CurReportDefinition

Manages Cost and Usage Report Definitions.

~> *NOTE:* The AWS Cost and Usage Report service is only available in `us-east-1` currently.

~> *NOTE:* If AWS Organizations is enabled, only the master account can use this resource.

## Properties

`ReportName` - (Required) Unique name for the report. Must start with a number/letter and is case sensitive. Limited to 256 characters.

`TimeUnit` - (Required) The frequency on which report data are measured and displayed.  Valid values are: HOURLY, DAILY.

`Format` - (Required) Format for report. Valid values are: textORcsv.

`Compression` - (Required) Compression format for report. Valid values are: GZIP, ZIP.

`AdditionalSchemaElements` - (Required) A list of schema elements. Valid values are: RESOURCES.

`S3Bucket` - (Required) Name of the existing S3 bucket to hold generated reports.

`S3Prefix` - (Optional) Report path prefix. Limited to 256 characters.

`S3Region` - (Required) Region of the existing S3 bucket to hold generated reports.

`AdditionalArtifacts` - (Required)  A list of additional artifacts. Valid values are: REDSHIFT, QUICKSIGHT.

## See Also

* [aws_cur_report_definition](https://www.terraform.io/docs/providers/aws/r/cur_report_definition.html) in the _Terraform Provider Documentation_


text:
# Diatrypella verruciformis var. verruciformis (Ehrh.) Nitschke, 1867 VARIETY

#### Status
SYNONYM

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

#### Published in
Pyrenomycetes Germanici 1: 76 (1867)

#### Original name
Sphaeria verruciformis Ehrh., 1785

### Remarks
null

path: /life/Fungi/Ascomycota/Sordariomycetes/Xylariales/Diatrypaceae/Diatrypella/Diatrypella favacea/ Syn. Diatrypella verruciformis verruciformis/README.md


text:
---
layout: post
title: Mixed Models revisited
---

- New Docs/Workshops: [Mixed Models with R](../mixed-models-with-R/) has been updated with content for the current version of the workshop.  In addition, I've updated a document [comparing mixed models and latent growth curve models](../mixed-growth-comparison/), showing their equivalence under a variety of model settings.


text:
# dwm

#### Table of Contents

1. [Overview](#overview)
2. [Module Description - What the module does and why it is useful](#module-description)
3. [Setup - The basics of getting started with dwm](#setup)
    * [What dwm affects](#what-dwm-affects)
    * [Beginning with dwm](#beginning-with-dwm)
4. [Usage - Configuration options and additional functionality](#usage)
5. [Reference - An under-the-hood peek at what the module is doing and how](#reference)
5. [Limitations - OS compatibility, etc.](#limitations)

## Overview

Module to install the dwm window manager.

## Module Description

This module compiles and installs the dwm window manageer
on a target node.

## Setup

### What dwm affects

* `dwm` executable at defined location.

### Beginning with dwm

```puppet
include dwm
```

## Usage

### I just want `dwm` installed

```puppet
include dwm
```

### I want to specify the version and location of `dwm`

```puppet
class { 'dwm':
  version => '5.8.2',
  prefix => '/opt/mysoftware',
}
```

## Reference

### Classes

* `dwm`: Installs the dwm binary

## Limitations

This module is known to work with the following operating system families:

 - Debian 8.2.0 or newer

The ability to customize the `config.h` file is not supported. This
is left up to the user to update the `config.h` file and recompile
`dwm` as desired.

repository: johnduarte/puppet-dwm

repo_name: johnduarte/puppet-dwm


text:
## Creating a new Camel K Integration task configuration with multiple parameters

Though the simple "Deploy Integration with Apache Camel K" menu works well for simple cases, you can use a Task for more complex integrations. When the Camel K integration requires more configuration, you can set that up using a Task.

To create a new Task, you have a few options.

1. From the command palette, call the `Tasks: Configure Task` command. This will open the tasks.json file where you can enter new task info by hand (with some auto-completion support in the editor). If you already have a tasks.json but no Camel K tasks, you can create a new task with the type `camel-k` in the tasks.json which is automatically opened.
2. If you don't have any Tasks configured yet, you can use the `camel-k: Start in dev mode Camel K integration opened in active editor` command, which will template an initial Camel K task for you.

You will end up with something like the following with a new, empty Camel K task specified:

```json
{
    // See https://go.microsoft.com/fwlink/?LinkId=733558
    // for the documentation about the tasks.json format
    "version": "2.0.0",
    "tasks": [
        {
            "type": "camel-k",
            "dev": true,
            "file": "${file}",
            "problemMatcher": []
        }
    ]
}
```

Note: We recommend adding a `label` attribute to more easily find your task in the task list when you try to run it.

Once you've created your Camel K task, you can use auto-complete to explore the various parameters available. The following example launches the integration in `--dev` mode and provides a couple of dependencies:

```json
{
    "type": "camel-k",
    "label": "Run RestWithUndertow and Dependencies",
    "dev": true,
    "file": "./examples/RestWithUndertow.java",
    "problemMatcher": [],
    "dependencies": [ "camel-rest", "camel-undertow" ]
}
```

When you've defined your Task, you can use one of two options to execute it:

- call command from palette `Tasks: Run Task`. You will see the command listed with the label that you provided previously.
- with the `Deploy Integration with Apache Camel K` command, pick the option `Use a predefined Task - useful for multi-attributes deployment`

After running the camel-k `Task`, a terminal will open where you can see the command used and any execution result.

repository: camel-tooling/vscode-camelk

repo_name: camel-tooling/vscode-camelk


text:
# swagger_client.TransactionApi

All URIs are relative to *https://localhost/ahoi/api/v2*

Method | HTTP request | Description
------------- | ------------- | -------------
[**get_transaction**](TransactionApi.md#get_transaction) | **GET** /accesses/{accessId}/accounts/{accountId}/transactions/{transactionId} | Get transaction
[**list_transactions**](TransactionApi.md#list_transactions) | **GET** /accesses/{accessId}/accounts/{accountId}/transactions | List transactions for account
[**list_transactions_for_pattern**](TransactionApi.md#list_transactions_for_pattern) | **GET** /accesses/{accessId}/accounts/{accountId}/transactionpatterns/{patternId}/transactions | List transactions for pattern

# **get_transaction**
> Transaction get_transaction(access_id, account_id, transaction_id)

Get transaction

Returns the transaction identified by **transactionId** in relationship with **accountId**.

### Example
```python
from __future__ import print_function
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: oauth2
configuration = swagger_client.Configuration()
configuration.access_token = 'YOUR_ACCESS_TOKEN'

# create an instance of the API class
api_instance = swagger_client.TransactionApi(swagger_client.ApiClient(configuration))
access_id = 789 # int | The **accessId** for the transaction to retrieve
account_id = 789 # int | The **accountId** for the transaction to retrieve
transaction_id = 789 # int | The **transactionId** for the pattern to retrieve

try:
    # Get transaction
    api_response = api_instance.get_transaction(access_id, account_id, transaction_id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TransactionApi->get_transaction: %s\n" % e)
```

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **access_id** | **int**| The **accessId** for the transaction to retrieve |
 **account_id** | **int**| The **accountId** for the transaction to retrieve |
 **transaction_id** | **int**| The **transactionId** for the pattern to retrieve |

### Return type

[**Transaction**](Transaction.md)

### Authorization

[oauth2](../README.md#oauth2)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json

[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)

# **list_transactions**
> list[Transaction] list_transactions(access_id, account_id, max_age=max_age, limit=limit, offset=offset, _from=_from, to=to)

List transactions for account

Retrieve all transactions for **accountId**.

### Example
```python
from __future__ import print_function
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: oauth2
configuration = swagger_client.Configuration()
configuration.access_token = 'YOUR_ACCESS_TOKEN'

# create an instance of the API class
api_instance = swagger_client.TransactionApi(swagger_client.ApiClient(configuration))
access_id = 789 # int | The **accessId** for which to retrieve transactions.
account_id = 789 # int | The **accountId** for which to retrieve transactions.
max_age = 789 # int | Optional — indicates the maximum acceptable timeframe (in seconds) since the last refresh of the given account. (optional)
limit = 56 # int | Optional — limit the number of returned transactions (optional)
offset = 56 # int | Optional — skip the first **offset** transactions in result (optional)
_from = '_from_example' # str | Optional — only return transactions with booking date later than **from**; an ISO8601 Month(2014-11), Date (2014-11-17) or DateTime         (2014-11-17T12:00:00Z) (optional)
to = 'to_example' # str | Optional — only return transactions with booking date prior or equal to **to**; an ISO8601 Date, Month or DateTime (optional)

try:
    # List transactions for account
    api_response = api_instance.list_transactions(access_id, account_id, max_age=max_age, limit=limit, offset=offset, _from=_from, to=to)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TransactionApi->list_transactions: %s\n" % e)
```

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **access_id** | **int**| The **accessId** for which to retrieve transactions. |
 **account_id** | **int**| The **accountId** for which to retrieve transactions. |
 **max_age** | **int**| Optional — indicates the maximum acceptable timeframe (in seconds) since the last refresh of the given account. | [optional]
 **limit** | **int**| Optional — limit the number of returned transactions | [optional]
 **offset** | **int**| Optional — skip the first **offset** transactions in result | [optional]
 **_from** | **str**| Optional — only return transactions with booking date later than **from**; an ISO8601 Month(2014-11), Date (2014-11-17) or DateTime         (2014-11-17T12:00:00Z) | [optional]
 **to** | **str**| Optional — only return transactions with booking date prior or equal to **to**; an ISO8601 Date, Month or DateTime | [optional]

### Return type

[**list[Transaction]**](Transaction.md)

### Authorization

[oauth2](../README.md#oauth2)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json

[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)

# **list_transactions_for_pattern**
> list[Transaction] list_transactions_for_pattern(access_id, account_id, pattern_id, max_age=max_age, limit=limit, offset=offset, _from=_from, to=to)

List transactions for pattern

Retrieve all transactions for **patternId**.

### Example
```python
from __future__ import print_function
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: oauth2
configuration = swagger_client.Configuration()
configuration.access_token = 'YOUR_ACCESS_TOKEN'

# create an instance of the API class
api_instance = swagger_client.TransactionApi(swagger_client.ApiClient(configuration))
access_id = 789 # int | The **accessId** for which to retrieve transactions
account_id = 789 # int | The **accountId** for which to retrieve transactions
pattern_id = 789 # int | The **patternId** for which to retrieve transactions
max_age = 789 # int | Optional — indicates the maximum acceptable timeframe (in seconds) since the last refresh of the given account (optional)
limit = 56 # int | Optional — limit the number of returned transactions (optional)
offset = 56 # int | Optional — skip the first **offset** transactions in result (optional)
_from = '_from_example' # str | Optional — only return transactions with a booking date later than **from**; an ISO8601 Month(2014-11), Date (2014-11-17) or DateTime         (2014-11-17T12:00:00Z) (optional)
to = 'to_example' # str | Optional — only return transactions with a booking date prior or equal to **to**; an ISO8601 Date, Month or DateTime (optional)

try:
    # List transactions for pattern
    api_response = api_instance.list_transactions_for_pattern(access_id, account_id, pattern_id, max_age=max_age, limit=limit, offset=offset, _from=_from, to=to)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TransactionApi->list_transactions_for_pattern: %s\n" % e)
```

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **access_id** | **int**| The **accessId** for which to retrieve transactions |
 **account_id** | **int**| The **accountId** for which to retrieve transactions |
 **pattern_id** | **int**| The **patternId** for which to retrieve transactions |
 **max_age** | **int**| Optional — indicates the maximum acceptable timeframe (in seconds) since the last refresh of the given account | [optional]
 **limit** | **int**| Optional — limit the number of returned transactions | [optional]
 **offset** | **int**| Optional — skip the first **offset** transactions in result | [optional]
 **_from** | **str**| Optional — only return transactions with a booking date later than **from**; an ISO8601 Month(2014-11), Date (2014-11-17) or DateTime         (2014-11-17T12:00:00Z) | [optional]
 **to** | **str**| Optional — only return transactions with a booking date prior or equal to **to**; an ISO8601 Date, Month or DateTime | [optional]

### Return type

[**list[Transaction]**](Transaction.md)

### Authorization

[oauth2](../README.md#oauth2)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json

[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)

repository: chbndrhnns/ahoi-client

repo_name: chbndrhnns/ahoi-client


text:
# Quick Score

A web based scoring tool for quickly scoring things based on lists.

## Hosting

The latest version of the tool can be found at:

-   <https://connected-web.github.io/quick-score/>

## Intent

The tool should:

-   be web based
-   be mobile friendly
-   be toggle friendly
-   be touch friendly
-   give realtime feedback
-   display lists of items

## Use cases

The tool should work for a variety of use cases, such as recruitment:

```
Reviewing CVs for evidence of particular skills or experience.
```

Board game accessibility:
```
Assessment of a board game for accessibility based on components.
```

Film reviews:
```
Review a film based on common characteristics.
```

## Milestones

| Icon               | Stage                               |
| ------------------ | ----------------------------------- |
| :heavy_check_mark: | Hosted on an web accessible URL     |
| :heavy_check_mark: | Toggleable score item               |
| :heavy_check_mark: | Realtime score update               |
| :heavy_check_mark: | Multiple score items                |
| :heavy_check_mark: | Multiple score items in categories  |
| :heavy_check_mark: | Categorised scoring                 |
| :heavy_check_mark: | Preconfigured skills survey         |
| :boom:             | Preconfigured board game survey     |
| :boom:             | Preconfigured film survey           |
| :heavy_check_mark: | Support for configurable weightings |

repository: connected-web/quick-score

repo_name: connected-web/quick-score


text:
Dart style guide
================

The Fuchsia project follows the guidelines in [Effective Dart][effective-dart],
but with some additions.

All code must be formatted using `dartfmt` before being checked in.

# Additional Style Rules

### DON'T follow the Flutter repository style guide.

The Flutter project's style guide is meant to be used for code in the Flutter
framework itself. It is not intended as style guidance for projects using
Flutter. All code in the Fuchsia repository should follow the standard
Dart style. Although we are not following the style, the Flutter's guide on
documentation and development is still useful.

### DO use trailing commas on all tree structures longer than one line.

Without trailing commas, code that builds widget trees or similar types of
code tends to be hard to read. Adding the trailing commas allows `dartfmt`
to do its job correctly.

#### Without trailing commas:
``` dart
children.add(Expanded(
  child: Center(
      child: Container(
          width: 64.0, height: 64.0, child: FuchsiaSpinner())),
));
```

#### With trailing commas:
``` dart
children.add(Expanded(
  child: Center(
      child: Container(
        width: 64.0,
        height: 64.0,
        child: FuchsiaSpinner(),
      ),
   ),
));
```

### DO order members using the Dart Analyzer.
In Visual Studio Code, this is the Dart: Organize Members command available
in the Command Palette. (Control+Shift+P or View -> Command Palette)

This formatter doesn’t appear to be available outside of the supported IDEs.

### PREFER to keep lines below 80 characters unless it would be more readable.
This is a slight amendment from the general Dart [rule][dartstyle-80-chars].
Unlike that rule, it is fine to have lines above 80 characters in the Fuchsia
repository, as long as it improves readability, and dartfmt won't automatically
truncate the line.

# Additional Usage Rules

## Repositories and Files

### DO follow the [Fuchsia layer repository structure][Fuchsia-directory-style].

### DO prefix library names in `/lib` and `/public/lib` with `lib.`
#### Example:
```
Dart_library("lib.settings") {
  package_name = "lib.settings"
  ...
}
```

### PREFER minimizing the number of public members exposed in a package.
This can be done by only making things public when needed, and keeping all
implementation detail libraries in the `/src` directory. Assume anything
public in the `lib` directory will be re-used.

### CONSIDER exporting publicly visible classes in a single `.dart` file.

For multiple classes that are used together but are in different files,
it’s more convenient for users of your library to import a single file rather
many at once. If the user wants narrower imports they can always restrict
visibility using the `show` keyword.

This also helps minimize the publicly visible surface.

Example:
``` dart
/// In src/apple.dart
class Apple {}

/// In src/orange.dart
class Orange {}

/// In src/veggies.dart
class Potato {}
class Tomato {}

/// In botanical_fruits.dart
export 'src/apple.dart';
export 'src/orange.dart';
// Can also be: export 'src/veggies.dart' hide Potato;
export 'src/veggies.dart' show Tomato;

/// In squeezer.dart
import 'package:plants/botanical_fruits.dart' show Orange;

```

### DO import all files within a package using relative paths.

Mixing and matching relative and absolute paths within a single package
causes Dart to act as if there were two separate imports of identical files,
which will introduce errors in typechecking. Either format works as long as
it is consistent. Within the Fuchsia repository, relative paths are used.

This does not apply to external libraries, as only the absolute path can be
used.

#### Good:
``` dart
import 'access_point.dart';
```

#### Bad:
``` dart
import 'package:wifi/access_point.dart';
```

### DO use namespacing when you import FIDL packages.

This adds clarity and readability. FIDL namespaces (library statements) are not
respected in Dart (e.g. `fuchsia.io.Node` becomes `Node`).
Because of tight namespaces, people tend to use more generic names in FIDL
(Error, File, Node, etc.), which result in more collisions/ambiguity in Dart.

#### Good:

``` dart
import 'package:fidl_fuchsia_file/fidl.dart' as file_fidl;
...

file_fidl.File.get(...) ...
```

#### Bad:

``` dart
import 'package:fidl_fuchsia_file/fidl.dart';
...

File.get(...) ...
```

### DO use namespacing when there is ambiguity, e.g. in class names.

There are often functions or classes that can collide, e.g. `File` or `Image`.
If you don't namespace, there will be a compile error.

#### Good:

``` dart
import 'dart:ui' as ui;

import 'package:flutter/material.dart';
...

ui.Image(...) ...
```

#### Bad:

``` dart
import 'dart:ui';

import 'package:flutter/material.dart';
...

Image(...) ... // Which Image is this?
```

### PREFER to use `show` if you only have a few imports from that package. Otherwise, use `as`.

Using `show` can avoid collisions without requiring you to prepend
namespaces to types, leading to cleaner code.

#### Good:

``` dart
import 'package:fancy_style_guide/style.dart' as style;
import 'package:flutter/material.dart';
import 'package:math/simple_functions.dart' show Addition, Subtraction;
```

#### Bad:

``` dart
import 'package:flutter/material.dart show Container, Row, Column, Padding,
  Expanded, ...;
```

## Coding practicies

### DON'T use `new` or use `const` redundantly.

Dart 2 makes the `new` optional for constructors, with an aim at removing them
in time. The `const` keyword is also optional where it can be inferred by the
compiler.

`const` can be inferred in:
* A const collection literal.
* A const constructor call.
* A metadata annotation.
* The initializer for a const variable declaration.
* A switch case expression—the part right after case before the :, not
  the body of the case.

This guidance will eventually be part of Effective Dart due to the changes for
Dart 2.

#### Good:
``` dart
final foo = Foo();
const foo = Foo();
const foo = const <Widget>[A(), B()];
const Foo(): bar = Bar();
```

#### Bad:
``` dart
final foo = new Foo();
const foo = const Foo();
foo = const [const A(), const B()];
const Foo(): bar = const Bar();

```

### DON'T do useful work in assert statements.

Code inside assert statements are not executed in production code. Asserts
should only check conditions and be side-effect free.

### PREFER to use `const` over `final` over `var`.

This minimizes the mutability for each member or local variable.

### PREFER return `Widget` instead of a specific type of Flutter widget.

As your project evolves, you may change the widget type that is returned in your
function. For example, you might wrap your widget with a Center. Returning
`Widget` simplifies the refactoring, as the method signature wouldn't have to
change.

#### Good:

``` dart
Widget returnContainerWidget() {
  return Container();
}
```

#### Bad:

``` dart
Container returnContainerWidget() {
  return Container();
}
```

# Additional Design Rules

### PREFER storing state in Models instead of state.

When storing state that Flutter widgets need to access, prefer to use
`ScopedModel` and `ScopedModelDescendant` instead of `StatefulWidget`.
A `StatefulWidget` should contain only internal widget state that can be lost
without any consequences.

Examples of stuff to store in a `ScopedModel`:
* User selections
* App state
* Anything that needs to be shared by widgets

Examples of stuff to store in a `StatefulWidget`'s `State`:
* Animation state that doesn't need to be controlled

### AVOID mixing named and positional parameters.

Instead, `@required` should be used in place of required positional parameters.

### PREFER named parameters.

In most situations, named parameters are less error prone and easier to read
than positional parameters, optional or not. They give users to pass in the
parameters in whatever order they please, and make Flutter trees especially
clearer.

In the Fuchsia repository, positional parameters should be reserved for simple
operational functions with only a few parameters.

#### Good:
``` dart
int add(int a, int b);
int addNumbers(int a, [int b, int c, int d]);
Foo fromJson(String json);
void load(String file);

Widget buildButton({
  @required Widget child,
  VoidCallback onTap,
  double width,
  bool isDisabled = false,
});
```

#### Bad:
``` dart
int add({int a, int b});
Foo fromJson({@required String json});

Widget buildButton(
  Widget child,
  VoidCallback onTap, [
  double width,
  bool isDisabled = false,
]);
```

### DO add [logging statements][dart-logging]

[effective-dart]: https://www.dartlang.org/guides/language/effective-dart
[fuchsia-directory-style]: /development/source_code/layer_repository_structure.md#
[dart-logging]: /development/languages/dart/logging.md
[dartstyle-80-chars]: https://www.dartlang.org/guides/language/effective-dart/style#avoid-lines-longer-than-80-characters