text:
# Trello to Newsletter

MuMaLab people write a newsletter once a week. That was done in a pad so far, and then sent out manually. Not very convinient. Let's automate.

## Setup
* Clone repo
```
git clone git@github.com:munichmakerlab/trello-newsletter.git
cd trello-newsletter
```

* Install py-trello
```
virtualenv env
. env/bin/activate
pip install py-trello
```

* Get Trello API key and secret from https://trello.com/app-key
* Do that OAuth dance
```
export TRELLO_API_KEY=<API_KEY>
export TRELLO_API_SECRET=<API_SECRET>
export TRELLO_EXPIRATION=never
```

* Copy `config.py.sample` and edit it
```
cp config.py.sample config.py
vi config.py
```

* Run the whole thing
```
python newsletter.py
```

repository: munichmakerlab/trello-newsletter

repo_name: munichmakerlab/trello-newsletter


text:
# Most Valuable Professor
[CLICK HERE TO VISIT SITE](https://uiuc1867mvp.web.illinois.edu/)

This was a semester long project for CS 411: Database Systems

This website is similar to rate my professor in the way that it displays useful information for students looking for courses

It differs in the way that it is backed strongly by [data](https://github.com/wadefagen/datasets/tree/master/gpa) produced by the university

# Details
Details about this project, including design, features, dataflow, and more, are located in the project report pdf in this repository

## Requirements
```
python >= 3.5
```

## Getting started
```bash
git clone https://github.com/tpjwm/Most-Valuable-Professor.git
cd Most-Valuable-Professor
python -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
export FLASK_APP = app
flask run
```

## Setting up GCP
Create a `app.yaml` file in the root folder with the following content:
```yaml
runtime: python38 # or another supported version

instance_class: F1

env_variables:
  MYSQL_USER: <user_name> # please put in your credentials
  MYSQL_PASSWORD: <user_pw> # please put in your credentials
  MYSQL_DB: <database_name> # please put in your credentials
  MYSQL_HOST: <database_ip> # please put in your credentials

handlers:
# Matches requests to /images/... to files in static/images/...
- url: /img
  static_dir: static/img

- url: /script
  static_dir: static/script

- url: /styles
  static_dir: static/styles
```

Setting up the deployment
```bash
curl https://sdk.cloud.google.com | bash
gcloud components install app-engine-python
gcloud config set project #PROJECT-NAME
gcloud auth login
gcloud app deploy
```
# Credits
* [Pratik](https://github.com/pratik139patel/Personal-Projects.git) - Backend, Database implementation
* [Michael](https://github.com/mharty2) - Backend, Database implementation
* [Dimitar](https://github.com/tpjwm) - Backend, Frontend
* [Omar](https://github.com/omarn33) - Frontend, Design

license: MIT

repository: tpjwm/Most-Valuable-Professor

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: tpjwm/Most-Valuable-Professor


text:
# Terraform::AWS::EcrRepository

Provides an EC2 Container Registry Repository.

~> **NOTE on ECR Availability**: The EC2 Container Registry is not yet rolled out
in all regions - available regions are listed
[the AWS Docs](https://docs.aws.amazon.com/general/latest/gr/rande.html#ecr_region).

## Properties

`Name` - (Required) Name of the repository.

`Tags` - (Optional) A mapping of tags to assign to the resource.

## Return Values

### Fn::GetAtt

`Arn` - Full ARN of the repository.

`Name` - The name of the repository.

`RegistryId` - The registry ID where the repository was created.

`RepositoryUrl` - The URL of the repository (in the form `Terraform::AWS::AccountId.dkr.ecr.region.amazonaws.com/repositoryName`.

## See Also

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


text:
# _Rebuilding Together Portland_

#### By _**Molly Donegan**_

#### _A test website for working with HTML and CSS_

## Technologies Used

* _HTML_
* _CSS_

## Description

_A test website for working with HTML and CSS_

## Setup/Installation Requirements

* _Clone this repository to your desktop_
* _Navigate to the top level of the directory_
* _Open index.html in your browser_

## Known Bugs

* _not adapted for responsive design_

## License

* _MIT_

Copyright (c) _2023_ _Molly Donegan_


text:
---
title: Building echoprint/codegen on Mac OS X
date: 2014-09-13 22:23
tag: [Mac OS X]
---

While investigating how services like [Shazam](http://shazam.com) worked, how they identified music using audio samples, I stumbled upon [Echoprint](http://echoprint.me/), an open-source music identification project, and when I did, I immediately jumped to experiment with it.

The Echoprint project has many sub-projects in itself, but the simplest way to use it is to send the audio sample in a specific format to an Echoprint server. The Echoprint project already has a free-to-use (keep in mind that with “free” comes request limitations) online Echoprint server that identifies the music for you, so you only need to create an appropriate code to call the service.

The echoprint-codegen project is used exactly for that purpose: it takes an audio input and produces a code out of it, ready to use in Echoprint service requests. There are no binary distributions for the project, so you need to manually build it after downloading (or cloning) the project on your PC.

First, clone the project from the Github repository.

<!-- more -->

```
git clone https://github.com/echonest/echoprint-codegen.git
```

And then build the project by going into the `src` directory and typing `make`… but it can’t be built, right?

The reason it won’t build is that it has two dependencies that must be installed on your PC: [Boost](http://boost.org), a very popular C++ library which will be built-in with the upcoming C++ release, and [TagLib](https://taglib.github.io), a C++ IDv3 tag library. But don’t worry, it’s extremely easy to install both using [Homebrew].

To install Boost, simply type this on your terminal:

```
brew install boost
```

And done! Boost is now installed under the Homebrew cellar directory (`/usr/local/Cellar/boost`), with a symbolic link linking to it from `/usr/local/include/boost`.

The same thing goes for TagLib as well:

```
brew install taglib
```

There you go, both dependencies are now installed. Only thing left to do now is to slightly modify the echoprint/codegen project’s make file (so that the newly-installed libraries can be detected by gcc) and build the project using make.

Navigate into the `src` directory of the project, and open the file `Makefile` using `vi` (or your favorite text editor), and then change the line where it says

```
BOOST_CFLAGS=-I/usr/local/include/boost-1_35
```

to

```
BOOST_CFLAGS=-I/usr/local/include
```

Save the file, and then run `make` again.

And… That’s it! Yes, it’s that simple. Just go up one directory (to the project’s root folder) and you should see the newly-created executable named `echoprint-codegen`.

gha_language: SCSS

gha_license_id: MIT


text:
# poddotify

Poddotify is a command line tool written in Swift to read a Podfile.lock and generate a Dot source. The Dot source can then be processed by Graphviz, an open source graph rendering library, to generate a visualization of the dependency graph as a jpg, png, pdf or more.

For more information about Graphviz you can visit their official website https://www.graphviz.org

The command line tool will resolve the transitive closure to simplify the dependency graph and reduce the number of edges. It will also mark as a subgraph the dependencies that represents subspecs of a certain podspec or, optionally, reduce them to a single node in order to simplify the graph complexity.

USAGE:
  - -i filename : specify the .lock filename to be used as input
  - -o filename : output filename
  - -noversion : do not include dependency version numbers (-nv)
  - -nosubspecs : reduce subspecs subgraphs to a single node (-ns)
  - -lefttoright : print graph left to right (-lr)
  - -verbose : verbose output (-v)
  - -help : usage information (-h)

By default the input filename is Podfile.lock

# Installation

You can use Homebrew to install the binary directly:

```sh
brew install gabrielepalma/tools/poddotify
```

Alternatively, you can clone this repository, edit the sources and build and run however you see fit.

# Examples

Using Wordpress Podfile.lock:
https://github.com/wordpress-mobile/WordPress-iOS
```sh
poddotify -i WP-Podfile.lock.txt -lr -ns
dot WP-Podfile.lock.dot -Tjpg -O
```

Using Artsy Podfile.lock:
https://github.com/artsy/eidolon
```sh
poddotify -i Artsy-Podfile.lock.txt
dot Artsy-Podfile.lock.dot -Tjpg -O
```

repository: gabrielepalma/poddotify

repo_name: gabrielepalma/poddotify


text:
Docking

[![npm (scoped)](https://img.shields.io/npm/v/@isotope/docking)](https://www.npmjs.com/package/@isotope/docking) [![npm](https://img.shields.io/npm/dm/@isotope/docking)](https://www.npmjs.com/package/@isotope/docking) [![Discord](https://img.shields.io/discord/707157754766426134)](https://discord.gg/FaFbaSk)

**Docking** is a simple and intuitive Static Site Generator (SSG) utilizing the Isotope ecosystem.

## Why Docking?

- **Isotope ecosystem** - Docking is a perfect choice when you're already familiar with tools like Isotope and Prototope. ❤
- **Simplicity** - Docking prefers simplicity. 2 commands, one simple config file, opinionated file structure - everything ready for you to create your first website!

## Installation

```bash
npm install @isotope/docking
```

## Usage

```bash
npx dck build
```

```bash
npx dck watch
```

## Interested?

Get started by checking out the [docs](https://areknawo.com/docking).

## Questions?

Have a question or want to chat about Docking? If so, check out the [Discord community](https://discord.gg/FaFbaSk)!

## Support Docking

Help make Docking better by contributing code or fixes, or donating:

repository: Isotopejs/isotope

repo_name: Isotopejs/isotope


text:
Learn about how to debug neural nets

**CNNs and Downsides of RNNs:**

RNNs cannot capture phrases without prefix context

Often capture too much of last words in final vector.

CNNs are very fast! Much faster than RNNs

**CNNs**

What if we conpute vectors for every possible word subsequence of a certain length? (Every n-gram)

**Convolutions**

A patch or **kernel** of weights which is slid over a sequence (or matrix), producing a dot product for each position. When we run CNNs we often pad the front and back so the ourput is the same length.

![Screenshot 2020-01-24 at 3.58.36 PM.png](resources/2C7838192986F45AF46CC094FD87139C.png)

Because one convolution only captures one value for each filter, we often use multiple filters to get multiple values, which we call *features*. The idea is that each filter specializes in some aspect of the sentence.![Screenshot 2020-01-24 at 4.04.21 PM.png](resources/9AD9F90528206C969393DABB69732F58.png)

**Important Ideas for CNNs (With NLP Focus)**

**Maxpooling**

Summarizes the output of a CNN.

For each of the features computed by the convolution, compute the max over all words of the returned feature values.![Screenshot 2020-01-24 at 4.05.52 PM.png](resources/B7EE1C86CD80D1DE413862FB7C9C8BCF.png)

**Batch Norm**

(Ioffe and Szegedy. 2015.)

Batch norm is almost always used in deep CNNs.

Transform the convolution output of a mini batch (whatever random 32 examples you saw) by scaling the activations to have zero mean and unit variance before pushing it to the next layer of the Conv Block. Ensures that what comes out of the conv block are always at the same scale.

* This allows deep NNs to learn much more reliably, becasue a lot of hyperparameter tuning in deep NN training is being very fussy about hyperparaneters to keep a scale of things about right so they dont get too big or too small. Batch-norm takes away the need to be so fussy about it.

**1x1 Convolutions**

1x1 Convolutions are convolutions with a kernel size of 1\. This gives you a position specific fully connected linear layer across channels!

You can do this because you want to map down from having a lot of channels to having fewer channels, or to get another linearities.

If you put fully connected layers over everything, they involve a lot of parameters, but putting in size 1 convolutions involve very few parameters.

**Avg pooling**

You can also take the average of each computed feature for each value. This corresponds roughly to “on average how much of this feature, ie. the sentence being about food, is present in the sentence?” Sometimes used. Used much less than maxpool.

**Other Notions**

Other notions used in CNNs but less common in NLP applications are in Appendix (2). They include

- Stride(2), Local Max Pool, Stride=2, k-max pooling over time

Convolutional Neural Networks for Sentence Classification (2014, very early paper)
----------------------------------------------------------------------------------

Single Sentence Text Classification (Old)![Screenshot 2020-01-24 at 4.25.12 PM.png](resources/B96CF46DE78A4BB46CA5BF06D9B40D93.png)

Below, *f* is a nonlinearity. In this paper they use a bias term and right-padding only (most people do symmetric padding).

![Screenshot 2020-01-24 at 4.27.03 PM.png](resources/C5C421E27B4767C6EA7A4DF01636C439.png)

At the end, do maxpooling. They have multiple features of different kernel sizes to do the analysis

![Screenshot 2020-01-24 at 4.28.05 PM.png](resources/98D46BFA64E92C522DBE0DF4D27879F0.png)

He used two identical copies of word vectors (GloVE) concatenated together to represent words. One set was frozen while the other was fine-tuned during training. Elemnts from both copies went in together in the max-pool.

To obtain final feature vector $z = [\hat c_1,...,\hat c_m]$ he used $m=300$, with 100 feature maps each of sizes 3, 4, 5.
Finally, the classification was done through a simple softmax layer.
$$y = softmax(W^{(S)}z+b)$$

**Finally, they used dropout**: Create masking vector $r$ of Bernoulli random variables with probability $p$ of being $1$. Delete features during training: $y=softmax(W^{(S)}(r \circ z) + b)$

At test time, no dropout, but becuase before you were dropping out a lot of stuff, scale weight matric by dropout prob $p=0.5$: $\hat W^{(S)} = pW^{(S)}$

Also: Constrain $l_2$ norms of weight vectors of each class to a fixed number s. Not very common. If weights were too large, they were rescaled so that they equal 3. Not very common to do.

![Screenshot 2020-01-24 at 4.34.15 PM.png](resources/FFC2C3228CBBFCA0A63C7C98AD2077CC.png)

Very Deep CNNs for Text Classification (VD-CNN)
-----------------------------------------------

(Conneau, Schwenl, LeCun, EACL2017).
 Starting Point: Build a computer vision-like CNN stack for NLP. This is significant because previous CNNs for NLP has not been very deep.

The authors started from the character level onwards. They truncate or pad documents to 1024 documents.

1. For each character, learn a character embedding of dim 16 (dim is not 16x1024)
2. Stick that through a convolutional layer with a kernel size of 3 and 64 output channel (dim is now 64x2014)
3. For n in 64,128,256,512:
  1. Stick that through a convolutional block of size (3,n) x2
  2. Do local pool to halve the size of the size of the sentence but doubple the size of the channels (features). Ourput is size n x 1024/(n/64). Don't do on last loop.
4. Do k-max pooling, keep 8 strongest values in each channel. (Dim=512 x 8)
5. Put it through 3 fully connected layers (512x8xnum\_classes)

Each Convolutional block is two convolutional layers of kernel 3, each collowed by batch norm and a ReLU nonlinearity. Pad to preserve dimension. Each convolutional block also has a skip connection that goes directly from the start of the block to the end.

![Screenshot 2020-01-24 at 5.25.59 PM.png](resources/76CAF87D1AA32CCE98F3839C158116AB.png)

![Screenshot 2020-01-24 at 5.25.36 PM.png](resources/11756A5592295E72679622222A51BE82.png)

They used huge datasets to test their model
Deeper networks work better up to 29 layers, after that point, it didn't much better with depth.

In vision, people generally use ResNet50 or ReNet101 for good results. They only use ResNet34 for a very lightweigh model. But in language it seems that the model stops improving after depth ~30.

## Quasi-Recurrent Neural Networks (Q-RNN, which are actually CNNs)

RNNs are a standard building blocks for NLP, but they paralleize badly and slowly. Idea: Take the best and paralleizable parts of RNNs and CNNs.

Rather than doing the standard LSTM things which is calculate the update value and gates for your new time slice, we instaed stick a relation between $t-1$ and $t$ states into the max-pooling layer of a CNN.

So we still compute candidate, forget, and ourput gates, but these candidates and gated values are done inside a pooling layer via a convolutional operation. So element-wise gaten pseudo-recurrence ofr parallelism across channels is done in pooling layer: $h_t = f_t \odot h_{t-1} + (1-f_t) \odot z_t$

![Screenshot 2020-01-25 at 12.30.53 PM.png](resources/D76E4A94DE7320D4BC8DFF93C4F7D78E.png)

In the pseudo-recurrence, you are modeling an interaction between words and the words next to it at each time slice, but its just worked out locally rather than being carried forward in one layer. But if you made your networks deeper using Q-RNNs, you expand your window of inference and you get a certain window of carry forward interactions.

Q-RNNS are not always better than LSTMs, but they are much faster. Long-term this isn't the idea that will end up winning out (Transformers will likely be that idea).

### More detail about Q-RNNs:
QRNNs use a regular convolution layer in the timestep dimension to compute three vectors for each input: a candidate vector, a forget gate, and an output gate.
More specifically, given an input sequence of $n$-dimensional vectors $x_1, x_2, ... x_T$ , the convolution layer for the candidate vectors with $m$ filters produces a sequence of $T$  m-dimensional output vectors $z_1, z_2, ..., z_T$. The same goes for the forget gates and output gates. The precise equations are
\begin{align}
z_t = & \tanh(conv_{W_z}(x_t, ..., x_{t - k + 1})) \\
f_t = & \sigma(conv_{W_f}(x_t, ..., x_{t - k + 1})) \\
z_t = & \sigma(conv_{W_o}(x_t, ..., x_{t - k + 1}))
\end{align}
This is just a normal convolution. The real magic happens in the pooling layer.
Using the inputs computed above, the QRNN computes the hidden states (outputs) according to the following equation:

\begin{align}
c_t = & f_t \circ c_{t-1} + (1 - f_t) \circ z_t \\
h_t = & o_t \circ c_t
\end{align}

where $\circ$ is the Hadamard product.

This equation looks like the equation for the LSTM, and the difference may seem a bit unclear at first. The important difference is that the sequential processing only occurs in the pooling layer and that the values of $z_t$, $f_t$, and $o_t$ do not depend on any previous values. This is the essence of QRNNs: do the heavy computation in parallel and do minimal sequential processing in the pooling layers.

That is, the output hidden states of each layer of a Q-RNN at each position do contain some and may be overwritten by some 'past' information as determined by the forget and ourput gates, but it can only be as far past as the kernel size.Thus for each layer, the span of dependencies that can be learned in the feature representation is only the kernel size, but longer and longer dependencies can be learned as we increase the depth.

[Source](https://mlexplained.com/2018/04/09/paper-dissected-quasi-recurrent-neural-networks-explained/)

![Screenshot 2020-01-24 at 7.18.50 PM.png](resources/5A2985923E8C111B81B923D26D967DAD.png)\\

![Screenshot 2020-01-24 at 7.22.29 PM.png](resources/9BD04A6BADA9074AE05C77AD15858B10.png)

# General Ideas in ConvNets for NLP

## Gating Units used Vertically
The gating/skipping that we wall in LSTMs and GRUs is a general idea, which is now used in a whole bunch of places. You can also gate vertically between layers of convolutions.
Indeed the key idea- summing candidate update with shortcut connection- is needed for very deep networks to work.

![Screenshot 2020-01-24 at 4.55.52 PM.png](resources/CA27FB5DB67E6E1A1F2C819CD0C28E3F.png)

##

### Residual Block (He et al 2016)
Simple skip connection, used in ResNet. The skipped embedding is added (not concatenated) to the output of the Conv layer.
### Highway block (Srivistava et al 2015)
Instead of adding the identity and the Conv layer, multiply the Conv layer outout to a $T$ gate and the identity ourput to a $C$ gate.

The residual block is about just as powerful as a highway block, and it is also simpler. How to interpret the residual block is that the default action is to carry over the identity to the next layer, and the job of the Conv block is to learn the deviations from the identity which should be taken between the layer.

The highway block seems more powerful as you are able to control both how much of the identity and how much of the new signal gets carried forth. But it isn't really, because you have have the Conv block in the residual network learn the amount of identity signal to lose.

# Appendix
(1) 1D CNNs in Pytorch
```
batch_size = 16
word_embed_size = 4
seq_len = 7
input = torch.randn(batch_size, word_embed_size, seq_len)
conv1 = Conv1d(in_channels=word_embed_size, out_channels=3, kernel_size=3) # can add: padding=1
hidden1 = conv1(input)
hidden2 = torch.max(hidden1, dim=2) # max pool
```

(2) Other less helpful notions:
The below are all ways to compress data. They are from vision, not many people actually use them in NLP.
- Stride(2) - We can jump every 2 words in the convolution. Rarely used.
- Local Max Pool, Stride=2. After getting the features from the convolutions, compress the representation into half the size by taking the max of every 2 positions.
- k-max pooling over time:
  - pick the k highest activations in the sequence and keep them in the order they origianlly appeared, throwing out the rest.

![Screenshot 2020-01-24 at 4.18.22 PM.png](resources/C1E3468969DF1E74B61921AC47A775B3.png)

![Screenshot 2020-01-24 at 4.19.12 PM.png](resources/7FBD2EAB02EA2558A3385241EA8CA3D9.png)

![Screenshot 2020-01-24 at 4.20.49 PM.png](resources/D522F76EBD1BA3560E522210314E5D1E.png)

(3) Comparison of models simple to complex:

![Screenshot 2020-01-24 at 4.41.40 PM.png](resources/C8A625EF3B24AE4210A47A40BB3855DD.png)

(4) CNN on NMT (2013, very old, the first NMT paper of the modern era)

The encoder was a CNN, which was decoded with a sequence model.

It’s really easy to use CNN as encoders.

It’s harder to use CNNs as decoders (because you have to use masking of future words during training).

![Screenshot 2020-01-24 at 5.05.26 PM.png](resources/F2BF19AC8C14A4FC0E74945B2C6B122D.png)

(5) Character level CNNs for POS tagging

Character level CNNs to build a word embedding.

![Screenshot 2020-01-24 at 5.08.42 PM.png](resources/A05EB46DDB3B6FCC77A0247A45A1715D.png)

url: https://raw.githubusercontent.com/textangel/textangel.github.io-old/e4f60d5a9ee9acd18a8c28a0a8af9165fd00fd46/_posts/CS224N Lecture 11-  CNNs for NLP.md

filename: CS224N Lecture 11-  CNNs for NLP.md


text:
## RAMP Challenge: French deputies votes prediction

Authors: *Florian Eisenbarth, Nicolas Oulianov, Nicolas Boussenina, Armand Foucault, Eloi Alardet*

This class group project is about predicting positions of deputies on votes in the French National Assembly.

We collect data from the government and heavily process it to build a custom supervized dataset.

We analyze this dataset to highlight *political games* inside the National Assembly.

Finally, using a Deep Learning model and smart feature engineering, we predict voting positions of a set of 10 political groups. We reach an accuracy of roughly 75%. We create a custom metric, a weighted F1 score tuned to our problem, that scores about 72% (best being 100%).

### Test your estimator

The submissions need to be located in the submissions folder. For instance for my_submission, it should be located in submissions/my_submission.

To run a specific submission, you can use the ramp-test command line:

`ramp-test --submission my_submission`

You can get more information regarding this command line:

`ramp-test --help`

### About RAMP...

To get more info about RAMP library, please visit [the documentation](https://paris-saclay-cds.github.io/ramp-docs/ramp-workflow/stable/using_kits.html).

### License

This project is published under a [MIT License](https://opensource.org/licenses/MIT).


text:
---
id: standalone
title: Standalone instalation
permalink: docs/standalone.html
prev: getting-started.html
next: create-react-app.html
---

In order to get started witout any web framework, if you just want to get started with Smart contracts only
you can do the following based on the method you prefer:

### npx

```bash
mkdir my-dapp
cd my-dapp
npx create-dapp-stack
npm install
```

If you use npm 5.1 or earlier, you can't use npx. Instead, install dapp-stack globally:

```bash
npm install -g create-dapp-stack
```

Now you can run:

```bash
mkdir my-dapp
cd my-dapp
create-dapp-stack
npm install
```

### npm

```bash
mkdir my-dapp
cd my-dapp
npm init dapp-stack
npm install
```

npm init <initializer> is available in npm 6+

### yarn

```bash
mkdir my-dapp
cd my-dapp
yarn create dapp-stack
yarn install
```

yarn create is available in Yarn 0.25+

It will create a directory called my-dapp inside the current folder.
Inside that directory, it will generate the initial project structure:

```bash
my-dapp
├── README.md
├── node_modules
├── package.json
├── .gitignore
├── environments
│   ├── local.js
│   └── test.js
└── contracts
    ├── src
    |   └── SimpleStorage.sol
    └── tests
        └── SimpleStorageTest.js
```

No configuration or complicated folder structures, just the files you need to build your dapp.

repository: sambarton/Dapp-Stack

repo_name: sambarton/Dapp-Stack


text:
## Fizz Buzz - AlgoDaily Day 2

Fizz Buzz is a classic interview question that apparently many engineering candidates can't solve! Let's cover it today.

We're given a number in the form of an integer n.

Write a function that returns the string representation of all numbers from 1 to n based on the following rules:

If it's a multiple of 3, represent it as "fizz".

If it's a multiple of 5, represent it as "buzz".

If it's a multiple of both 3 and 5, represent it as "fizzbuzz".

If it's neither, just return the number itself.

As such, fizzBuzz(15) would result in '12fizz4buzzfizz78fizzbuzz11fizz1314fizzbuzz'.

[Solution](/problems/002/index.js)

repository: bobthered/algodaily

branch_name: refs/heads/main

repo_name: bobthered/algodaily


text:
ofxAppUtils
===========

openFrameworks app utilities

Copyright (c) [Dan Wilcox](danomatika.com) 2011-2017

BSD Simplified License.

For information on usage and redistribution, and for a DISCLAIMER OF ALL
WARRANTIES, see the file, "LICENSE.txt," in this distribution.

See Documentation on [Github](https://github.com/danomatika/ofxAppUtils) and the [openFrameworks Forum post](https://forum.openframeworks.cc/t/ofxapputils/5995).

openFrameworks is a cross platform open source toolkit for creative coding in C++.

[http://www.openframeworks.cc/](http://www.openframeworks.cc/)

This project has been supported by the CMU [Frank-Ratchey STUDIO for Creative Inquiry](http://studioforcreativeinquiry.org) and the DU [Emergent Digital Practices Program](https://www.du.edu/ahss/edp/).

Description
-----------

ofxAppUtils is a set of utilities for openFrameworks application development including:

* ofxApp: an ofBaseApp/ofxiPhoneApp extension with optional screen scaling transformer & scene manager
* ofxScene: a mini ofBaseApp/ofxiPhoneApp for writing stand alone scenes
* ofxSceneManager: handles a list of scenes using a std::map
* ofxTransformer: open gl transformer for origin translation, screen scaling, mirroring, and quad warping
* ofxQuadWarper: an open gl matrix quad warper (useful for oblique projection mapping)
* ofxTimer: a simple millis-based timer
* ofxMovingAverage: a simple linear moving average
* ofxParticle: a simple time-based particle base class
* ofxParticleSystem: an auto manager for ofxParticles
* ofxBitmapString: a stream interface for ofDrawBitmapString

All ofBaseApp & ofxiOSApp callbacks are handled down to the scene level.

Installation
------------

To use ofxAppUtils, first you need to download and install Open Frameworks. ofxAppUtils is currently developed against the latest stable version of Open Frameworks on github.

To get a copy of the repository you can download the source from [http://github.com/danomatika/ofxAppUtils/zipball/master](http://github.com/danomatika/ofxAppUtils/zipball/master) or, alternatively, you can use git clone:

git clone git://github.com/danomatika/ofxAppUtils.git

The addon should sit in `openFrameworks/addons/ofxAppUtils/`.

### Which version to use?

The master branch of ofxAppUtils will work with the current stable version of openFrameworks and can be considered *relatively* stable.

Previous versions are tagged using [Semantic Versioning](http://semver.org) with the updates to newer versions of openFrameworks noted in the changelog, CHANGES.txt. You can select the tag in the Github "Current Branch" menu or clone and check it out using git.

If you want to use ofxAppUtils with a previous version of openFrameworks, checkout the corresponding version tag after cloning:

    git clone git://github.com/danomatika/ofxAppUtils.git
    cd ofxAppUtils
    git checkout 0.5.0

### Dependencies

You may also need the following addon dependencies:

* ofxGui: included with openFrameworks

To enable the ofxGui transformer panel, include `ofxTransformerPanel.h`, create an "ofxTransformerPanel" object, and set the transformer in _ofxTransformerPanel::setup()_.

Running the Example Projects
----------------------------

The example projects are in the `appUtilsExample` & `appUtilsIOSExample` folders.

Project files for the examples are not included so you will need to generate the project files for your operating system and development environment using the OF ProjectGenerator which is included with the openFrameworks distribution.

To (re)generate project files for an *existing* project:

* click the "Import" button in the ProjectGenerator
* navigate to the base folder for the example project ie. "appUtilsExample"
* click the "Update" button

If everything went Ok, you should now be able to open the generated project and build/run the example.

### macOS

Open the Xcode project, select the appUtilsExample-Debug scheme, and hit "Run".

### Linux

Open the Code::Blocks .cbp and hit F9 to build. Optionally, you can build the example with the Makefile.

To build and run it on the terminal:

make
make run

### Windows

An example Visual Studio solution as well as a Codeblocks workspace are included.

Adding ofxAppUtils to an Existing Project
---------------------------------------

### ProjectGenerator

Select ofxAppUtils and other addons used by your project from the available addons in the ProjectGenerator, select the parent folder of your project, and set the *exact* name of the existing project in the text box. This will overwrite the existing project files with new ones that now include ofxAppUtils.

*Note: you will lose any custom settings you've added manually to your project.*

### Manual Method

_Note: These instructions are for manually adding ofxAppUtils to an existing project. You do not need to follow these steps if you use the ProjecGenerator app, except for adding the OFX_APP_UTILS defines._

If you want to add ofxAppUtils to another project, you need to make sure you include the src folders:

openFrameworks/addons/ofxAppUtils/src

### Xcode

* create a new group "ofxAppUtils"
* drag these directories from ofxAppUtils into this new group: ofxAppUtils/src
* you also need to add the following addon dependencies (if you're using them) in a similar manner:
	* ofxGui
* make sure to remove any of the example folders in the Xcode project tree for any of the addons you've added manually

### For Linux (Makefiles & Codeblocks):

* edit addons.make in your project folder and add the following line to the end of the file:

ofxAppUtils

### For Codeblocks (Win):

* add the ofxAppUtils sources to the project:
	* right-click on your project in the project tree
	* select "Add Files Recursively ..."
	* navigate and choose the ofxAppUtils/src folder
* add defines, search paths, and libraries to link:
	* right-click on your project in the project tree
	* select "Build options..."
	* make sure the project name is selected in the tree (not release or debug)
	* select the "Compiler settings" tab
	* select the "Search directories" tab, click add the search paths:

	..\\..\\..\addons\ofxAppUtils\src

### For Visual Studio:

* drag the ofxApputils/src folder onto the project tree
* right click on the project in the project tree and select Properties
* set the Configuration to All Configurations
* add the defines and search paths:
  * add to the search paths in Configuration Properties->C/C++->General->Additonal Include Directories:

  ..\\..\\..\\addons\ofxAppUtils\src

### Extending Your BaseApp

There are two changes you need to make to extend your app with the ofApputils ofxApp class which handles all the *automagic*:

* your base app needs to inherit from ofxApp in your ofApp.h

class ofApp : public ofBaseApp {
// becomes
class ofApp : public ofxApp {

* you need to run your app with the app utils in main.cpp

ofRunApp(new ofApp());
// becomes
ofRunAppWithAppUtils(new ofApp());

That's it. Check the example ofApp::setup() for more info on startup settings.

Note: this is completely optional. You can always handle the transforms etc yourself using an ofxTransformer instance, etc.

#### ofxGetAppPtr

Internally, calling `ofRunAppWithAppUtils` actually creates a wrapper ofBaseApp which then runs the given ofxApp. As a result, **calling `ofGetAppPtr()` does not work correctly** as it returns a pointer to the wrapper and not the app itself.

In order to fix this, there is a new function added with ofxAppUtils called `ofxGetAppPtr()` (note the "x") which returns the correct pointer. If you are porting existing code, make sure to change any `ofGetAppPtr()` calls to `ofxGetAppPtr()`.

DEVELOPING
----------

You can help develop ofxAppUtils on GitHub: [https://github.com/danomatika/ofxAppUtils](https://github.com/danomatika/ofxAppUtils)

Create an account, clone or fork the repo, then request a push/merge.

If you find any bugs or suggestions please log them to GitHub as well.

repository: danomatika/ofxAppUtils

repo_name: danomatika/ofxAppUtils


text:
![Hero Image](https://github.com/jamland/samplescope/blob/main/assets/banner.png?raw=true)

# Samplescope

Download [Samplescope App for macOS or Windows](https://github.com/jamland/samplescope/releases/)

## Simply

Samplescope is app to search audio samples over internet

## Detailed

There are 2 main stimulus for this app:

- Give a user a simple (quick and easy) way to search over online samples
- Research the field of available online audio resources

# Development

## TBA: Description followed open source project on github

## Commands

Some script commands uses `cross-env` to ensure to set and use environment variables across platforms.

| Command     | Description                                 |
| ----------- | ------------------------------------------- |
| start       | Start app in DEV mode                       |
| start:watch | Same and watch for changes                  |
| make        | Compile ready-to-use app                    |
| package     | Compile app (not distributable, use `make`) |
| publish     | `make`, notarize and publish to GitHub      |
| lint        | Lint app                                    |
| lint:app    | Lint app w/ `electron-forge`                |
| test        | Run tests                                   |

Details on [Electron Forge docs for CLI](https://www.electronforge.io/cli)

### Notarize

The config could be found in `forge.config`.

macOS: `APPLE_ID` & `APPLE_ID_PASSWORD` tokens needs to be added to `.env` file. All notarization works done by `src/hooks/notarize` hook on `publish` cmd.

Windows: Code-sign certificate need to be placed within `private/` folder.

The rest of the work for both platforms done automatically on `npm run publish` cmd.

### Publish

This command will attempt to make the forge application and then publish it to the publish targets defined in `forge.config`.

It will post to (or create if not exist) Github's Draft Releases with name of last version.
You need to run publish on each platform you want to support, so `Samplescope-X.X.X.Setup.exe` will be made on posted from Win and `Samplescope-darwin-x64-X.X.X.zip` on MacOS.

## Private Keys

There are some 3rd-party API related credentials, Github token, Apple passwords and other sensative private credentials required to run, package, deploy this app. This credentials should not be published to repository for security reasons, and should be added manually by developer.
Specifically:

- add new `.env` file. There is `.env.example` with example of required keys
- add `./private` folder
- add `./private/GH_TOKEN.txt` file with GitHub token
- add `./private/AppleIdPassword.txt` file with generated Apple Id Password

repository: KoSukeWork/samplescope

repo_name: KoSukeWork/samplescope


text:
rebel-loading
=============

A simple web component to display a loading spinner.

Usage
=====

You can simply include the either the ES5 version from `dist/` or the ES2015 version from `src/` into your project and make use of the custom element `rebel-loading`.

```javascript
    <button id="btn">Toggle</button>
    <div class="frame">
        <rebel-loading id="loader"></rebel-loading>
    </div>
    <script>
        document.querySelector("#btn").addEventListener("click", function(){
            document.querySelector("#loader").toggle();
        });
    </script>
```

For convenience you can also install it via npm: `npm install rebel-repeater`

Polyfills
=========

This web component uses V1 of the [Custom Elements](https://developers.google.com/web/fundamentals/getting-started/primers/customelements) specification, to get this working in most browsers you are going to need to use a polyfill. It is recommended that you include the following [SkateJS Web Components](https://github.com/skatejs/web-components) polyfill:

`<script src="https://unpkg.com/skatejs-web-components/dist/index-with-deps.min.js"></script>`

API
===

At this point in time the component is very primitive and more a proof of concept than anything useful.

Attributes
----------

There are currently no attributes available for this component.

Methods
-------

###show

This method simply shows the loading element.

###hide

This method simply hides the loading element.

###toggle

This method simply shows the loading element if it is already hidden or hides it if it is already visible.

###isHidden

This method simply returns true if the loading element is hidden.

Contributing
============

To contribute to this project all you will need is jspm installed and a love of web components. Please submit any suggestions or changes via a pull request.

repository: RevillWeb/rebel-loading

repo_name: RevillWeb/rebel-loading


text:
YiiChimp Basic Project Template
============================

This template is evolved from Yii2 Basic Project Template.

The template contains the basic features provided by Yii2 along with the addition of demo client module which would demonstrate the crud operations using
YiiChimp architectural changes.

REQUIREMENTS
------------

The minimum requirement by this project template that your Web server supports PHP 5.4.0.

INSTALLATION
------------

### Install via Composer

If you do not have [Composer](http://getcomposer.org/), you may install it by following the instructions
at [getcomposer.org](http://getcomposer.org/doc/00-intro.md#installation-nix).

You can then install this project template using the following command:

~~~
php composer.phar global require "fxp/composer-asset-plugin:^1.3.1"
php composer.phar create-project --prefer-dist ushainformatique/yiichimp-app-basic yiichimpbasic
~~~

Now you should be able to access the application through the following URL, assuming `basic` is the directory
directly under the Web root.

~~~
http://localhost/yiichimpbasic/web/
~~~

### Install from an Archive File

Extract the archive file downloaded from [github.com](http://www.github.com/ushainformatique/yiichimpbasic) to
a directory named `yiichimpbasic` that is directly under the Web root.

Set cookie validation key in `config/web.php` file to some random secret string:

```php
'request' => [
    // !!! insert a secret key in the following (if it is empty) - this is required by cookie validation
    'cookieValidationKey' => '<secret random string goes here>',
],
```

You can then access the application through the following URL:

~~~
http://localhost/yiichimpbasic/web/
~~~

CONFIGURATION
-------------

### Database

Edit the file `config/db.php` with real data, for example:

```php
return [
    'class' => 'yii\db\Connection',
    'dsn' => 'mysql:host=localhost;dbname=yiichimp',
    'username' => 'root',
    'password' => '',
    'charset' => 'utf8',
];
```

**NOTES:**
- YiiChimp won't create the database for you, this has to be done manually before you can access it.
- Check and edit the other files in the `config/` directory to customize your application as required.

Install Framework Modules Tables and Data
-----------------------------------------

The framework is provided with modules like users, auth, settings, services and notifications. In case the tables and data for these modules has to be installed, the following commands has to be executed.

yii build/tables
yii build/super
yii build/data

The first command would build the module tables. The second command would install the super user for the application. The third command would install the data for the modules.

repository: ushainformatique/yiichimp-app-basic

repo_name: ushainformatique/yiichimp-app-basic


text:
# sizes

`sizes` is a bash command line tool to display the content of a directory showing the sizes in a human readable format.
The output is ordered descending by size.

## Examples

```bash
$ sizes
4,0K	./sizes
4,0K	./README.md
4,0K	./LICENSE
```

```bash
$ sizes /var/log
 33M	/var/log/install.log
4,0M	/var/log/wifi.log
2,2M	/var/log/asl
2,0M	/var/log/DiagnosticMessages
1,4M	/var/log/powermanagement
468K	/var/log/wifi.log.0.bz2
324K	/var/log/system.log
160K	/var/log/displaypolicy
 56K	/var/log/dm
 24K	/var/log/system.log.2.gz
 24K	/var/log/system.log.1.gz
 20K	/var/log/system.log.0.gz
 12K	/var/log/daily.out
8,0K	/var/log/fsck_apfs.log
4,0K	/var/log/fsck_apfs_error.log
4,0K	/var/log/emond
4,0K	/var/log/cups
4,0K	/var/log/Bluetooth
  0B	/var/log/uucp
  0B	/var/log/shutdown_monitor.log
```

repository: Cravid/sizes

repo_name: Cravid/sizes


text:
# Media Queries
Some components require different styles for mobile devices and desktop screens.
The default [_media-queries.scss](https://github.com/mlaursen/react-md/blob/master/src/scss/_media-queries.scss)
is included by default.

The initial breakpoints are just at `600px`. If you want to define your own media queries
or only use a few components, you can use the `md-COMPONENT-mobile` or `md-COMPONENT-desktop`.
There are also some components that are different on mobile for landscape or portrait. They will
be defined as `md-COMPONENT-portrait` or `md-COMPONENT-landscape`.  Check out the mixins in the
[sassdoc](/sassdoc) for full details.

#### Limited Components and Media Queries
Here is an example application that only uses `DatePickers`, `Buttons`, `TextFields`, and `Cards`.

```scss
@import '~react-md/src/scss/helpers/all';
@import '~react-md/src/scss/utils';
@import '~react-md/src/scss/typography';
@import '~react-md/src/scss/components/buttons';
@import '~react-md/src/scss/components/cards';
@import '~react-md/src/scss/components/inks';
@import '~react-md/src/scss/components/pickers';
@import '~react-md/src/scss/components/text-fields';

@media only screen and (orientation: portrait) and (max-width: 599px) {
  @include md-pickers-portrait();
}

@media only screen and (orientation: portrait) and (max-width: 599px) {
  @include md-pickers-landscape();
}

@media only screen and (min-width: 0) and (max-width: 599px) {
  @include md-lists-desktop();
  @include md-text-field-mobile();
}

@media only screen and (min-width: 600px) {
  @include md-lists-desktop();
  @include md-text-field-desktop();
  @include md-pickers-landscape();
}
```

This will not include all the other `react-md` components and update
the comonent styles at the given breakpoints.

repository: JonathanSudibya/react-md-docs

repo_name: JonathanSudibya/react-md-docs


text:
# Table of contents

* [Welcome to Noir Roleplay](README.md)

## Rules

* [Noir Roleplay Rules](rules/noir-rules/README.md)
  * [Punishment Policy](rules/noir-rules/punishment-policy.md)
  * [FiveM & Discord Rules](rules/noir-rules/fivem-and-discord-rules.md)
  * [Discord Rules](rules/noir-rules/discord-rules.md)
  * [FiveM Rules](rules/noir-rules/fivem-rules.md)
  * [LEO Rules](rules/noir-rules/leo-rules.md)
  * [Department Rules](rules/noir-rules/department-rules.md)

repository: JaredScar/Noir-Roleplay-Gitbook

repo_name: JaredScar/Noir-Roleplay-Gitbook


text:
# svycka/sv-settings

[![Build Status][ico-travis]][link-travis]
[![Coverage Status](https://coveralls.io/repos/svycka/sv-settings/badge.svg?branch=master&service=github)](https://coveralls.io/github/svycka/sv-settings?branch=master)
[![Quality Score][ico-code-quality]][link-code-quality]
[![Latest Version on Packagist][ico-version]][link-packagist]
[![Software License][ico-license]](LICENSE.md)
[![Total Downloads][ico-downloads]][link-downloads]

This module simplifies settings storage. For example this can be used with [ZfcUser](https://github.com/ZF-Commons/ZfcUser) or store your application global settings. This module also could be used with CMS to store page settings like title, description, SEO, published time or whatever you want. This module also provides optional simple REST API to change your settings.

## Install

Via Composer

``` bash
$ composer require svycka/sv-settings
```

## Basic Usage

- Register `Svycka/Settings` as module in `config/application.config.php`
- Copy the file located in `vendor/svycka/sv-settings/config/settings.global.php.dist` to `config/autoload/settings.global.php` and change the values as you wish

## Change log

Please see [CHANGELOG](CHANGELOG.md) for more information what has changed recently.

## Credits

- [Vytautas Stankus][link-author]
- [All Contributors][link-contributors]

## License

The MIT License (MIT). Please see [License File](LICENSE.md) for more information.

[ico-version]: https://img.shields.io/packagist/v/svycka/sv-settings.svg?style=flat-square
[ico-license]: https://img.shields.io/badge/license-MIT-brightgreen.svg?style=flat-square
[ico-travis]: https://img.shields.io/travis/svycka/sv-settings/master.svg?style=flat-square
[ico-code-quality]: https://img.shields.io/scrutinizer/g/svycka/sv-settings.svg?style=flat-square
[ico-downloads]: https://img.shields.io/packagist/dt/svycka/sv-settings.svg?style=flat-square

[link-packagist]: https://packagist.org/packages/svycka/sv-settings
[link-downloads]: https://packagist.org/packages/svycka/sv-settings
[link-travis]: https://travis-ci.org/svycka/sv-settings
[link-code-quality]: https://scrutinizer-ci.com/g/svycka/sv-settings
[link-author]: https://github.com/svycka
[link-contributors]: ../../contributors

repository: svycka/sv-settings

gha_language: PHP

repo_name: svycka/sv-settings


text:
{% comment %}
This file is licensed under the MIT License (MIT) available on
http://opensource.org/licenses/MIT.
{% endcomment %}

{% capture INCLUDE_F_LIST_TRANSACTIONS %}
- n: "{{DEPTH}}
`involvesWatchonly`"
  t: "bool"
  p: "Optional
(0 or 1)"
  d: "Set to `true` if the payment involves a watch-only address.  Otherwise not returned"

- n: "{{DEPTH}}
`account`"
  t: "string"
  p: "Required
(exactly 1)"
  d: "*Deprecated: will be removed in a later version of Bitcoin Core*

The account which the payment was credited to or debited from.  May be an empty string (\"\") for the default account"

- n: "{{DEPTH}}
`address`"
  t: "string (base58)"
  p: "Optional
(0 or 1)"
  d: "The address paid in this payment, which may be someone else's address not belonging to this wallet.  May be empty if the address is unknown, such as when paying to a non-standard pubkey script"

- n: "{{DEPTH}}
`category`"
  t: "string"
  p: "Required
(exactly 1)"
  d: "Set to one of the following values:
• `send` if sending payment
• `receive` if this wallet received payment in a regular transaction
• `generate` if a matured and spendable coinbase
• `immature` if a coinbase that is not spendable yet
• `orphan` if a coinbase from a block that's not in the local best block chain"

- n: "{{DEPTH}}
`amount`"
  t: "number (bitcoins)"
  p: "Required
(exactly 1)"
  d: "A negative bitcoin amount if sending payment; a positive bitcoin amount if receiving payment (including coinbases)"

- n: "{{DEPTH}}
`vout`"
  t: "number (int)"
  p: "Required
(exactly 1)"
  d: "For an output, the output index (vout) for this output in this transaction.  For an input, the output index for the output being spent in its transaction.  Because inputs list the output indexes from previous transactions, more than one entry in the details array may have the same output index"

- n: "{{DEPTH}}
`fee`"
  t: "number (bitcoins)"
  p: "Optional
(0 or 1)"
  d: "If sending payment, the fee paid as a negative bitcoins value.  May be `0`. Not returned if receiving payment"

{% endcapture %}

{% capture INCLUDE_F_LIST_TRANSACTIONS_F_FULL %}
- n: "{{DEPTH}}
`confirmations`"
  t: "number (int)"
  p: "Required
(exactly 1)"
  d: "The number of confirmations the transaction has received.  Will be `0` for unconfirmed and `-1` for conflicted"

- n: "{{DEPTH}}
`generated`"
  t: "bool"
  p: "Optional
(0 or 1)"
  d: "Set to `true` if the transaction is a coinbase.  Not returned for regular transactions"

- n: "{{DEPTH}}
`blockhash`"
  t: "string (hex)"
  p: "Optional
(0 or 1)"
  d: "The hash of the block on the local best block chain which includes this transaction, encoded as hex in RPC byte order.  Only returned for confirmed transactions"

- n: "{{DEPTH}}
`blockindex`"
  t: "number (int)"
  p: "Optional
(0 or 1)"
  d: "The index of the transaction in the block that includes it.  Only returned for confirmed transactions"

- n: "{{DEPTH}}
`blocktime`"
  t: "number (int)"
  p: "Optional
(0 or 1)"
  d: "The block header time (Unix epoch time) of the block on the local best block chain which includes this transaction.  Only returned for confirmed transactions"

- n: "{{DEPTH}}
`txid`"
  t: "string (hex)"
  p: "Required
(exactly 1)"
  d: "The TXID of the transaction, encoded as hex in RPC byte order"

- n: "{{DEPTH}}
`walletconflicts`"
  t: "array"
  p: "Required
(exactly 1)"
  d: "An array containing the TXIDs of other transactions that spend the same inputs (UTXOs) as this transaction.  Array may be empty"

- n: "{{DEPTH}}→
TXID"
  t: "string (hex)"
  p: "Optional
(0 or more)"
  d: "The TXID of a conflicting transaction, encoded as hex in RPC byte order"

- n: "{{DEPTH}}
`time`"
  t: "number (int)"
  p: "Required
(exactly 1)"
  d: "A Unix epoch time when the transaction was added to the wallet"

- n: "{{DEPTH}}
`timereceived`"
  t: "number (int)"
  p: "Required
(exactly 1)"
  d: "A Unix epoch time when the transaction was detected by the local node, or the time of the block on the local best block chain that included the transaction"

- n: "{{DEPTH}}
`bip125-replaceable`"
  t: "string"
  p: "Required
(exactly 1)"
  d: "*Added in Bitcoin Core 0.12.0*

Indicates if a transaction is replaceable under BIP 125:
• `yes` is replaceable
• `no` not replaceable
• `unknown` for unconfirmed transactions not in the mempool"

- n: "{{DEPTH}}
`comment`"
  t: "string"
  p: "Optional
(0 or 1)"
  d: "For transaction originating with this wallet, a locally-stored comment added to the transaction.  Only returned if a comment was added"

- n: "{{DEPTH}}
`to`"
  t: "string"
  p: "Optional
(0 or 1)"
  d: "For transaction originating with this wallet, a locally-stored comment added to the transaction identifying who the transaction was sent to.  Only returned if a comment-to was added"

{% endcapture %}

{% capture INCLUDE_SPEND_CONFIRMATIONS %}
{% itemplate ntpd1 %}
- n: "Confirmations"
  t: "number (int)"
  p: "Optional
(0 or 1)"
  d: "The minimum number of confirmations an incoming transaction must have for its outputs to be credited to this account's balance. Outgoing transactions are always counted, as are move transactions made with the `move` RPC. If an account doesn't have a balance high enough to pay for this transaction, the payment will be rejected.  Use `0` to spend unconfirmed incoming payments. Default is `1`"

{% enditemplate %}

![Warning icon](/img/icons/icon_warning.svg?{{site.time | date: '%s'}})
**Warning:** if account1 receives an unconfirmed payment and transfers
it to account2 with the `move` RPC, account2 will be able to spend those
bitcoins even if this parameter is set to `1` or higher.{% endcapture %}

{% capture INCLUDE_DECODE_RAW_TRANSACTION %}
- n: "{{DEPTH}} →
`txid`"
  t: "string (hex)"
  p: "Required
(exactly 1)"
  d: "The transaction's TXID encoded as hex in RPC byte order"

- n: "{{DEPTH}} →
`hash`"
  t: "string (hex)"
  p: "Required
(exactly 1)"
  d: "*Added in Bitcoin Core 0.13.0*

The transaction hash.  Differs from txid for witness transactions"

- n: "{{DEPTH}} →
`size`"
  t: "number (int)"
  p: "Required
(exactly 1)"
  d: "*Added in Bitcoin Core 0.12.0*

The serialized transaction size"

- n: "{{DEPTH}} →
`vsize`"
  t: "number (int)"
  p: "Required
(exactly 1)"
  d: "*Added in Bitcoin Core 0.13.0*

The virtual transaction size.  Differs from size for witness transactions"

- n: "{{DEPTH}} →
`version`"
  t: "number (int)"
  p: "Required
(exactly 1)"
  d: "The transaction format version number"

- n: "{{DEPTH}} →
`locktime`"
  t: "number (int)"
  p: "Required
(exactly 1)"
  d: "The transaction's locktime: either a Unix epoch date or block height; see the [Locktime parsing rules][]"

- n: "{{DEPTH}} →
`vin`"
  t: "array"
  p: "Required
(exactly 1)"
  d: "An array of objects with each object being an input vector (vin) for this transaction.  Input objects will have the same order within the array as they have in the transaction, so the first input listed will be input 0"

- n: "{{DEPTH}} → →
Input"
  t: "object"
  p: "Required
(1 or more)"
  d: "An object describing one of this transaction's inputs.  May be a regular input or a coinbase"

- n: "{{DEPTH}} → → →
`txid`"
  t: "string"
  p: "Optional
(0 or 1)"
  d: "The TXID of the outpoint being spent, encoded as hex in RPC byte order.  Not present if this is a coinbase transaction"

- n: "{{DEPTH}} → → →
`vout`"
  t: "number (int)"
  p: "Optional
(0 or 1)"
  d: "The output index number (vout) of the outpoint being spent.  The first output in a transaction has an index of `0`.  Not present if this is a coinbase transaction"

- n: "{{DEPTH}} → → →
`scriptSig`"
  t: "object"
  p: "Optional
(0 or 1)"
  d: "An object describing the signature script of this input.  Not present if this is a coinbase transaction"

- n: "{{DEPTH}} → → → →
`asm`"
  t: "string"
  p: "Required
(exactly 1)"
  d: "The signature script in decoded form with non-data-pushing opcodes listed"

- n: "{{DEPTH}} → → → →
`hex`"
  t: "string (hex)"
  p: "Required
(exactly 1)"
  d: "The signature script encoded as hex"

- n: "{{DEPTH}} → → →
`coinbase`"
  t: "string (hex)"
  p: "Optional
(0 or 1)"
  d: "The coinbase (similar to the hex field of a scriptSig) encoded as hex.  Only present if this is a coinbase transaction"

- n: "{{DEPTH}} → → →
`sequence`"
  t: "number (int)"
  p: "Required
(exactly 1)"
  d: "The input sequence number"

- n: "{{DEPTH}} → → →
`txinwitness`"
  t: "string : array"
  p: "Optional
(0 or 1)"
  d: "*Added in Bitcoin Core 0.13.0*

Hex-encoded witness data. Only for segregated witness transactions"

- n: "{{DEPTH}} →
`vout`"
  t: "array"
  p: "Required
(exactly 1)"
  d: "An array of objects each describing an output vector (vout) for this transaction.  Output objects will have the same order within the array as they have in the transaction, so the first output listed will be output 0"

- n: "{{DEPTH}} → →
Output"
  t: "object"
  p: "Required
(1 or more)"
  d: "An object describing one of this transaction's outputs"

- n: "{{DEPTH}} → → →
`value`"
  t: "number (bitcoins)"
  p: "Required
(exactly 1)"
  d: "The number of bitcoins paid to this output.  May be `0`"

- n: "{{DEPTH}} → → →
`n`"
  t: "number (int)"
  p: "Required
(exactly 1)"
  d: "The output index number of this output within this transaction"

- n: "{{DEPTH}} → → →
`scriptPubKey`"
  t: "object"
  p: "Required
(exactly 1)"
  d: "An object describing the pubkey script"

- n: "{{DEPTH}} → → → →
`asm`"
  t: "string"
  p: "Required
(exactly 1)"
  d: "The pubkey script in decoded form with non-data-pushing opcodes listed"

- n: "{{DEPTH}} → → → →
`hex`"
  t: "string (hex)"
  p: "Required
(exactly 1)"
  d: "The pubkey script encoded as hex"

- n: "{{DEPTH}} → → → →
`reqSigs`"
  t: "number (int)"
  p: "Optional
(0 or 1)"
  d: "The number of signatures required; this is always `1` for P2PK, P2PKH, and P2SH (including P2SH multisig because the redeem script is not available in the pubkey script).  It may be greater than 1 for bare multisig.  This value will not be returned for `nulldata` or `nonstandard` script types (see the `type` key below)"

- n: "{{DEPTH}} → → → →
`type`"
  t: "string"
  p: "Optional
(0 or 1)"
  d: "The type of script.  This will be one of the following:
• `pubkey` for a P2PK script
• `pubkeyhash` for a P2PKH script
• `scripthash` for a P2SH script
• `multisig` for a bare multisig script
• `nulldata` for nulldata scripts
• `nonstandard` for unknown scripts"

- n: "{{DEPTH}} → → → →
`addresses`"
  t: "string : array"
  p: "Optional
(0 or 1)"
  d: "The P2PKH or P2SH addresses used in this transaction, or the computed P2PKH address of any pubkeys in this transaction.  This array will not be returned for `nulldata` or `nonstandard` script types"

- n: "{{DEPTH}} → → → → →
Address"
  t: "string"
  p: "Required
(1 or more)"
  d: "A P2PKH or P2SH address"

{% endcapture %}

{% assign INCLUDE_WALLET_UNLOCKED="If the wallet has been encrypted either through the GUI or with the `encryptwallet` RPC, it must first be unlocked with the `walletpassphrase` RPC" %}

{% capture INCLUDE_CONFIRMATIONS_PARAMETER %}
{% itemplate ntpd1 %}
- n: "Confirmations"
  t: "number (int)"
  p: "Optional
(0 or 1)"
  d: "The minimum number of confirmations an externally-generated transaction must have before it is counted towards the balance.  Transactions generated by this node are counted immediately.  Typically, externally-generated transactions are payments to this wallet and transactions generated by this node are payments to other wallets.  Use `0` to count unconfirmed transactions.  Default is `1`"

{% enditemplate %}
{% endcapture %}

{% capture INCLUDE_INCLUDE_WATCH_ONLY_PARAMETER %}
{% itemplate ntpd1 %}
- n: "Include Watch-Only"
  t: "bool"
  p: "Optional
(0 or 1)"
  d: "If set to `true`, include watch-only addresses in details and calculations as if they were regular addresses belonging to the wallet.  If set to `false` (the default), treat watch-only addresses as if they didn't belong to this wallet"

{% enditemplate %}
{% endcapture %}

{% assign WARNING="![Warning icon](/img/icons/icon_warning.svg?1528322191) **Warning:**" %}

{% assign reindexNote="Note: if you begin using `txindex=1` after downloading the block chain, you must rebuild your indexes by starting Bitcoin Core with the option  `-reindex`.  This may take several hours to complete, during which time your node will not process new blocks or transactions. This reindex only needs to be done once." %}

gha_license_id: NOASSERTION


text:
#Thanks for UnitSpawn plugin for Template.
Thanks Volas171

# Unit Spawn
![Build](https://github.com/RebornTrack970/blockPlace/workflows/Build/badge.svg)
## Use

Template: `/place block team x y`

Ex: `/place router sharded 10 10`

## Installation
./gradlew jar


text:
# R-BERT-relation-extraction
[![PWC](https://img.shields.io/endpoint.svg?url=https://paperswithcode.com/badge/enriching-pre-trained-language-model-with/relation-extraction-on-semeval-2010-task-8)](https://paperswithcode.com/sota/relation-extraction-on-semeval-2010-task-8?p=enriching-pre-trained-language-model-with)

Implementation of [Enriching Pre-trained Language Model Entity Information for Relation Classification](https://dl.acm.org/doi/abs/10.1145/3357384.3358119).

## Environment Requirements
* python 3.6.9
* pytorch 1.5.1+cu92
* transformers 2.11.0
* tqdm 4.40.1

## Device
* TITAN Xp
* CUDA Version 9.0.176

## Data
* [SemEval2010 Task8](https://drive.google.com/file/d/0B_jQiLugGTAkMDQ5ZjZiMTUtMzQ1Yy00YWNmLWJlZDYtOWY1ZDMwY2U4YjFk/view?sort=name&layout=list&num=50) \[[paper](https://www.aclweb.org/anthology/S10-1006.pdf)\]
* [bert-base-uncased](https://huggingface.co/bert-base-uncased)

## Usage
1. Download the pre-trained BERT model and put it into the `resource` folder.
2. Run the following the commands to start the program.
```shell
python run.py \
    --batch_size=16 \
    --max_len=128 \
    --lr=2e-5 \
    --epoch=5 \
    --dropout=0.1
```
More details can be seen by `python run.py -h`.

3. You can use the official scorer to check the final predicted result (in the `eval` folder).
```shell
perl semeval2010_task8_scorer-v1.2.pl proposed_answer.txt predicted_result.txt >> result.txt
```

## Result
The result of my version and that in paper are present as follows:
| paper | my version |
| :------: | :------: |
| 0.8925 | 0.8906 |

The training log can be seen in `train.log` and the official evaluation results is available in `result.txt`.

*Note*:
* Some settings may be different from those mentioned in the paper.
* No validation set used during training.

## Reference Link
* https://github.com/monologg/R-BERT

repository: onehaitao/R-BERT-relation-extraction

repo_name: onehaitao/R-BERT-relation-extraction


text:
---
layout: default
---

# 1996-09-07 - Re: Tack of Internet censorship

## Header Data

From<EMAIL_ADDRESS><EMAIL_ADDRESS>To: Anonymous<EMAIL_ADDRESS>Message Hash: 4a7834dec5afb76f84be742e12a1f5ff05e0d59bb41e72f57b7890b8c17bd6eb

Message ID<EMAIL_ADDRESS>Reply To<EMAIL_ADDRESS>UTC Datetime: 1996-09-07 12:03:44 UTC

Raw Date: Sat, 7 Sep 1996 20:03:44 +0800

## Raw message

```
{% raw  %}From<EMAIL_ADDRESS><EMAIL_ADDRESS>Date: Sat, 7 Sep 1996 20:03:44 +0800
To: Anonymous<EMAIL_ADDRESS>Subject: Re: Tack of Internet censorship
In-Reply-To<EMAIL_ADDRESS>Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

On Thu, 5 Sep 1996, Anonymous wrote:

> What I am proposing is that Apache or other WWW servers
> have a way to allow access to site B's URL at site A,
> similar to the old trick of finger user<EMAIL_ADDRESS>>
> Implementation should be simple.  However, I wonder what
> is a good standard way to specify this in the URL or
> a site.

<EMAIL_ADDRESS>

{% endraw %}
```

## Thread

+ Return to [September 1996](/archive/1996/09)

+ Return to<EMAIL_ADDRESS><pstira@escape.com>](/authors/_pstira_at_escape_com__pstira_at_escape_com_)"
+ Return to<EMAIL_ADDRESS>(Anonymous)](/authors/nobody_at_replay_com_anonymous_)"

+ 1996-09-06 (Fri, 6 Sep 1996 17:08:18 +0800) - [Tack of Internet censorship](/archive/1996/09/b0459bb5455122cf531237d3249793bfc1811068f625339ac73d7c254419e91b) -<EMAIL_ADDRESS>(Anonymous)_
  + 1996-09-07 (Sat, 7 Sep 1996 20:03:44 +0800) - Re: Tack of Internet censorship -<EMAIL_ADDRESS><EMAIL_ADDRESS>


text:
# Temporal Anomaly Detection (WEIGHTED AVERAGE) Using Different Thresholds

Within the MDIVI/Weighted Average Temporal Anomaly Detection repository, there will be three different folders consisting of sub-folders that consist of figures (comprised of a time-series plot of
the eigenvalue vectors and an outlier detection signals plot) that correspond to each NumPy array in the MDIVI experimental group and were generated with different 'window,'and
'threshold' values.

These three folders will be titled **"threshold = 2.0"**,**"threshold = 2.5,"** and **"threshold = 3.0"** as I experimented with these three threshold values. Within each of these three folders, I experiment with different
window sizes **(15,20,50)** and there will be different sub-folders titled with the corresponding window.

url: https://raw.githubusercontent.com/quinngroup/ornet-reu-2021/a273df4f53f663078371200f0c57bf320254d589/MDIVI/Weighted Average Temporal Anomaly Detection/README.MD


text:
# BrightID Node

BrightID nodes store the social graph used by [BrightID](https://github.com/BrightID/BrightID).

* [BrightID's API doc and test interface](https://app.swaggerhub.com/apis-docs/brightid/brightid/)
* [Running a node.](https://github.com/BrightID/BrightID-Node/wiki/Installation-Guide)

## Contribute

Many issues have [bounties assigned](https://github.com/orgs/BrightID/projects/2?card_filter_query=label%3A%22bounty+%F0%9F%92%8E%22), paid in [BrightID Subs tokens](https://uniswap.info/token/0x61ceac48136d6782dbd83c09f51e23514d12470a). [Apply to our keybase](https://keybase.io/team/brightid) to start contributing.

[• Project Board](https://github.com/orgs/BrightID/projects/2) [• All Repos](https://github.com/BrightID)

### Dev Setup

Use the [development guide](https://github.com/BrightID/BrightID-Node/wiki/Development-Guide) to setup a development environment and workflow.

license: ISC

repository: crisog/BrightID-Node

repo_name: crisog/BrightID-Node


text:
- Pokémon World Online - Server Basic Setup

Welcome to our README.md ~ Note that currently most usernames are free without a password, Only less than 50 accounts have been registered.

This guide will help you on setting up you're very own pokemon world online server.

................................................................................................
Requirements: 'Node.js command prompt' ~ https://nodejs.org/en/ ~ Download for Windows (x86) Latest-Version: 6.9.2 Supported: 5.7.0 at the least.

( Step-1 ) your computers folder path

> cd C:\Users\%Username%\Downloads\pokemon-world-server-master\pokemon-world-server (default path)

( Step-2 ) Press Win + R (Win: 4 Flags Key Between Ctrl + Alt) and type cmd.exe in the Run Box
> cd current_server_path (From Step-1)

> npm install --server

( Step-3 ) Starting up your server on your end (localhost.psim.online) for local testing, Just search "what is my IP" for global IP.

> node app.js OR node app (.js extention is optional)

Let's help you open a port so you're freinds can join you're server heres an easy to help instruction below!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
README GUIDE: http://www.howtogeek.com/66214/how-to-forward-ports-on-your-router/
YOUTUBE GUIDE: https://www.youtube.com/results?search_query=how-to-forward-ports-on-your-router
PORT-CHECK See if the ports 'open' or 'closed' : http://www.yougetsignal.com/tools/open-ports/ - Can also get IP here.
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Great. After doing the above processes... You want to become owner right follow steps below

Open your server files, go to config, add a file called usergroups.csv, Add in the file ``YOURNAME,~`` to grant you admin.

Once done save the file and restart the server, Job done you can now run a server with us.

repository: KewlStatics/pokemon-world-server

repo_name: KewlStatics/pokemon-world-server


text:
Wifi Signal Strength Meter

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

This application can be used to measure the strength of WiFi signals that your device is receiving. Move around as you do this, and the app keeps track of signal variations as you move, second by second. Find the best spot, and forget buffering and lagging video calls!

-----------------------------------------
### Inspiration

* Internet has become an essential part of our life, these days, everyone want faster internet. WiFi technology uses radio waves to provide internet connectivity. It’s one of the most ubiquitous and standardized access point in the world of technology.

* Wi-Fi signal strength depends on a variety of factors, such as how far you are from the router, whether it’s a 2.4 or 5ghz connection, and even the materials of the walls around you. The closer you are to the router, the better.

* This application can be used to measure the strength of WiFi signals that your device is receiving. A stronger Wi-Fi signal means a more reliable connection. This is what enables you to take full advantage of the internet speeds available to you.

------------------------------------------
### Features

- `Detect nearby WiFi networks` : Get a list of nearby WiFi networks. WiFi will be turned on automatically when you open the app. Turn on Location on your device and press 'SCAN'.
- `Get details of the connected WiFI network` : Connect to a WiFi network and press 'GET INFO' to get the details of the network such as Network id, SSID, BSSID, Link Speed, Frequency, and IP address.
- `Measure signal strength` : The app displays the signal strength of the network to which the device is connected every second for a period of 1 minute or until you press 'STOP'. The average signal strength at the end of 1 minute is also displayed. The signal measurement is not converted to %, and you get raw data in dBm. dBm is typically expressed as a negative number. The closer to zero the reading is, the stronger the signal. So for example, -79 dBm is a stronger signal than -88 dBm.
- `Save the results` : Store the details of the network and the entire signal strength log in a txt file for future reference.
- `Load a saved file` : Load a previously saved log file from within the app itself.

------------------------------------------
### Demo

------------------------------------------
### Installation
* For Usage
    * Download the [`Wifi_Signal_Strength_Meter.apk`](./Wifi_Signal_Strength_Meter.apk) and install it on your device.
    * Grant 'Storage' and 'Location' permission to the app.

* For Development
    * Clone the repo
    ```sh
        $ git clone https://github.com/mihir-m-gandhi/WiFi-Signal-Strength-Meter
    ```
    * Open `Code` folder in Android Studio.

------------------------------------------
### Author
Mihir Gandhi - [mihir-m-gandhi](https://github.com/mihir-m-gandhi)

------------------------------------------
### License
This project is licensed under the MIT - see the [LICENSE](./LICENSE) file for details.


text:
# Transduce
[![Build Status](https://secure.travis-ci.org/transduce/transduce.svg)](http://travis-ci.org/transduce/transduce)

Transducers for JavaScript.

> Transducers are composable algorithmic transformations. They are independent from the context of their input and output sources and specify only the essence of the transformation in terms of an individual element. Because transducers are decoupled from input or output sources, they can be used in many different processes - collections, streams, channels, observables, etc. Transducers compose directly, without awareness of input or creation of intermediate aggregates.

http://clojure.org/transducers

If you are not familiar with transducers, check out [Transducers Explained][3].

### Install and Usage

```bash
$ npm install transduce
```

#### Browser

```bash
$ bower install transduce
```

* [Development](https://raw.githubusercontent.com/transduce/transduce/master/build/transduce.js)
* [Minified](https://raw.githubusercontent.com/transduce/transduce/master/build/transduce.min.js)

Structured to allow creation of custom builds by loading only desired libs.  For example, the base build contains only top-level `core` and `transducers`:

* [Base Development](https://raw.githubusercontent.com/transduce/transduce/master/build/transduce.base.js)
* [Base Minified](https://raw.githubusercontent.com/transduce/transduce/master/build/transduce.base.min.js)

#### Explicit Require and Custom Bundles

Collected as a convenience for an aggregated API. Any function or transducer below can be bundled separately in browserify builds by requiring with path from `transduce`.

What does this mean? You can require the whole thing:

```javascript
var tr = require('transduce')
tr.into([], [1,2,3,4,5,6])
// [1,2,3,4,5,6]

tr.into('', [1,2,3,4,5,6])
// '123456'

tr.into([], tr.filter(isEven), [1,2,3,4,5,6])
// [2,4,6]

tr.into([], tr.cat, [[1,2],[3,4],[5,6]])
// [1,2,3,4,5,6])

tr.into({}, [[1,2],[3,4],[5,6]])
// {1:2,3:4,5:6}

var transducer = tr.compose(tr.cat, tr.array.unshift(0), tr.map(add(1)))
tr.into([], transducer, [[1,2],[3,4],[5,6]])
// [1,2,3,4,5,6,7]
```

If you want to be reduce bundle size (or just like to be explicit), require packages with path from `transduce`.

```javascript
  var core = require('transduce/core'),
      transducers = require('transduce/transducers'),
      array = require('transduce/array')
  var transducer = core.compose(transducers.cat, array.unshift(0), transducers.map(add(1)))
  base.into([], transducer, [[1,2],[3,4],[5,6]])
  // [1,2,3,4,5,6,7]
```

### Definitions

##### Input Source
A source of values, normally a collection, `coll`.  This library supports arrays, plain objects, strings, and anything that can be converted to iterators (see `iterator` function below).

##### Reducing Function
A two arity function, `rf`, appropriate for passing to `reduce`. The first argument is the accumulator and the second argument is the iteration value.  When using transducers, the accumulator is normally a collection, but it is not required.

##### Initial Value
The initial accumulator value, `init` to use with Reduce.

##### Transformer
An object that provides a reducing function, `@@transducer/step`, initial value function, `@@transducer/init`, and result extraction function, `@@transducer/result`.  Combines the steps of reduce into a single object.

##### Reduce
A function that folds over an input source to produce an Output Source.  Accepts a Reducing Function or Transformer, `xf`, as the first argument, an optional initial value, `init`, as the second argument and an Input Source, `coll` as the third argument.

Also known as `foldLeft` or `foldl` in other languages and libraries.

The function begins with calling the Reducing Function of `xf`, `@@transducer/step`, with the initial accumulator, `init`, and the first item of Input Source, `coll`.  The return value from the reducing function is used as the next accumulator with the next item in `coll`. The process repeats until either `coll` is exhausted or `xf` indicates early termination with `reduced`. Finally, the result extraction function of `xf`, `@@transducer/result`, is called with the final accumulator to perform potentially delayed actions and optionally convert the accumulator to the Output Source.

Reduce defines a Transducible Process.

##### Transducer
A function, `t`, that accepts a transformer, `xf`, and returns a transformer. All transformations are defined in terms of transducers, independent of the Transducible Process. Can be composed directly to create new transducers.

##### Transducible Process
A process that begins with an initial value accumulator, steps through items of an input source and optionally transforming with transducer, `t`, and optionally completes with a result.  Transduce is one transducible process. Transducible Processes can also be push based. See [transduce-stream][2] for an example.  The same transducer can be used with any transducible process.

### API

Supports the following functions:

```javascript
// core
into: function(init, t?, coll?)
reduce: function(xf, init?, coll)
transduce: function(t, xf, init?, coll)
eduction: function(t, coll)
sequence: function(t, value)

compose: function(/*fns*/)
isReduced: function(value)
reduced: function(value, force?)
unreduced: function(value)

completing: function(rf, result?)
transformer: function(value)
iterable: function(value)
iterator: function(value)
transducer: function(step?, result?, init?)

protocols: {
  iterator: Symbol.iterator || '@@iterator'
  transducer: {
    init: '@@transducer/init',
    step: '@@transducer/step',
    result: '@@transducer/result',
    reduce: '@@transducer/reduce',
    reduced: '@@transducer/reduced',
    value: '@@transducer/value'
  }
}

// transducers
map: function(f)
filter: function(predicate)
remove: function(predicate)
take: function(n)
takeWhile: function(predicate)
drop: function(n)
dropWhile: function(predicate)
cat: transducer
mapcat: function(f)
partitionAll: function(n)
partitionBy: function(f)
dedupe: function()
unique: function(f?)
tap: function(interceptor)

array {
  forEach: function(callback)
  find: function(predicate)
  push: function(/*args*/)
  unshift: function(/*args*/)
  every: function(predicate)
  some: function(predicate)
  contains: function(target)
  slice: function(begin?, end?)
  initial: function(n?)
  last: function(n?)
}

math {
  min: function(f?)
  max: function(f?)
}

string {
  split: function(separator, limit?)
  join: function(separator)
  nonEmpty: function()
  lines: function(limit?)
  chars: function(limit?)
  words: function(delimiter?, limit?)
}
```

#### Core

Core functionality mixed into `transduce` directly or available by explictly requiring from `transduce/core`.  The following are equivalent:

- `require('transduce').into`
- `require('transduce/core').into`

##### into(init, t?, coll?)
Returns a new collection appending all items into `init` by passing all items from source collection `coll` through the optional transducer `t`.  Chooses transformer, `xf` from type of `init`.  Can be array, object, string or have `@@transformer`. `coll` is converted to an `iterator`.

The function is automatically curried. If `coll` is not provided, returns a curried function using `transformer` from `init` and the same transformation can be used for multiple collections.

```javascript
var tr = require('transduce')

// init, t and coll provided
tr.into([], tr.filter(isEven), [1,2,3,4,5,6]) // [2,4,6]

// init and coll, no t
tr.into([], [1,2,3,4,5,6]) // [1,2,3,4,5,6]
tr.into('hi ', [1,2,3,4,5,6]) // 'hi 123456'

// Curry on init
var toArray = tr.into([])
toArray([1,2,3]) // [1,2,3]
toArray(tr.map(add(1)), [1,2,3]) // [2,3,4]

// Curry on init and t
var add1 =  into([], tr.map(add(1)))
var add1 =  toArray(tr.map(add(1)))
add1([1,2,3]) // [2,3,4])

// Iterator coll
toArray(range(1,4)) // [1,2,3])
var add2 = toArray(tr.map(add(2)))
add2(range(3)) // [2,3,4])

// Object coll
var toObject = tr.into({})
toObject([['a', 'b'], ['b', 'c']]) // {a: 'b', b: 'c'})
var part2 = toObject(tr.partitionAll(2))
part2(['a', 'b', 'b', 'c']) // {a: 'b', b: 'c'})
```

##### reduce(xf, init?, coll)
Reduces over a transformation. If `xf` is not a `transformer`, it is converted to one using `completing`. Arrays are special cased to reduce using for loop and to allow transducers using `reduced`.  If `coll` has a `'@@transducer/reduce'` method, it is called with `xf.step` and `init`. Otherwise,`coll` is converted to an `iterator`.  If the function is called with arity-2, the `xf.init()` is used as the `init` value.

##### transduce(t, xf, init?, coll)
Transduces over a transformation. The transducer `t` is initialized with `xf` and is passed to `reduce`. `xf` is converted to a `transformer` if it is not one already using `completing`. If the function is called with arity-3, the `xf.init()` is used as the `init` value.

##### eduction(t, coll)
Creates an iterable and reducible application of the collection `coll` transformed by transducer`t`.  The returned eduction will be iterable using `sequence` and have a `['@@transducer/reduce'](rf, init)` method using `transduce`.

##### sequence(t, value)
Create an ES6 Iterable by transforming an input source using transducer `t`.

##### compose(/\*fns\*/)
Simple function composition of arguments. Useful for composing (combining) transducers.

##### isReduced(value)
Is the value reduced? (signal for early termination)

##### reduced(value, force?)
Ensures the value is reduced (useful for early termination). If `force` is not provided or `false`, only wraps with Reduced value if not already `isReduced`.  If `force` is `true`, always wraps value with Reduced value.

##### unreduced(value)
Ensure the value is not reduced (unwraps reduced values if necessary)

##### completing(rf, result?)
Lifts a reducing function, `rf`, into a transformer, `xf`.  Uses `identity` if `result` function is not provided. The `init` function calls `rf` with no arguments.

##### transformer(value)
Attempts to convert the parameter into a transformer.  If cannot be converted, returns `undefined`.  If defined, the return value will have `init`, `step`, `result` functions that can be used for transformation.  Converts arrays, strings, objects, functions (`completing`) or anything that follows the transformer protocol into a transformer.

Objects support pairs or objects. If `item` is an array of length 2, uses first (0 index) as the key and the second (1 index) as the value.  Otherwise iterates over own properties of items and merges values with same keys into the result object.

If `value` is `undefined`, returns a transformer that maintains the last value and does not buffer results. Ignores the accumulator and returns the input on every `step`. The `init` value will be `undefined`.

##### iterable(value)
Returns the iterable for the parameter, returning if has an iterator protocol or wrapping in proper iterable if has a next method. Returns `undefined` if cannot create an iterator.

Converts arrays to iterables over each indexed item. Converts to functions to infinite iterables that always call function on next. Converts objects to iterables of key, value pairs.

The iterable is an object that has a function identified by `protocols.iterator` that should be called with no args and returns an iterator object that has a `next` method to cycle through the iterator.

##### iterator(value)
Returns an iterator for the value, shorthand for calling `iterable(value)[protocols.iterator]()`

##### isIterable(value)
Returns `true` if a value fulfills the iterator protocol, also returning true for `Array` and `String` as these types both implement the iterator protocol in ES6.

##### isIterator(value)
Returns `true` if a value is an iterator, defined an object with a `next` function.

##### protocols.iterator
Symbol (or a string that acts as symbols) for `@@iterator` you can use to configure your custom objects.

##### protocols.transducer
String that acts as symbols for supporting the transducer protocol. Used to define transformers and reduced values.

##### transducer(step?, result?, init?)
Creates a transducer from a reducing function, `step`, result extraction function `result` and initial value function `init`.  If any function is `null` or `undefined`, default is to forward directly to wrapped transformer.

The `@@transducer/step` function of the resulting transformer calls `step(xfStep, result, input)` bound to a transducer instance, where `xfStep` calls `step` on the wrapped transformer. The `init` and `result` functions behave similarly.

All functions are called with a bound to a transducer instance (`this` parameter) that contains `init`, `step` and `result` functions that forward to wrapped transformer. The context can be used to implement stateful transducers.

```javascript
// Map from a step function
function map(callback) {
  return transducer(function(xfStep, value, input) {
    return xfStep(value, callback(input))
  })
}

// using reduced
function takeWhile(p){
  return transducer(function(xfStep, value, input){
    return p(input) ? xfStep(value, input) : reduced(value)
  })
}

// using context for stateful transducers
function drop(n){
  return transducer(function(xfStep, value, item){
    if(this.n === void 0) this.n = n
    return (--this.n < 0) ? xfStep(value, item) : value
  })
}

// using custom result
function some(predicate) {
  return transducer(
    function(xfStep, value, input){
      if(predicate(input)){
        this.found = true
        return reduced(xfStep(value, true))
      }
      return value
    },
    function(xfResult, value){
      if(!this.found){
        value = this.xfStep(value, false)
      }
      return xfResult(value)
    })
}
```

#### Transducers
Common transducers mixed into `transduce` directly or available by explictly requiring from `transduce/transducers`. The following are equivalent:
- `require('transduce').map`
- `require('transduce/transducers).map`

##### map(f)
Transducer that steps all items after applying a mapping function `f` to each item.

##### filter(predicate)
Transducer that steps items which pass predicate test.

##### remove(predicate)
Transducer that removes all items that pass predicate.

##### take(n)
Transducer that steps first `n` items and then terminates with `reduced`.

##### takeWhile(predicate)
Transducer that take items until predicate returns true. Terminates with reduce when predicate returns true.

##### drop(n)
Transducer that drops first `n` items and steps remaining untouched.

##### dropWhile(predicate)
Transducer that drops items until predicate returns true and steps remaining untouched.

##### cat
Concatenating transducer.  Reducing over every item in the transformation using provided transformer.

##### mapcat(mappingFunction)
Transducer that applies a `mappingFunction` to each item, then concatenates the result of the mapping function.  Same is `compose(map(mappingFunction), cat)`

##### partitionAll(n?)
Partitions the source into arrays of size `n`. When transformer completes, the transformer will be stepped with any remaining items. If `n` is not provided or size `0` it will collect all values and step with this value.

##### partitionBy(f)
Partitions the source into sub arrays when the value of the function `f` changes equality.  When transformer completes, the transformer will be stepped with any remaining items.

##### dedupe()
Removes consecutive duplicates from the transformation. Subsequent stepped values are checked for equality using `===`.

##### unique(f?)
Produce a duplicate-free version of the transformation. If `f` is passed, it will be called with each item and the return value for uniqueness check.  Uniqueness is checked across all values already seen, and as such, the items (or computed checks) are buffered.

##### tap(interceptor)
Transducer that invokes interceptor with each result and input, and then passes through input. The primary purpose of this method is to "tap into" a method chain, in order to perform operations on intermediate results within the chain.  Executes interceptor with current result and input.

##### interpose(separator)
Transducer that places separator between each stepped value.

#### Array
Use Array methods as Transducers.  Treats each stepped item as an item in the array, and defines transducers that step items with the same contract as array methods.

Mixed into `transduce.array` or available by explictly requiring from `transduce/array`.  The following are equivalent:

- `require('transduce').array.forEach`
- `require('transduce/array').forEach`

##### array.forEach(callback)
Passes every item through unchanged, but after executing `callback(item, idx)`.  Can be useful for "tapping into" composed transducer pipelines.   The return value of the callback is ignored, item is passed unchanged.

##### array.find(predicate)
Like filter, but terminates transducer pipeline with the result of the first item that passes the predicate test. Will always step either 0 (if not found) or 1 (if found) values.

##### array.push(/\*args\*/)
Passes all items straight through until the result is requested.  Once completed, steps every argument through the pipeline, before returning the result.  This effectively pushes values on the end of the stream.

##### array.unshift(/\*args\*/)
Before stepping the first item, steps all arguments through the pipeline, then passes every item through unchanged.  This effectively unshifts values onto the beginning of the stream.

##### array.every(predicate)
Checks to see if every item passes the predicate test.  Steps a single item `true` or `false`.  Early termination on `false`.

##### array.some(predicate)
Checks to see if some item passes the predicate test.  Steps a single item `true` or `false`.  Early termination on `true`.

##### array.contains(target)
Does the stream contain the target value (`target === item`)? Steps a single item `true` or `false`. Early termination on `true`.

##### array.slice(begin?, end?)
Like array slice, but with transducers.  Steps items between `begin` (inclusive) and `end` (exclusive).  If either index is negative, indexes from end of transformation.  If `end` is undefined, steps until result of transformation. If `begin` is undefined, begins at 0.

Note that if either index is negative, items will be buffered until completion.

##### array.initial(n?)
Steps everything but the last entry. Passing `n` will step all values excluding the last N.

Note that no items will be sent and all items will be buffered until completion.

##### array.last(n?)
Step the last element. Passing `n` will step the last N  values.

Note that no items will be sent until completion.

#### Math

Mixed into `transduce.math` or available by explictly requiring from `transduce/math`.  The following are equivalent:

- `require('transduce').math.min`
- `require('transduce/math').min`

##### math.min(f?)
Steps the minimum value on the result of the transformation. if `f` is provided, it is called with each item and the return value is used to compare values. Otherwise, the items are compared as numbers

#####  math.max(f?)
Steps the maximum value on the result of the transformation. if `f` is provided, it is called with each item and the return value is used to compare values. Otherwise, the items are compared as numbers

#### String
Transduce over sequences of strings. Particularly useful with [transduce-stream][2].

Treats every item as a substring, and splits across the entire transducer sequence.  This allows functions to work with chunks sent through streams.  When using transducers with streams, it is helpful to compose the transformation that you want with one of these functions to operate against a given line/word/etc.

Mixed into `transduce.string` or available by explictly requiring from `transduce/string`.  The following are equivalent:

- `require('transduce').string.split`
- `require('transduce/string').split`

##### string.split(separator, limit?)
Works like `''.split` but splits across entire sequence of items. Accepts separator (String or RegExp) and optional limit of words to send.

##### string.join(separator)
Buffers all items and joins results on transducer `result`.

##### string.nonEmpty()
Only steps items that are non empty strings (`input.trim().length > 0`).

##### string.lines(limit?)
Split chunks into lines and steps each line with optional limit (number of lines).

##### string.chars(limit?)
Split chunks into characters and steps each char with optional limit (number of chars).

##### string.words(delimiter?, limit?)
Split chunks into words using `delimiter` (default `/\s+/`) and steps each word with optional limit (number of words).

### Credits

Extracted from [underarm][6], which was created initially as a translation from [Clojure][8]. Now compatible with and inspired by protocols defined by [transducers-js][4] and [transducers.js][5].

### License
MIT

[1]: https://github.com/transduce
[2]: https://github.com/transduce/transduce-stream
[3]: http://simplectic.com/blog/2014/transducers-explained-1/
[4]: https://github.com/cognitect-labs/transducers-js
[5]: https://github.com/jlongster/transducers.js
[6]: https://github.com/kevinbeaty/underarm
[7]: http://simplectic.com/projects/underarm
[8]: http://clojure.org/transducers
[10]: https://github.com/jlongster/transducers.js#the-transformer-protocol

repository: transduce/transduce

gha_language: JavaScript

repo_name: transduce/transduce


text:
# Operationalizing Istio

In this second of a two-part series of workshops on Istio service mesh, we dig into how to “day 2” Istio in your organization to improve speed of delivery and reduce mean time to recovery (MTTR). We focus on things like integrating with CI/CD and observability tooling, zero-downtime control-plane upgrades, how to rotate certs and integrate with PKI, running on VMs, and ending with multi-cluster deployments.

We've cultivated a lot of this knowledge from working organizations across the world and helping them operationalize Istio.  We cover the following topics in this second workshop:

* Automating config with Fluxcd and Flagger
* Integrate with APM/observability tools
* Certificate rotation and PKI integration
* Bridging to VMs
* Multi-cluster deployments

## This workshop is currently WIP/Coming Soon


text:
# destiny2_api.model.DestinyDefinitionsDestinyActivityChallengeDefinition

## Load the model package
```dart
import 'package:destiny2_api/api.dart';
```

## Properties
Name | Type | Description | Notes
------------ | ------------- | ------------- | -------------
**objectiveHash** | **int** | The hash for the Objective that matches this challenge. Use it to look up the DestinyObjectiveDefinition. | [optional] [default to null]
**dummyRewards** | [**List<DestinyDestinyItemQuantity>**](DestinyDestinyItemQuantity.md) | The rewards as they're represented in the UI. Note that they generally link to \"dummy\" items that give a summary of rewards rather than direct, real items themselves.  If the quantity is 0, don't show the quantity. | [optional] [default to []]

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

gha_language: Dart


text:
---
title:  "Hello World, v3"
date:   2017-08-06 15:00:00
excerpt: "Fifteen years of occasional blogging"
categories:
  - blog
tags:
  - Jekyll
  - update
---
When I started blogging in 2004 I used [Geeks with Blogs](http://geekswithblogs.net/jwatson/Default.aspx) later moving on to [Blogger](http://pragmatic-software.blogspot.com/) in 2008. Fast forward to 2017 and I'm now working with [GitHub Pages](https://pages.github.com/) using [Jekyll](https://jekyllrb.com/) for static content generation.

gha_language: HTML


text:
# B-Tree
A single-file high performance B+ Tree, with LRU cache in memory to boost the performance.
## Use
bptree::LRUBPTree has integrated LRU cache in it. You can include `LRUBPTree.h` to use it.
- search(K): search specified key and return std::pair<KeyType,bool>. Not found if `pair->second` is False.
- insert(K, V): insert a pair of data
- remove(K): remove the pair with the specified key
- range(K_low, K_high): get a range of data subject to K_low <= key <= K_high

repository: XOR-op/B-Tree

repo_name: XOR-op/B-Tree


text:
# Kurunt UDP Input

## Performance Note

The UDP protocol is designed for performance not reliable delivery. If reliable delivery is important to you, use the TCP input, which guarantees deliver.

During benchmarking the UDP input will loose messages. For example:

```
/kurunt/lib/workers/string$ perl client.pl -T=udp -P=7001 -m=10000 -c=10 -d=''
```
This should send and process 100,000 messages, however only around 40,000 to 50,000 messages actually get processed. Under smaller loads all messages get processed. However using the TCP input, all messages get processed.

Because the UDP protocol sends/receives one message at a time it actually performs slower than the TCP input under load because the TCP protocol uses batching.

repository: modeneis/kurunt

repo_name: modeneis/kurunt