text:
OpenAttack

  Documentation • Features & Uses • Usage Examples • Attack Models • Toolkit Design

OpenAttack is an open-source Python-based textual adversarial attack toolkit, which handles the whole process of textual adversarial attacking, including preprocessing text, accessing the victim model, generating adversarial examples and evaluation.

![demo](./docs/source/images/demo.gif)

## Features & Uses

OpenAttack has following features:

1. **High usability.** OpenAttack provides easy-to-use APIs that can support the whole process of textual adversarial attacks;
2. **Full coverage of attack model types**. OpenAttack supports sentence-/word-/character-level perturbations and gradient-/score-/decision-based/blind attack models;
3. **Great flexibility and extensibility**. You can easily attack a customized victim model or develop and evaluate a customized attack model;
4. **Comprehensive Evaluation**. OpenAttack can thoroughly evaluate an attack model from attack effectiveness, adversarial example quality and attack efficiency.

OpenAttack has a wide range of uses, including:

1. Providing various handy baselines for attack models;
2. Comprehensively evaluating attack models using its thorough evaluation metrics;
3. Assisting in quick development of new attack models with the help of its common attack components;
4. Evaluating the robustness of a machine learning model against various adversarial attacks;
5. Conducting adversarial training to improve robustness of a machine learning model by enriching the training data with generated adversarial examples.

## Installation

You can either use `pip` or clone this repo to install OpenAttack.

#### 1. Using pip (recommended)

```bash
pip install OpenAttack
```

#### 2. Cloning this repo

```bash
git clone https://github.com/thunlp/OpenAttack.git
cd OpenAttack
python setup.py install
```

After installation, you can try running `demo.py` to check if OpenAttack works well:

```
python demo.py
```

## Usage Examples

#### Basic: Use Built-in Attacks

OpenAttack builds in some commonly used text classification models such as LSTM and BERT as well as datasets such as [SST](https://nlp.stanford.edu/sentiment/treebank.html) for sentiment analysis and [SNLI](https://nlp.stanford.edu/projects/snli/) for natural language inference. You can effortlessly conduct adversarial attacks against the built-in victim models on the datasets.

The following code snippet shows how to use a genetic algorithm-based attack model ([Alzantot et al., 2018](https://www.aclweb.org/anthology/D18-1316.pdf)) to attack BERT on the SST dataset:

```python
import OpenAttack as oa
# choose a trained victim classification model
victim = oa.DataManager.load("Victim.BERT.SST")
# choose an evaluation dataset
dataset = oa.DataManager.load("Dataset.SST.sample")
# choose Genetic as the attacker and initialize it with default parameters
attacker = oa.attackers.GeneticAttacker()
# prepare for attacking
attack_eval = oa.attack_evals.DefaultAttackEval(attacker, victim)
# launch attacks and print attack results
attack_eval.eval(dataset, visualize=True)
```

#### Advanced: Attack a Customized Victim Model

The following code snippet shows how to use the genetic algorithm-based attack model to attack a customized sentiment analysis model (a statistical model built in NLTK) on SST.

```python
import OpenAttack as oa
import numpy as np
from nltk.sentiment.vader import SentimentIntensityAnalyzer

# configure access interface of the customized victim model
class MyClassifier(oa.Classifier):
    def __init__(self):
        self.model = SentimentIntensityAnalyzer()
    # access to the classification probability scores with respect input sentences
    def get_prob(self, input_):
        rt = []
        for sent in input_:
            rs = self.model.polarity_scores(sent)
            prob = rs["pos"] / (rs["neg"] + rs["pos"])
            rt.append(np.array([1 - prob, prob]))
        return np.array(rt)
# choose the costomized classifier as the victim model
victim = MyClassifier()
# choose an evaluation dataset
dataset = oa.DataManager.load("Dataset.SST.sample")
# choose Genetic as the attacker and initialize it with default parameters
attacker = oa.attackers.GeneticAttacker()
# prepare for attacking
attack_eval = oa.attack_evals.DefaultAttackEval(attacker, victim)
# launch attacks and print attack results
attack_eval.eval(dataset, visualize=True)
```

#### Advanced: Design a Customized Attack Model

OpenAttack incorporates many handy components which can be easily assembled into new attack model.

[Here](./examples/custom_attacker.py) gives an example of how to design a simple attack model which shuffles the tokens in the original sentence.

#### Advanced: Adversarial Training

OpenAttack can easily generate adversarial examples by attacking instances in the training set, which can be added to original training data set to retrain a more robust victim model, i.e., adversarial training.

[Here](./examples/adversarial_training.py)  gives an example of how to conduct adversarial training with OpenAttack.

#### Advanced: Design a Customized Evaluation Metric

OpenAttack supports designing a customized adversarial attack evaluation metric.

[Here](./examples/custom_eval.py)  gives an example of how to add BLEU score as a customized evaluation metric to evaluate adversarial attacks.

## Attack Models

According to the level of perturbations imposed on original input, textual adversarial attack models can be categorized into sentence-level, word-level, character-level attack models.

According to the accessibility to the victim model, textual adversarial attack models can be categorized into `gradient`-based, `score`-based, `decision`-based and `blind` attack models.

> [TAADPapers](https://github.com/thunlp/TAADpapers) is a paper list which summarizes almost all the papers concerning textual adversarial attack and defense. You can have a look at this list to find more attack models.

Currently OpenAttack includes 13 typical attack models against text classification models that cover **all** attack types.

Here is the list of currently involved attack models.

- Sentence-level
  - (SEA) **Semantically Equivalent Adversarial Rules for Debugging NLP Models**. *Marco Tulio Ribeiro, Sameer Singh, Carlos Guestrin*. ACL 2018. `decision` [[pdf](https://aclweb.org/anthology/P18-1079)] [[code](https://github.com/marcotcr/sears)]
  - (SCPN) **Adversarial Example Generation with Syntactically Controlled Paraphrase Networks**. *Mohit Iyyer, John Wieting, Kevin Gimpel, Luke Zettlemoyer*. NAACL-HLT 2018. `blind` [[pdf](https://www.aclweb.org/anthology/N18-1170)] [[code&data](https://github.com/miyyer/scpn)]
  - (GAN) **Generating Natural Adversarial Examples**. *Zhengli Zhao, Dheeru Dua, Sameer Singh*. ICLR 2018. `decision` [[pdf](https://arxiv.org/pdf/1710.11342.pdf)] [[code](https://github.com/zhengliz/natural-adversary)]
- Word-level
  - (SememePSO) **Word-level Textual Adversarial Attacking as Combinatorial Optimization**. *Yuan Zang, Fanchao Qi, Chenghao Yang, Zhiyuan Liu, Meng Zhang, Qun Liu and Maosong Sun*. ACL 2020. `score` [[pdf](https://www.aclweb.org/anthology/2020.acl-main.540.pdf)] [[code](https://github.com/thunlp/SememePSO-Attack)]
  - (TextFooler) **Is BERT Really Robust? A Strong Baseline for Natural Language Attack on Text Classification and Entailment**. *Di Jin, Zhijing Jin, Joey Tianyi Zhou, Peter Szolovits*. AAAI-20. `score` [[pdf](https://arxiv.org/pdf/1907.11932v4)] [[code](https://github.com/wqj111186/TextFooler)]
  - (PWWS) **Generating Natural Language Adversarial Examples through Probability Weighted Word Saliency**. *Shuhuai Ren, Yihe Deng, Kun He, Wanxiang Che*. ACL 2019. `score` [[pdf](https://www.aclweb.org/anthology/P19-1103.pdf)] [[code](https://github.com/JHL-HUST/PWWS/)]
  - (Genetic) **Generating Natural Language Adversarial Examples**. *Moustafa Alzantot, Yash Sharma, Ahmed Elgohary, Bo-Jhang Ho, Mani Srivastava, Kai-Wei Chang*. EMNLP 2018. `score` [[pdf](https://www.aclweb.org/anthology/D18-1316)] [[code](https://github.com/nesl/nlp_adversarial_examples)]
  - (FD) **Crafting Adversarial Input Sequences For Recurrent Neural Networks**. *Nicolas Papernot, Patrick McDaniel, Ananthram Swami, Richard Harang*. MILCOM 2016. `gradient` [[pdf](https://arxiv.org/pdf/1604.08275.pdf)]
- Word/Char-level
  - (UAT) **Universal Adversarial Triggers for Attacking and Analyzing NLP.** *Eric Wallace, Shi Feng, Nikhil Kandpal, Matt Gardner, Sameer Singh*. EMNLP-IJCNLP 2019. `gradient` [[pdf](https://arxiv.org/pdf/1908.07125.pdf)] [[code](https://github.com/Eric-Wallace/universal-triggers)] [[website](http://www.ericswallace.com/triggers)]
  - (TextBugger) **TEXTBUGGER: Generating Adversarial Text Against Real-world Applications**. *Jinfeng Li, Shouling Ji, Tianyu Du, Bo Li, Ting Wang*. NDSS 2019. `gradient` `score` [[pdf](https://arxiv.org/pdf/1812.05271.pdf)]
  - (HotFlip) **HotFlip: White-Box Adversarial Examples for Text Classification**. *Javid Ebrahimi, Anyi Rao, Daniel Lowd, Dejing Dou*. ACL 2018. `gradient` [[pdf](https://www.aclweb.org/anthology/P18-2006)] [[code](https://github.com/AnyiRao/WordAdver)]
- Char-level
  - (VIPER) **Text Processing Like Humans Do: Visually Attacking and Shielding NLP Systems**. *Steffen Eger, Gözde Gül ¸Sahin, Andreas Rücklé, Ji-Ung Lee, Claudia Schulz, Mohsen Mesgar, Krishnkant Swarnkar, Edwin Simpson, Iryna Gurevych*. NAACL-HLT 2019. `score` [[pdf](https://www.aclweb.org/anthology/N19-1165)] [[code&data](https://github.com/UKPLab/naacl2019-like-humans-visual-attacks)]
  - (DeepWordBug) **Black-box Generation of Adversarial Text Sequences to Evade Deep Learning Classifiers**. *Ji Gao, Jack Lanchantin, Mary Lou Soffa, Yanjun Qi*. IEEE SPW 2018. `score` [[pdf](https://ieeexplore.ieee.org/document/8424632)] [[code](https://github.com/QData/deepWordBug)]

Following table illustrates the comparison of the attack models.

|    Model    |  Accessibility  | Perturbation | Main Idea                                           |
| :---------: | :-------------: | :----------: | :-------------------------------------------------- |
|     SEA     |    Decision     |   Sentence   | Rule-based paraphrasing                             |
|    SCPN     |      Blind      |   Sentence   | Paraphrasing                                        |
|     GAN     |    Decision     |   Sentence   | Text generation by encoder-decoder                  |
| TextFooler  |      Score      |     Word     | Greedy word substitution                            |
|    PWWS     |      Score      |     Word     | Greedy word substitution                            |
|   Genetic   |      Score      |     Word     | Genetic algorithm-based word substitution           |
|     FD      |    Gradient     |     Word     | Gradient-based word substitution                    |
| TextBugger  | Gradient, Score |  Word+Char   | Greedy word substitution and character manipulation |
|     UAT     |    Gradient     |  Word, Char  | Gradient-based word or character manipulation       |
|   HotFlip   |    Gradient     |  Word, Char  | Gradient-based word or character substitution       |
|    VIPER    |      Blind      |     Char     | Visually similar character substitution             |
| DeepWordBug |      Score      |     Char     | Greedy character manipulation                       |

## Toolkit Design

Considering the significant distinctions among different attack models, we leave considerable freedom for the skeleton design of attack models, and focus more on streamlining the general processing of adversarial attacking and the common components used in attack models.

OpenAttack has 7 main modules:

* **TextProcessor**: processing the original text sequence so as to assist attack models in generating adversarial examples.
* **Classifier**: wrapping victim classification models
* **Attacker**: involving various attack models
* **Substitute**: packing different word/character substitution methods which are widely used in word- and character-level attack models.
* **Metric**: providing several adversarial example quality metrics which can serve as either the constraints on the adversarial examples during attacking or evaluation metrics for evaluating adversarial attacks.
* **AttackEval**: evaluating textual adversarial attacks from attack effectiveness, adversarial example quality and attack efficiency.
* **DataManager**: managing all the data as well as saved models that are used in other modules

repository: Feem/OpenAttack

repo_name: Feem/OpenAttack


text:
---
layout: post
title: "Back into the Engine"
date: 2019-07-30 13:32:23 -0600
categories: news,general
comments: true
---

I made my way back to work in engine. The [AeonGUI](https://github.com/AeonGames/AeonGUI) project is still going on, but I realized that it should serve the engine primarily, and I was worrying too much on it being standards compliant, and code complete when the reality is that getting such a project to the completeness I was envisioning is just as large a task as creating the game engine. Even if I made the agent as good as Chrome or Firefox, that does not guarantee that other people would use it or be interested in it. So instead of creating something for an imaginary client and **then** adapt that product into the engine, I figure to work on the GUI as needed by the engine, and keep both projects moving forward in parallel.

repository: AeonGames/AeonEngine

branch_name: refs/heads/master

extension: markdown

license_type: permissive

repo_name: AeonGames/AeonEngine


text:
# Natural Language Understanding API Samples

This directory contains sample code for using Natural Language Understanding API.

OLAMI website and documentation: [http://olami.ai](http://olami.ai)

## Build the application:

Run the following command in bash to build the test program *nluapi_test*.

```
make
```

## Run the application:

Replace **api_url, your_app_key, your_app_secret, your_text_input** in accordance to your needs and your own data.

```
./nluapi_test main.py api_url your_app_key your_app_secret your_text_input
```

- For example: (Simplified Chinese Request with the text "我爱欧拉蜜")

```
./nluapi_test https://cn.olami.ai/cloudservice/api 172c5b7b7121407ba572da444a999999 2115d0888bd049549581b7a0a6888888 我爱欧拉蜜
```

- For example: (Traditional Chinese Request with the text "我愛歐拉蜜")

```
./nluapi_test https://tw.olami.ai/cloudservice/api<PHONE_NUMBER>66555444333222111000aa<PHONE_NUMBER>44555666777888999000aa 我愛歐拉蜜
```

extension: md


text:
---
id: doc2
title: Installation
hide_title: false
hide_table_of_contents: false
---
It is necessary to have R installed in order to be able to run this code. R is a free software environment for statistical computing and graphics. It compiles and runs on a wide variety of UNIX platforms, Windows and MacOS. To [download R.](https://cran.r-project.org/mirrors.html), please choose your preferred [CRAN mirror.](https://cran.r-project.org/mirrors.html)

There are four main script files within the [**code on Github**](https://github.com/facebookexperimental/Robyn/tree/master/source):
1. ***fb__robyn_mmm_(...)func.R:*** Where all the model functions are stored.
2. ***fb__robyn_mmm_(...)exec.R:*** Where the functions above are executed. This will be the main script you will be working with.
3. ***fb__robyn_mmm_(...)plot.R:*** Where the functions to plot results are kept.
4. ***fb__robyn_mmm_(...)optm.R:*** Where the optimiser functions reside.

Please **download** and **open** all of them in your R environment.

license: MIT

repository: Erictwigeo/Robyn

repo_name: Erictwigeo/Robyn


text:
# ReadMe Generator
  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
  ## Description
  This Node application will use information obtained from command line prompts to generate a ReadMe.md file for a users project that can be copied to their GitHub project.
  ## Table of Contents
  * [Installation](#installation)
  * [Usage](#usage)
  * [License](#license)
  * [Contributions](#contributions)
  * [Testing](#testing)
  * [Questions](#questions)

  ## Installation
  Clone Rep, run Node Index in root directory

  ## Usage
  Using this node app will simplify the creation of a ReadMe.md file for a GitHub project.
  ## License
  * This application is covered under the MIT license
  ## Contributions
  Please contact to contribute

  ## Testing
  Please test and use npm init

  ## Questions
  Created by: prestonrl

  If you have questions please contact [prl<EMAIL_ADDRESS>

repository: prestonrl/readme-generator

branch_name: refs/heads/main

repo_name: prestonrl/readme-generator


text:
---
layout: post
date: 2019-08-27
title: Variational Inference of Normalizing Flows (Rezende & Shakir, 2015)
tags: [paper_summary]
mathjax: true
---

[Original paper link](http://proceedings.mlr.press/v37/rezende15.pdf)

# Normalizing Flows

![](\photos\shakir_danilo_slide.png){: style="width: 600px; height: auto;"}

**Key idea**: Assume a simple probability distribution, take a sample from it and then ___transform___ that sample. This is equivalent to change of variables in probability distributions and, if the transformation meets some mild conditions, can result in a very complex pdf of the transformed variable. The formalism of normalizing flows now gives us a systematic way of specifying the approximate posterior distributions $q(z\vert x)$ required for variational inference. (see [Inference in probabilistic models](/post/inf_prob_models/))

Example: If $f$ is monotonically increasing or monotonically decreasing function, such that $y = f(x)$, $x \sim p_{X}$, then we have:
\\[ p_{Y}(y)= \frac{d}{dy}\mathbb{P}(Y\leq y)= \frac{d}{dy}\mathbb{P}(f(X)\leq y)=\frac{d}{dy}\mathbb{P}(X\leq f^{-1}(y))=p_{X}(f^{-1}(y))\frac{df^{-1}(y)}{dy}=p_{X}(x)\frac{df^{-1}(y)}{dy},\\]
\\[ p_{Y}(y)= \frac{d}{dy}\mathbb{P}(Y\leq y)= \frac{d}{dy}\mathbb{P}(f(X)\leq y)=\frac{d}{dy}\mathbb{P}(X\geq f^{-1}(y))=-p_{X}(f^{-1}(y))\frac{df^{-1}(y)}{dy}=-p_{X}(x)\frac{df^{-1}(y)}{dy},\\]
respectively.

Similarly for multivariate invertible mappings $f:\mathbb{R}^{m}\mapsto \mathbb{R}^{m}$ and $X\sim p_{X}$, $Y=f(X)$, we get:

\\[\boxed{ p_{Y}(y)=p_{X}(x)\left\lvert \operatorname{det}\frac{df^{-1}(y)}{dy}\right\rvert =p_{X}(x)\left\lvert \operatorname{det}\frac{df(x)}{dy}\right\rvert^{-1} },\qquad complexity \rightarrow O(m^{3})\\]
where the last equality exploits the [property of jacobian of inverse functions](https://en.wikipedia.org/wiki/Inverse_function_theorem) (PS: invertibility of $f(\cdot)$ validates the use of this property) and $[ \mathrm{det}(A^{-1}) =\mathrm{det}(A)^{-1} ]$.

NFs are typically used to parametrise the approximate posterior $q(z\vert x)$ but can also be applied for the likelihood function. We can apply a series of mappings  $f_{k},~ k= \[ 1,\dots,K \]$ and obtain a normalizing flow:

$$ \mathbf{z}_K = f_K \circ \dots \circ f_1 (\mathbf{z}_0), \quad \mathbf{z}_0 \sim q_0(\mathbf{z}_0), $$

$$ \mathbf{z}_K \sim q_K(\mathbf{z}_K) = q_0(\mathbf{z}_0) \prod_{k=1}^K
  \left|
    \mathrm{det} \frac{
      \partial f_k
    }{
      \partial \mathbf{z}_{k-1}\
    }
  \right| ^{-1}, \quad or $$

  $$ \ln q_K (\mathbf{z}_K) = \ln q_0(\mathbf{z}_0) - \sum_{k=1}^{K} \ln \mathrm{det} \left|
     \frac{
      \partial f_k
    }{
      \partial \mathbf{z}_{k-1}\
    }
  \right|. $$

This series of transformations can transform a simple probability distribution (e.g. Gaussian) into a complicated multi-modal one. Note that after every mapping ($f_1, f_2, \dots $), the det-Jac has to be computed to ensure that the output is also a distribution. To be of practical use, however, we can consider only transformations whose determinants of Jacobians are easy to compute. The original paper considered two simple family of transformations, named planar and radial flows.

---

## Planar Flow
\\[ f(\mathbf{z}) = \mathbf{z} + \mathbf{u} h(\mathbf{w}^{\top} \mathbf{z} + b) \\]
with $\mathbf{U}, \mathbf{W}\in \mathbb{R}^{d}$ and $b\in \mathbb{R}$ and $h$ an element-wise non-linearity. Let $\psi (\mathbf{z}) = h' (\mathbf{w}^T \mathbf{z} + b) \mathbf{w}$. Then the determinant can be easily computed as

\\[ \left| \mathrm{det} \frac{\partial f}{\partial \mathbf{z}} \right| =
  \left| 1 + \mathbf{u}^{\top} \psi( \mathbf{z} ) \right| = \left| 1 + \mathbf{u}^{\top} h' (\mathbf{w}^T \mathbf{z} + b) \mathbf{w} \right| .  \\]
Since $0\leq h' \leq 1$ for $ h(x) = \tanh (x) $, we require $ \mathbf{u}^{\top}\mathbf{w} \geq -1$ for invertibility of such flows. We can think of planar flows as slicing the $\mathbf{z}$-space with straight lines (or hyperplanes), where each line contracts or expands the space around it, see figure 1 (in paper).

---

## Radial Flow
\\[  f(\mathbf{z}) = \mathbf{z} + \beta h(\alpha, r)(\mathbf{z} - \mathbf{z}_0),\\]

with $$r = \Vert\mathbf{z} - \mathbf{z}_0 \Vert_2 $$, $$h(\alpha, r) = \frac{1}{\alpha + r}$$ and parameters $$\mathbf{z}_0 \in \mathbb{R}^d, \alpha \in \mathbb{R}_+$$ and $$\beta \in \mathbb{R}$$.

Similarly to planar flows, radial flows introduce spheres in the $z$-space, which either contract or expand the space inside the sphere, see figure 1 (in paper).

---
### Algorithmic steps
Suppose the unknown target distribution is specified using energy functions $U(z)$, $p(z) = \frac{1}{\mathcal{Z}} \exp(-U(z))$, where $\mathcal{Z}$ is the unknown partition function (normalization constant); that is, $p(z) \propto \exp({-U(z)})$.

**Steps:**
1. Generate random samples from initial distribution $z_{0} \sim q_0 (z) = \mathcal{N}(z; \mu, \sigma^2 I)$.
   Here $\mu$ and $\sigma$ can either be fixed (such as standard Normal distribution) or can be estimated as follows:
   Draw auxillary random variable $\epsilon$ from standard normal distribution $\epsilon \sim \mathcal{N}(0, I)$ and apply linear normalizing flow transformation $f(\epsilon) = \mu + \sigma \epsilon$, re-parameterizing $\sigma = e^{(\frac{1}{2}*\log(var))}$ to ensure $\sigma > 0$, then jointly optimize {$\mu$, $var$} together with the other normalizing flow parameters (see below).

2. Transform the initial samples $z_0$ through $K$ *Normalizing Flow* transforms, from which we obtain the transformed approximate distribution $q_{K}(z)$,
     $\log q_{K}(z) = \log q_0 (z) - \sum_{k=1}^K \log (\mathrm{det} |J_k|)$
   where $J_k$ is the Jacobian of the $k$-th (invertible) normalizing flow transform.
   E.g. for planar flows,
     $\log q_{K}(z) = \log q_0 (z) - \sum_{k=1}^K \log |1 + u_k^{\top} \psi_k(z_{k-1})|$
   where each flow includes model parameters $\lambda = \\{ w, u, b \\}$.
3. Jointly optimize all model parameters by minimizing *KL-Divergence* between the approximate distribution $q_{K}(z)$
   and the true distribution $p(z)$.
     $$ \begin{align*}
              loss = KL[q_{K}(z)||p(z)] & = \mathbb{E}_{z_K \sim q_{K}(z)} \left[ \log q_K(z_K) - \log p(z_K) \right]\\
                             &= \mathbb{E}_{z_K \sim q_{K}(z)} \left[ \left(\log q_0(z_0) - \sum_k \log (\mathrm{det} |J_k|)\right) - \left(-U(z_K) - \log(\mathcal{Z})\right) \right]\\
                            &= \mathbb{E}_{z_0 \sim q_0(z)} \left[ \log q_0(z_0) - \sum_k \log \left(\mathrm{det} |J_k|\right) + U(f_1(f_2(\dots f_K(z_0)))) + \log(\mathcal{Z}) \right]
     \end{align*}  $$
   Here the partition function $\mathcal{Z}$ is independent of $z_0$ and model parameters, so we can ignore it for the optimization
     $loss = \mathbb{E}_{z_0 \sim q_0(z)} \left[ \log q_0(z_0) - \sum_k \log (\mathrm{det} |J_k|) + U(z_K) \right]$

The expectation could be approximated by Monte Carlo sampling, the mini-batch average here could be considered as the Monte Carlo Sampling Expectation.

### Ex: Density estimation (Generative modelling)
$p_X:$ data distribution, $p_Y:$ prior over latent variable, $p_{f^{-1}(Y)}:$ push-forward density of $f^{-1}(Y)$, i.e the generative model

$$\begin{align*}
 D_{KL}(p_X \Vert p_{f^{-1}(Y)}) & = \mathbb{E}_{x\sim p_{X}}\left[ \log p_X (x) - \log p_{f^{-1}(Y)} (x) \right] \\
                                 & = \mathbb{E}_{x\sim p_{X}}\left[ \log p_X (x) - \log p_{X} (x) \right] \\
                                 & = \mathbb{E}_{x\sim p_{X}}\left[ \log p_X (x) - \log p_{Y} (f(x))\left| \mathrm{det} \frac{\partial f(x)}{\partial x} \right|\right]\\
                                 & = \mathbb{E}_{x\sim p_{X}}\left[ \log p_X (x) - \log p_{Y} (f(x)) - \log \left| \mathrm{det} \frac{\partial f(x)}{\partial x} \right| \right]
\end{align*} $$

---

### Footnotes:
1. See [A note on the evaluation of generative models](https://arxiv.org/abs/1511.01844) for a thought-provoking discussion about how high log-likelihood is neither sufficient nor necessary to generate “plausible” images. Still, it’s better than nothing and in practice a useful diagnostic tool.

2. There’s a connection between Normalizing Flows and GANs via encoder-decoder GAN architectures that learn the inverse of the generator (ALI / BiGAN). Since there is a separate encoder trying to recover $u=G^{−1}(x)$ such that $x=G(u)$, the generator can be thought of as a flow for the simple uniform distribution. However, we don’t know how to compute the amount of volume expansion/contraction w.r.t. $x$, so we cannot recover density from GANs. However, it’s probably not entirely unreasonable to model the log-det-jacobian numerically or enforce some kind of linear-time Jacobian by construction.

repository: orgapblog/pubapblog

gha_language: HTML

gha_license_id: MIT

repo_name: orgapblog/pubapblog


text:
# Monero tx_extra data analysis: ASCII data

Neptune & Isthmus, 2020

Here are some examples of ASCII data we found in unencrypted payment IDs across the Monero blockchain.

We present this for the purpose of demonstrating that unencrypted payment IDs are trivial to read and leak information about Monero users.

## High-level overview:
- 350+ dates
- 80+ email addresses
- 10+ URLs
- 100+ variations on "X is the best X"
- 250+ messages

## Examples
### Dates
Multiple formats observed, including:
- Repeating YYYY-MM-DD: `2017-05-22DM2017-05-22DM2017-05-`
- "ID" + YYYYMMDD + tag: ` ID201904060422492k5oCZ1K71J8ZODB9d`
- YYYYMMDDhhmmss + tag: `20190406042249vxBGF5xa5jqbb3GT1Q`

These dates and PIDs are often repeated, probably for convenient transaction linkability.

### Email addresses
There are a large number of email addresses, including personal domains, and several widely-known cryptocurrency ecosystem contributors.

### URLs
There are a variety of URLs including:
- LinkedIn profiles
- A [short story](https://pastebin.com/mpJwkf7R)
- An article about a [ring size update](http://weuse.cash/2016/03/23/hard-fork/)

### X is the best X
There are boatloads of transactions with variations on "X is the best X", a few examples including:
- fluffypony is tge best pony ever
- fluffypony is tha best pony ever
- fluffypony is the best pony eveB
- fluffypony is the best pony ever
- fluffypony isbsýìûr5st pony ewww
- fluffypony&86(G(e best pony etRû
- xmrscott is the best Scott

### Messages
There are hundreds of messages, ranging from jokes to vulgarity. MANY include PII such as names, handles, transaction amounts, credit card info, and contact information (not included below):
- `LEALANA 5 XMR RCT( û(bí)ì 1C!2S(`
- `<*> Joins [#xmrchain] ->Guest1`
- `  FUCK BINANCE FUCK CHAINALYSIS`
- `Mining Payout`
- `Here, have some kitt-katt - -`
- `1000000 Monero blocks - XMR4ever`
- `ThisthebestpaymntIDwehaveeverhad`
- `anycoin040820190441anycoin040820`
- `50X.COM Best Exchange         "ç`
- `For guns, drugs and prostitutes!`
- `RouziLovesPLGuitarAndLSMusic`
- `MONERO.RS 100 XMR Giveaway W#1`
- `This is a test transaction`
- `@@~:good luck in life:~@@`
- `DEADINSIDETID4`
- `¡¿¡They are watching you`
- `This tx was generated by Coinomi`
- `Fuck-your-donations,assholes!`
- `trololololipopspaymentidmymoscow`
- `Monero is AWSOME!!!`
- `FUCK THE SYSTEM`
- `ETCheckThisOutHereIsYourFirstXMR`
- `EPOL Group 2 #ICSSS2019 Victory!`
- `Here'sAnotherMoneroFundTransfer!`
- `Sic semper tyrannis!`
- `hallohallo eine neue monero tro`
- `Everyone should use Monero!!!!!!`
- `SleezyMacMoonster(1800-225-5324)`
- `hei dette er meg`
- `warm summer buffer zone`
- `minexmrcomdevfeeminexmrcomdevfee`
- `thanks for everything`
- `Test 0.1 XMR to Personal Account`
- `Yet another uneventful hardfork`
- `thanks a lot for sharing ideas!!`
- `13 tx.s: ASCII_EPOL.html.tar.bz2`
- `im the king of monero fuckyouall`
- `>>FUCK YOU BYTECOIN SCAM PIGS!<<`
- `THANK YOU!`
- `#Egö           !"#$%&'()0123456`
- `Thou shalt not track my Monero!!`
- `myfirstmonerodonationtopiratebay`
- `This is the end my friend again8`
- `forgot to send this a while ago!`
- `WE WANT TO USE MONERO TO UPGRADE`
- `Istanbul 1st monero meetup`
- `To the Moonero!`
- `I\'d like to eat some bananasyoy`
- `ADD-BITCOIN-AND-MONERO-PAYMENTS`
- `Electroneum Wallet----Payment ID`
- `Drugs@FBI-Catch-me-if-you-can`
- `LOL@Chainalysis@LOL`
- `     thisismypaymentidyoufucker!`
- `DONATION FOR AN AMAZING SERVICE!`
- `We are the champions, my friends`
- `XMR IS ANONYMOUS. TRACK MY COCK!`
- `Thanks for the helphavesome beer`
- `ICSSS-2019-EUROPOL-GROUP2-FTW!:)`
- `WhenIwasachildIspakeasachildIun`
- `Hallo Hallo das ist ein test fr`
- `it's been a pleasure trading w/u`
- `We need more DOGE smut for ads`
- `thanks for the graphs theyrecool`
- `monerogenesismining`

## Next steps
While unencrypted payment IDs are no longer included by the core wallet, they are still allowed by the protocol, and are still occasionally in use today.  Go have some fun - leave us some new easter eggs to find. ;- )

However, note that your transactions will be pretty easy to link (especially via the change output) if you send multiple messages from the same wallet, so be mindful. And obviously putting your name or email address in plaintext on a blockchain puts your digital and physical safety at risk, so think twice before putting PII in memo fields (just because you *can* doesn't mean that you *should*).


text:
# pdfmerger
A small python package to merge and bookmark PDF files based on PyPDF2 and reportlab.

Allows to **merge a list of PDF files while preserving their original name**. In fact the file name of each merged file (without extension) may optionally be written on every page of the merged file (watermark).

Unless specified in the program options (--write-filenames) no watermark will be added to the pages.

Output file will contain **bookmarks** to the original files.

## Running the program using Docker (no installation required)
This program can be used on the fly without installation by running the image present on [Docker Hub](https://hub.docker.com/r/northwestwitch/pdfmerger/tags?page=1&ordering=last_updated)

Simple command to launch the container and check that it works:
```
docker run -it --rm  pdfmerger --help
```
Keep in mind that you need to map the folder(s) containing the files to merge and the folder that will contain the outfile to a folder in the Docker container filesystem (default is /home/pdfmerger/data). To do so you should run the container providing a volume. For instance if you files are in folder `/home/username/documents` the volume will be `/home/username/documents:/home/pdfmerger/data`

Please note that the program will look your for infiles inside `/home/pdfmerger/data` because that is the folder that they're mapped into, so when you run the program from the terminal the --infile(-f) option should point to that folder.
In the terminal, In order to produce an outfile on your file system (and outside the container) you should also provide the option `--outfolder /home/pdfmerger/data`.

Example command to pull the image from Docker Hub and execute the program directly with custom parameters:
```
docker run -d --rm \
-v /home/username/documents:/home/pdfmerger/data \
northwestwitch/pdfmerger --orientation landscape \
-f /home/pdfmerger/data/infile1.pdf -f /home/pdfmerger/data/infile2.pdf .. \
--outfolder /home/pdfmerger/data (--outfile outfilename.pdf)
```

## Installing the program locally
Requires python>=3.6.

Clone this repository with the command:
```
git clone https://github.com/northwestwitch/pdfmerger.git
```
enter the created folder with
```
cd pdfmerger
```
Install the software and its dependencies with `pip install`:
```
pip install -e .
```

## Usage
```
Options:
  -f, --infile TEXT               Path to one infile, repeat for multiple
                                  files  [required]

  --orientation [portrait|landscape]
                                  Orientation of initial PDF files  [required]
  --outfolder PATH                Path to destination outfile
  --outfile TEXT                  Name of destination outfile
  --write-filenames               Write original file names on the pages
                                  before merging
  --help                          Show this message and exit.
```

Example:
```
pdfmerge --orientation landscape -f infile1.pdf -f infile2.pdf .. --add-filenames (--outfolder outfolder --outfile outfile.pdf)
```

The demo folder contains [3 test files](https://github.com/northwestwitch/pdfmerger/tree/master/pdfmerger/demo) that you could test the program with.

repository: northwestwitch/pdfmerger

gha_language: Python

repo_name: northwestwitch/pdfmerger


text:
---
layout: post
title: "OsPP18,OsPP2C10"
description: ""
category: genes
tags: [protein phosphatase, drought and oxidative stress , drought stress , oxidative stress, stress tolerance]
---

* **Information**
    + Symbol: OsPP18,OsPP2C10
    + MSU: [LOC_Os02g05630](http://rice.uga.edu/cgi-bin/ORF_infopage.cgi?orf=LOC_Os02g05630)
    + RAPdb: [Os02g0149800](https://rapdb.dna.affrc.go.jp/locus/?name=Os02g0149800)

* **Publication**
    + [A SNAC1-regulated protein phosphatase gene OsPP18 modulates drought and oxidative stress tolerance through ABA-independent reactive oxygen species scavenging in rice](http://www.ncbi.nlm.nih.gov/pubmed?term=A SNAC1-regulated protein phosphatase gene OsPP18 modulates drought and oxidative stress tolerance through ABA-independent reactive oxygen species scavenging in rice%5BTitle%5D), 2014, Plant Physiol.

* **Genbank accession number**

* **Key message**
    + A SNAC1-regulated protein phosphatase gene OsPP18 modulates drought and oxidative stress tolerance through ABA-independent reactive oxygen species scavenging in rice

* **Connection**
    + __OsNAC19~SNAC1~OsNAC9__, __OsPP18~OsPP2C10__, [A SNAC1-regulated protein phosphatase gene OsPP18 modulates drought and oxidative stress tolerance through ABA-independent reactive oxygen species scavenging in rice](http://www.ncbi.nlm.nih.gov/pubmed?term=A SNAC1-regulated protein phosphatase gene OsPP18 modulates drought and oxidative stress tolerance through ABA-independent reactive oxygen species scavenging in rice%5BTitle%5D), We identified a rice protein phosphatase 2C (PP2C) gene, OsPP18, as a STRESS-RESPOSIVE NAC1 (SNAC1)-regulated downstream gene.

[//]: # * **Key figures**


text:
---
title: "HANNA Benchmark"
excerpt: "HANNA, a large annotated dataset of Human-ANnotated NArratives for ASG evaluation."
collection: portfolio
url:
---

HANNA is a large annotated dataset of Human-ANnotated NArratives for ASG evaluation. It was introduced in the paper "*Of Human Criteria and Automatic Metrics*: A Benchmark of the Evaluation of Story Generation" accepted in COLING 2022.

The repository is accessible [here](https://github.com/lashoun/hanna-benchmark-asg).


text:
# CHANGELOG

## v3.3.1 (2022-09-09)

- updates Flask (>=2.1.3) and Flask-WTF (1.0.*)

## v3.3.0 (2022-09-09)
- move revision statuses to constants
- refactors and DRYs up report generation with `ReportSectionConfig`
- adds WIP diffs section to RevisionStatusReport
- adds flag `include_in_slack` for sections to include in Slack

## v3.2.0 (2022-07-26)
- Updates to use explicitly set Conduit API token, Phabricator base URL, etc
- Adds `/users` listing page and user profile page
- Adds utils for fetching users: single user by user name, multiple users, all active users
- Adds the ability to show metrics for specific users
- Adds more colors from flatuicolors.com
- Upgrades to Chart.js 3.8.0 and adds legend event hooks
- cleanup: rename `*_pages` to `*_endpoints` for several view

## v3.1.2 (2022-05-21)
- Fixes breadcrumbs for report names by preserving case

## v3.1.1 (2021-12-13)
- Removes an incorrect type hint

## v3.1.0 (2021-12-13)
- Fixes metric aggregation by customer, service, and owner (#12)
- Fixes `start_of_month` by simply using `1`, instead of `calendar.monthrange[0]`, (#11)
- Minor improvements to metrics explorer (#10)
- adds `CUSTOM_STATIC_DIR` and `CUSTOM_STYLESHEETS` served by `{{ url_for('custom_static', filename=filename) }}` (#9)

## v3.0.1 (2021-04-06)
- Include all open Maniphest statuses for upcoming tasks due report
  - awaitingbusiness
  - inprogress
  - open
  - stalled

## v3.0.0 (2020-12-22)
- added Explore page and blueprint
- adds mechanism to retrieve a list of Customers (special Project tag)
- adds the ability to filter task metrics by Customer
- styling for applied filters string
- formatting for task metrics
- adds custom segments (including nested segments) for projects on explore page
- filter by bulk project names
- add hyperlinks with quarter interval to explore
- slightly improved interval calculation
- improved section headings indicating interval
- adds aggregated metrics, normalized metrics and rate metrics
- tasks by project_phids query use AND, so need to make multiple queries
- display 2 decimal points
- adds AggregatedTaskMetricsStats as companion to TaskMetricsStats
- segment tasks by customer, users, and service
- move/refactor utils.py and constants.py into module with submodules
- add checks for null projects

## v2.7.0 (2020-11-19)
- adds statistical analysis

## v2.6.0 (2020-11-19)
- Version bump only

## v2.5.0 (2020-11-18)
- adds Stories, Features, Tasks in addition to Bugs as metric types

## v2.4.0 (2020-11-18)
- adds filters to web metrics
- adds the ability to select interval: week/month
- adds the ability to set custom start and end period

## v2.3.0 (2020-11-18)
- Adds breadcrumbs to website

## v2.2.1 (2020-11-04)
- Adds report setting: non_group_reviewer_acceptance_threshold
- Allows requiring a minimum number of acceptances by non-group reviewers for GroupReviewStatusReport

## v2.2.0 (2020-10-27)
- Adds GroupReviewStatusReport
- adds web link for RevisionStatusReport and GroupsReviewStatusReport
- convert REPORTS config from dict to list

## v2.1.2 (2020-10-21)
- update Maniphest open, closed statuses
- fix BugMetric namedtuple name

## v2.1.1 (2020-08-25)

- Use accordion component to show/collapse bugs
- Fix Maniphest __str__ representation
- fix MANIPHEST_STATUSES_CLOSED vs MANIPHEST_STATUSES_OPE

## v2.1.0 (2020-08-25)

- add metrics class and utils for generating metrics
- adds bugs report to metrics
- refactored get_maniphest_tasks functions to properly paginate
- moves markdown to requirements
- fixes an HTML revision status report formatting bug
- update README with release instructions

## v2.0.0 (2020-08-24)

- include [web] variant of phablytics
- include Flask in requirements_web.txt
- explicitly require minimum Python 3.0
- properly package *.html template files with distribution
- add HTML-formatted reports
- convert emoji aliases to unicode characters

## v1.0.2 (2020-08-17)

- handles paginated results for Maniphest search

## v1.0.1 (2020-08-06)

- filter out changes-planned, include needs-revision

## v1.0.0 (2020-08-04)

- adds new dataclass ReportConfig to configure how reports should run
- all reports now work with ReportConfig
- adds report_name setting, which is a higher-level object than report_type
- multiple reports (with different report_names) can have different configurations using the same report_type
- updates differential revision search to include statuses of accepted, changes-planned, needs-review
- switches -r from --report_type to --report_name
- all Slack messages now support customizing username and emoji
- isort everything (switching to multi-line combo imports)
- updated README with some basic Get Started instructions

## v0.4.0 (2020-08-04)

- split out reports into its own directory module and separate files

## v0.3.0 (2020-06-17)

- use python-dotenv to read in env
- use settings.py in cwd
- various bug fixes

## v0.2.0 (2020-01-26)

- added CLI mode

## v0.1.0 (2020-01-26)

- update README, add LICENSE and a bunch of other build-related files

repository: hacktoolkit/phablytics

repo_name: hacktoolkit/phablytics


text:
#SBM-Spec

The open published interface components and hardware design guide for space-based manufacturing platforms.

**buttons:**
###[View Standards](http://sbmspec.com/home)

###[Follow on Github](http://github.com/SBMSpec/SBM-spec)

repository: SBMSpec/SBM-Spec

path: /Cover Page/CoverPage.md

gha_language: CSS

repo_name: SBMSpec/SBM-Spec


text:
# Remove Twitter Social Dilemma

Don't fall into the Social Dilemma. Remove explore/trends/suggested-follows/promoted on Twitter.
Also consider removing Ads on your google search results via [AdblockerGoogleSearch](https://github.com/PatrickJS/AdblockerGoogleSearch).
Also consider removing recommended on Youtube via [Remove YouTube Recommended Videos, Comments](https://chrome.google.com/webstore/detail/remove-youtube-recommende/khncfooichmfjbepaaaebmommgaepoid)

## Chrome Installation

1. Clone this repository, so it exists locally: `git clone https://github.com/PatrickJS/remove-twitter-social-dilemma.git`
2. In your browser, open the Extension Management page by navigating to `chrome://extensions` or by clicking on the Chrome menu, hovering over More Tools then selecting Extensions.
3. Enable Developer Mode by clicking the toggle switch next to Developer mode.
4. Click the LOAD UNPACKED button and select the extension directory (this repository, where it was cloned to).

## Brave Installation

If you're using [Brave Browser](https://brave.com/) you do not need to install this but you do need to add a few css selectors.

[Click on this link for instructions](https://dev.to/donavon/disable-promoted-tweets-in-twitter-using-brave-3e37)

Enter these selectors

```
div[aria-label="Timeline: Trending now"]
```
```
aside[aria-label="Who to follow"]
```
```
a[aria-label="Search and explore"]
```
```
nav[aria-label="Footer"]
```

Also set your blocker to aggressive

<img width="359" alt="Screen Shot 2020-09-20 at 6 46 43 AM" src="https://user-images.githubusercontent.com/1016365/93712903-80aa1c00-fb0d-11ea-842e-e9e7159cb879.png">

---

https://www.thesocialdilemma.com/

repository: PatrickJS/remove-twitter-social-dilemma

repo_name: PatrickJS/remove-twitter-social-dilemma


text:
---
aktt_notify_twitter:
- true
aktt_tweeted:
- 1
author: Adam
categories:
- Uncategorized
date: "2010-12-10"
dsq_thread_id:
- 188339600
layout: post
ljID:
- 319
title: Reasons why I love living in a small town
url: /blog/2010/12/10/reasons-why-i-love-living-in-a-small-town/
---
We had our first measurable snowfall today — a meager quarter inch or so. I was awake early, or late, depending on your point of view thanks to [fibrosomnia](1) day 2. I decided to _walk_ uptown to our favorite breakfast joint where I had three eggs, three slices of bacon, and fried potatoes and onions for under $5. I jotted down some words, made some notes on the next story I’m working on, and on the way back home picked up an extra large half hot chocolate, half coffee at Tim Hortons (which is open 24/7, btw) for less than $2. If I have to be awake, I may as well have some pep.

Cheap, convenient living is good.

 [1]: http://www.adamisrael.com/blog/2010/12/09/fibrosomnia/


text:
+++
author = ["Keiji Yoshida"]
date = "2015-03-27T15:07:34+09:00"
linktitle = "gobench - Go Benchmark Competition"
title = "gobench - Go Benchmark Competition"
+++

## Introduction

Simplicity is one of the philosophies of Go. Rob Pike said that the secret of Go's success is in its simplicity at [Go Conference 2014 autumn](http://gocon.connpass.com/event/9748/) in Tokyo, Japan. Dave Cheney [emphasized the importance of simplicity in Go](http://dave.cheney.net/2015/03/08/simplicity-and-collaboration) at [GopherCon India 2015](http://www.gophercon.in/). There are plenty of articles which explain the ways of writing code effectively in Go including [the official website of Go](http://golang.org/) and we can learn how to write simple Go code by studying these.

However, what about performance? How can we learn the ways of writing fast code in Go and improve the performance of our programs? The skill of writing fast code is as important as the one of writing simple code but the former is more difficult to master because much of the skill of writing fast code comes from experience.

So, I started [Go Benchmark Competition](http://gobench.org/), an environment in which we can gain practical experience of writing fast code in Go and exchange knowledge and know-how relating performance with one another. Now it's warmly welcomed by some of Go programmers and known affectionately as *gobench*.

![gobench](/postimages/gobench/gobench.png)

## Abstract

*gobench* competitions are held on [Slack](https://slack.com/). Participants in a competition can submit their code by simply sending it to a bot on Slack. The submitted code is automatically benchmarked and the bot on Slack notifies the submitter of its result. Rankings of competitions are shown in real time on [the official website](http://gobench.org/) like [this](http://gobench.org/results.html?no=1). Participants can improve and submit their code over and over again so that they can achieve higher rank. The submitted code is opened to the public after the competition ends. Participants can read and study from others' code and exchange their ideas and know-how with one another.

![slack](/postimages/gobench/slack.png)

## Merit of a Competition

A competition is the best thing in that it can give us an incentive to write faster code. A ranking page like [this](http://gobench.org/results.html?no=1) shows every submitted code's performance clearly and that prompts us to write faster code to achieve higher rank. So, a competition accentuates the difference between one's skill of writing fast code with others' and urges us to improve and master the skill.

![gobench](/postimages/gobench/competition.png)

## How to Join

You can join a competition easily by simply interacting with a bot on Slack. You can see how to join a competition in detail on the [How to Join](https://github.com/gobench/competitions/wiki/How-to-Join) Wiki page.

## Conclusion

I believe *gobench* will be useful to other Go programmers because it encourages them to improve the skill of writing fast code through collaborative learning from others. Or it might offer a good opportunity for beginners of Go to understand the importance of writing code considering its performance. I hope the skills/know-how you have improved/acquired at *gobench* will help you when you try to solve actual problems in Go.

If you have any questions or feedback about *gobench*, feel free to contact [me](https://twitter.com/_yosssi).

repository: gopheracademy/gopheracademy-web

gha_license_id: NOASSERTION

repo_name: gopheracademy/gopheracademy-web


text:
[![Go Report Card](https://goreportcard.com/badge/github.com/lastbackend/lastbackend)](https://goreportcard.com/report/github.com/lastbackend/lastbackend)
[![GoDoc](https://godoc.org/github.com/lastbackend/lastbackend?status.png)](https://godoc.org/github.com/lastbackend/lastbackend)
[![Travis](https://travis-ci.org/lastbackend/lastbackend.svg?branch=master)](https://travis-ci.org/lastbackend/lastbackend)
[![Join the chat at freenode:lastbackend](https://img.shields.io/badge/irc-freenode%3A%20%23lastbackend-blue.svg)](http://webchat.freenode.net/?channels=%23lastbackend)
[![Licensed under Apache License version 2.0](https://img.shields.io/github/license/lastbackend/lastbackend.svg?maxAge=2592000)](https://www.apache.org/licenses/LICENSE-2.0)
[![StackShare](https://img.shields.io/badge/tech-stack-0690fa.svg?style=flat)](https://stackshare.io/last-backend/last-backend)

![alt text](docs/assets/logo.png?raw=true "Image")

## Last.Backend: the apps cloud hosting for fast apps deploying, you don't need to manage.

Last.Backend is an open-source platform, which allows you build a personal cloud on your servers based on kubernetes technology.

Last.Backend fetches code from current directory, request or repo, build it and deploy it to server.
Last.Backend uses powerful containers, that means that your app will be run anywhere, from your development environment on your laptop to any large scale cloud hosting.
You can run deploy it daemon on the host where you want to deploy your applications (it can be local or remote), run CLI with this host and your applications will be deployed on specified host.

This project has [Roadmap](ROADMAP.md), feel free to offer your features.

Look at our [Changelog](CHANGELOG.md) to see project progress!

We are actively searching for contributors! If you want to help our project and to make developers life easier, please read our **[Contibuting guideliness](CONTRIBUTING.md)**.

**We have benefits for active contributors!**

![alt text](docs/screens/workflow.gif?raw=true "Image")

___

## Table of contents

1. [Key features](#key_features)
2. [Prerequisites](#prerequisites)
3. [How to install](#how_to_install)
4. [API Reference](#api)
5. [Maintainers](#maintainers)
6. [Roadmap](#roadmap)
7. [Community](#community)
8. [Authors](#authors)
9. [License](#license)

___

## Key features

1. Fast application deploying to any server
2. Easy application sharing
3. Easy application management
4. Deploying application with url/hub (like docker hub)
5. Deploying scheduling
6. Deploying services like redis, rabbitmq, mysql, etc.

___

## Prerequisites

- Go 1.6 or higher
- Kubernetes 1.5
- RethinkDB 2.3.5
- Git

___

## How to install

For develop locally on your host you need read the [documentation](https://github.com/lastbackend/lastbackend/wiki/Getting-Started) for build and running this.

---

### API Reference

For additional information about the API see Last.Backend [API Reference](https://github.com/lastbackend/lastbackend/wiki/API-Reference).

---

## Maintainers

We have separated maintainers page [here](https://github.com/lastbackend/lastbackend/blob/master/MAINTAINERS.md)

---

## Roadmap

For details on our planned features and future direction please refer to our [roadmap](ROADMAP.md).

---

### Community

Join us on social media:
 - [Twitter](https://twitter.com/LastBackend)
 - [Facebook](https://www.facebook.com/lastbackend)
 - [Stackshare](https://stackshare.io/last-backend/last-backend)
 - [AngelList](https://angel.co/last-backend)
 - [LinkedIn](https://www.linkedin.com/company/last-backend)

Read our [blog](https://blog.lastbackend.com).

---

### Authors

Alexander: https://github.com/undassa

Konstantin: https://github.com/unloop

---
## License

Origin is licensed under the [Apache License, Version 2.0](http://www.apache.org/licenses/).

repository: mtojek/lastbackend

repo_name: mtojek/lastbackend


text:
# recommendation-systems

Information Retrieval Assignment - 3 (CS F469)

## Team:
* [Daksh Yashlaha](https://github.com/daksh-yashlaha)
* [Pranjal Gupta](https://github.com/PranjalGupta2199)
* [Satyam Mani](https://github.com/sat13mani)
* [Ujjwal Raizada](https://github.com/ujjwal-raizada)


text:
![Jarviz](../jarviz-logo.png)

# Jarviz Graph Tool

Jarviz graph tool is designed for graphing the dependency coupling data for Java applications. The dependency coupling data provided as a [JSON Lines (.jsonl)](http://jsonlines.org/) file is generated from [Jarviz Java library](../jarviz-lib).

In order to run the tool, Jarviz Graph expects [node](https://nodejs.org) and [npm](https://www.npmjs.com/get-npm) to be installed in the system as a prerequisite.

### Sample Dependency Graph

## Usage

### Development

- Clone the repository
- Run following command:

```shell
$ npm install
$ npm run build:example
```

The output is generated as HTML files in the `build` directory using the mock coupling data from `lib/mock` directory.

### Command

To generate the HTML graph using specified coupling data, run:

```shell
npx "@homeaway/jarviz-graph" -i <Input Directory> -o <Output Directory>
```

### Parameters

```
-i, --input <path>    Input path to the directory containing Jarviz JSONL
-o, --output <path>   Output path to the directory for HTML graph
```

## Legal

This project is available under the [Apache 2.0 License](http://www.apache.org/licenses/LICENSE-2.0.html).

Copyright 2020 Expedia, Inc.

repository: ExpediaGroup/jarviz

gha_language: Java

repo_name: ExpediaGroup/jarviz


text:
![MIT License](https://img.shields.io/badge/license-MIT-blue.svg)
![Tag](https://img.shields.io/github/tag/disq/crawler.svg)
[![godoc](https://img.shields.io/badge/godoc-reference-blue.svg)](https://godoc.org/github.com/disq/crawler)
[![Go Report](https://goreportcard.com/badge/github.com/disq/crawler)](https://goreportcard.com/report/github.com/disq/crawler)

# Crawler

Web crawler PoC

## Build / Deploy

    # Clone
    git clone https://github.com/disq/crawler.git
    cd crawler

    # Fetch dependencies
    dep ensure

    # Build
    go build ./cmd/crawler

## Usage

    Usage: ./crawler [options] [start url] [additional hosts to include...]
      -l string
            Log level (default "info")
      -t duration
            HTTP timeout (default 5s)
      -w int
            Number of worker goroutines. Negative numbers mean multiples of the CPU core count. (default 256)

# License

MIT.

repository: disq/crawler

repo_name: disq/crawler


text:
# Resistor Ladder Buttons

The `LadderButtons.ino` is a sample code for `LadderButtonConfig` which
supports multiple buttons on a single analog pin. The buttons are distinguished
by using a resistor ladder that sets the voltage to different values. The
voltage can be read using the `analogRead()` function.

This program demonstrates 4 buttons using 4 resistors:

* 1 x SparkFun Pro Micro (clone)
* 4 x push buttons
* 1 x 4.7 kohm resistor
* 2 x 10 kohm resistor
* 1 x 47k kohm resistor

See [Resistor Ladder](../../docs/resistor_ladder) for documentation on
how to use the `LadderButtonConfig` class.

## Circuit and Breadboard

![Circuit](../../docs/resistor_ladder/resistor_ladder_parallel.png)

The circuit above shows a 220 Ohm current-limiting resistor on Button 0. I was
lazy and did not use it for this breadboard:

![Breadboard](breadboard_resistor_ladder.jpg)

## Sample Output

### `MODE_READ_BUTTONS`

When `LadderButtons.ino` is compiled with:
```C++
#define MODE MODE_READ_BUTTONS
```
it reads 4 buttons connected to the `A0` analog pin.

The sample output shows where each button was Pressed then Released. Blank lines
were added for readability:

```
handleEvent(): virtualPin: 0; eventType: Pressed; buttonState: 0
handleEvent(): virtualPin: 0; eventType: Released; buttonState: 1

handleEvent(): virtualPin: 1; eventType: Pressed; buttonState: 0
handleEvent(): virtualPin: 1; eventType: Released; buttonState: 1

handleEvent(): virtualPin: 2; eventType: Pressed; buttonState: 0
handleEvent(): virtualPin: 2; eventType: Released; buttonState: 1

handleEvent(): virtualPin: 3; eventType: Pressed; buttonState: 0
handleEvent(): virtualPin: 3; eventType: Released; buttonState: 1
```

### `MODE_CALIBRATE`

When the program is compiled with

```C++
#define MODE MODE_CALIBRATE
```

the values of `analogRead()` is printed as fast as possible.

repository: bxparks/AceButton

branch_name: refs/heads/develop

repo_name: bxparks/AceButton


text:
> **This repository has moved to https://gitlab.developers.cam.ac.uk/uis/devops/django/ucamwebauth**

[![Build Status](https://travis-ci.org/uisautomation/django-ucamwebauth.svg?branch=master)](https://travis-ci.org/uisautomation/django-ucamwebauth)

# Introduction

django-ucamwebauth is a library which provides use of Cambridge University's
[Raven authentication](http://raven.cam.ac.uk/) for [Django](https://www.djangoproject.com/). It provides a Django
authentication backend which can be added to `AUTHENTICATION_BACKENDS` in the Django `settings` module.

## Use

Install django-ucamwebauth using pip:

```bash
pip install django-ucamwebauth
```

Then you can enable it within your Django project's settings.py:

```python
AUTHENTICATION_BACKENDS = (
    'ucamwebauth.backends.RavenAuthBackend',
    'django.contrib.auth.backends.ModelBackend'
)
```

This allows both normal Django login and Raven login.

You should then enable the URLs for ucamwebauth:

````python
urlpatterns = patterns('',
    ...
    url(r'', include('ucamwebauth.urls')),
    ...
)
````

## Minimum Config Settings

You then need to configure the app's settings. Raven has a live and test environments, the URL and certificate details
are given below.

There are four minimum config settings:

```
UCAMWEBAUTH_LOGIN_URL: a string representing the URL for the Raven login redirect.
UCAMWEBAUTH_LOGOUT_URL: a string representing the logout URL for Raven.
UCAMWEBAUTH_RETURN_URL: the URL of your app which the Raven service should return the user to after authentication.
    (Default is generated automatically from the urlconf)
UCAMWEBAUTH_LOGOUT_REDIRECT: a string representing the URL to where the user is redirected when she logs out of the app
    (Default to '/').
UCAMWEBAUTH_NOT_CURRENT: a boolean value representing if raven users that are currently not members of the university
    should be allowed to log in (Default to False). More info: http://www.ucs.cam.ac.uk/accounts/ravenleaving
UCAMWEBAUTH_CERTS: a dictionary including key names and their associated certificates which can be downloaded from the
    Raven project pages.
UCAMWEBAUTH_TIMEOUT: An integer with the time (in seconds) that has to pass to consider an authentication timed out
    (Default to 30).
UCAMWEBAUTH_REDIRECT_AFTER_LOGIN: The url where you want to redirect the user after login (Default to '/').
UCAMWEBAUTH_CREATE_USE: This defaults to True, allowing the autocreation of users who have been successfully
authenticated by Raven, but do not exist in the local database. The user is created with set_unusable_password().
```

An example, referencing the Raven test environment is given below:

```python
UCAMWEBAUTH_LOGIN_URL = 'https://demo.raven.cam.ac.uk/auth/authenticate.html'
UCAMWEBAUTH_LOGOUT_URL = 'https://demo.raven.cam.ac.uk/auth/logout.html'
UCAMWEBAUTH_LOGOUT_REDIRECT = 'http://www.cam.ac.uk/'
UCAMWEBAUTH_CERTS = {901: """-----BEGIN CERTIFICATE-----
MIIDzTCCAzagAwIBAgIBADANBgkqhkiG9w0BAQQFADCBpjELMAkGA1UEBhMCR0Ix
EDAOBgNVBAgTB0VuZ2xhbmQxEjAQBgNVBAcTCUNhbWJyaWRnZTEgMB4GA1UEChMX
VW5pdmVyc2l0eSBvZiBDYW1icmlkZ2UxLTArBgNVBAsTJENvbXB1dGluZyBTZXJ2
aWNlIERFTU8gUmF2ZW4gU2VydmljZTEgMB4GA1UEAxMXUmF2ZW4gREVNTyBwdWJs
aWMga2V5IDEwHhcNMDUwNzI2MTMyMTIwWhcNMDUwODI1MTMyMTIwWjCBpjELMAkG
A1UEBhMCR0IxEDAOBgNVBAgTB0VuZ2xhbmQxEjAQBgNVBAcTCUNhbWJyaWRnZTEg
MB4GA1UEChMXVW5pdmVyc2l0eSBvZiBDYW1icmlkZ2UxLTArBgNVBAsTJENvbXB1
dGluZyBTZXJ2aWNlIERFTU8gUmF2ZW4gU2VydmljZTEgMB4GA1UEAxMXUmF2ZW4g
REVNTyBwdWJsaWMga2V5IDEwgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBALhF
i9tIZvjYQQRfOzP3cy5ujR91ZntQnQehldByHlchHRmXwA1ot/e1WlHPgIjYkFRW
lSNcSDM5r7BkFu69zM66IHcF80NIopBp+3FYqi5uglEDlpzFrd+vYllzw7lBzUnp
CrwTxyO5JBaWnFMZrQkSdspXv89VQUO4V4QjXV7/AgMBAAGjggEHMIIBAzAdBgNV
HQ4EFgQUgjC6WtA4jFf54kxlidhFi8w+0HkwgdMGA1UdIwSByzCByIAUgjC6WtA4
jFf54kxlidhFi8w+0HmhgaykgakwgaYxCzAJBgNVBAYTAkdCMRAwDgYDVQQIEwdF
bmdsYW5kMRIwEAYDVQQHEwlDYW1icmlkZ2UxIDAeBgNVBAoTF1VuaXZlcnNpdHkg
b2YgQ2FtYnJpZGdlMS0wKwYDVQQLEyRDb21wdXRpbmcgU2VydmljZSBERU1PIFJh
dmVuIFNlcnZpY2UxIDAeBgNVBAMTF1JhdmVuIERFTU8gcHVibGljIGtleSAxggEA
MAwGA1UdEwQFMAMBAf8wDQYJKoZIhvcNAQEEBQADgYEAsdyB+9szctHHIHE+S2Kg
LSxbGuFG9yfPFIqaSntlYMxKKB5ba/tIAMzyAOHxdEM5hi1DXRsOok3ElWjOw9oN
6Psvk/hLUN+YfC1saaUs3oh+OTfD7I4gRTbXPgsd6JgJQ0TQtuGygJdaht9cRBHW
wOq24EIbX5LquL9w+uvnfXw=
-----END CERTIFICATE-----
"""}
```

## Errors

There are five possible exceptions that can be raised using this module: MalformedResponseError, InvalidResponseError,
PublicKeyNotFoundError, and OtherStatusCode that return HTTP 500, or UserNotAuthorised that returns 403. You can catch
these exceptions using process_exception middleware
(https://docs.djangoproject.com/en/1.7/topics/http/middleware/#process_exception) to customize what the user will
receive as a response. The module has a default behaviour for these exceptions with HTTP error codes and using their
corresponding templates. To use the default behaviour just add:

```python
MIDDLEWARE_CLASSES = (
    ...
    'ucamwebauth.middleware.DefaultErrorBehaviour',
    ...
)

INSTALLED_APPS = (
    ...
    'ucamwebauth',
    ...
)
```

You can also rewrite the ucamwebauth_\<httpcode\>.html templates. You only need to add the following lines to your own if
you want to show the user the error message:

```python
{% for message in messages %}
    {{ message }}<br/>
{% endfor %}
```

## Authentication request parameters

This parameters are sent with the authentication request and allows the developer to tune the request to fit their app:

```
UCAMWEBAUTH_DESC: A text description of the resource requesting authentication which may be displayed to the end-user
    to further identify the resource to which his/her identity is being disclosed. Can be omitted.
UCAMWEBAUTH_IACT: The value 'yes' requires that a re-authentication exchange takes place with the user. This could be
    used prior to a sensitive transaction in an attempt to ensure that a previously authenticated user is still present
    at the browser. The value 'no' requires that the authentication request will only succeed if the user's identity
    can be returned without interacting with the user. This could be used as an optimisation to take advantage of any
    existing authentication but without actively soliciting one. If omitted or empty, then a previously established
    identity may be returned if the WLS supports doing so, and if not then the user will be prompted as necessary.
UCAMWEBAUTH_MSG: Text describing why authentication is being requested on this occasion which may be displayed to the
    end-user. Can be omitted.
UCAMWEBAUTH_PARAMS: Data that will be returned unaltered to the WAA in any 'authentication response message' issued as
    a result of this request. This could be used to carry the identity of the resource originally requested or other
    WAA state, or to associate authentication requests with their eventual replies. When returned, this data will be
    protected by the digital signature applied to the authentication response message but nothing else is done to
    ensure the integrity or confidentiality of this data - the WAA MUST take responsibility for this if necessary.
UCAMWEBAUTH_FAIL: If this parameter is 'yes' and the outcome of the request is anything other than success (i.e. the
    status code would be anything other than 200) then the WLS MUST return an informative error to the user and MUST
    not redirect back to the WAA. Setting this makes it easier to implement WAAs at the expense of a loss of
    flexibility in error handling.
```

The details of these can be found in the Raven WLS protocol documentation,
[here](http://raven.cam.ac.uk/project/waa2wls-protocol.txt).

repository: uisautomation/django-ucamwebauth

repo_name: uisautomation/django-ucamwebauth


text:
---
category: 'computer'
date: 2022-08-30 11:34:34 UTC-06:00
description: ''
link: ''
slug: its-a-unix-system
tags: 'guide, computer, nonsense, hypermodernism'
title: It's a UNIX system!
type: text
---

# my system

I'm going to go through my customized dev environment and linux workflow (?),

this is mostly for starcraft brood war ofc born of necessity.

I use vim but I expect autocomplete and go to definitions and a tool that let me move throuth my projet easy and quick

is a great text editor available everywhere that let me customize it to my own needs

I'm by no means a vim expert, this is more like my notes in the continuous process of learning and making my own customized experience.

vim window movements suck by default, I need good movements (explain what does this means).

my goals are built-in language support for Python, Lua, Erlang and C

avoid the requirement of tools outside those supported languages,

avoid rust or go utilities if possible,

avoid c++ if possible,

introduce debian linux

kek

introduce the starcraft and vim comparation..

- vim plugging manager
- my list of pluggins
- autocompletion
- unit tests
- git integration
- startify menu (?)
- go to definition
- linting (?)
- denite (more than just a fuzzy finder!)
- undotree F5
- dirvish (file finder)
- hotkeys

- mksh
- kitty
- bspwm
- tmux

direction is more important than speed

# plug

plug vim pluging manager

## my list of pluggins

| pluggin              | description                                                                 |
| - | - |
| vim-sensible         | a universal set of defaults that everyone can agree on.                     |
| vim-eunuch           | Vim sugar for the UNIX shell commands that need it the most.                |
| vim-fugitive         | It's so awesome, it should be illegal.                                      |
| vim-unimpaired       | Complementary pairs of mappings.                                            |
| vim-repeat           | Repeat.vim remaps . in a way that plugins can tap into it.                  |
| vim-dispatch         | Kick off builds and test suites using one of several asynchronous adapters. |
| vim-startify         | A fancy start screen for Vim                                                |
| vim-signify          | Show differences with style                                                 |
| vim-polyglot         | A solid language pack for Vim.                                              |
| vim-maximizer        | Maximizes and restores the current window in Vim.                           |
| vim-bbye             | Close and remove the buffer.                                                |
| vim-lastplace        | Intelligently reopen files at your last edit position.                      |
| vim-sandwich         | add/delete/replace surroundings of a sandwiched textobject                  |
| vim-highlightedyank  | Make the yanked region apparent!                                            |
| goyo                 | Distraction-free writing in Vim.                                            |
| limelight            | Hyperfocus-writing in Vim.                                                  |
| vim-peekaboo         | see the contents of the registers.                                          |
| vim-easy-align       | A simple, easy-to-use Vim alignment plugin.                                 |
| gv.vim               | A git commit browser in Vim                                                 |
| vim-slash            | Enhancing in-buffer search experience                                       |
| Vim-Jinja2-Syntax    | An up-to-date jinja2 syntax file.                                           |
| denite               | Denite is a dark powered plugin to unite all interfaces.                    |
| vim-dirvish          | Directory viewer for Vim                                                    |
| vim-dirvish-git      | Plugin for dirvish.vim that shows git status flags                          |
| vim-gtfo             | Go to Terminal or File manager                                              |
| vim-love-docs        | Vim plugin for LÖVE syntax highlighting and help file                       |
| vim-pandoc           | pandoc integration and utilities for vim                                    |
| vim-pandoc-syntax    | pandoc markdown syntax                                                      |
| graphviz.vim         | graphviz .dot to .png flow chart image                        |
| vim-sxhkdrc          | Vim syntax for sxhkd's configuration files                    |
| jupytext.vim         | editing Jupyter ipynb files via jupytext                      |
| tmux-complete.vim    | insert mode completion of words in adjacent tmux panes        |
| vim-tmux-navigator   | Seamless navigation between tmux panes and vim splits         |
| vim-table-mode       | VIM Table Mode for instant table creation.                    |
| auto-pairs           | Vim plugin, insert or delete brackets, parens, quotes in pair |
| undotree             | The undo history visualizer for VIM                           |
| onehalf              | one half dark                                                 |
| rainbow              | Rainbow Parentheses Improved                                  |
| VimCompletesMe       | You don't Complete Me; Vim Completes Me!                      |
| deoplete             | Dark powered asynchronous completion framework for Vim        |
| neoinclude           | Include completion framework for deoplete                     |
| deoplete-clangx      | C/C++ Completion for deoplete using clang                     |
| nvim-yarp            | Yet Another Remote Plugin Framework                           |
| vim-hug-neovim-rpc   | Compatibility layer for neovim rpc client working on vim8     |
| deoplete-vim-lsp     | deoplete source for vim-lsp                                   |
| vim-cmake            | plugin for working with CMake projects                        |
| vim-gutentags        | A Vim plugin that manages your tag files                      |
| tagbar               | displays tags in a window, ordered by scope                   |
| async.vim            | normalize async job control api for vim                       |
| vim-lsp              | async language server protocol plugin for vim                 |
| ale                  | Check syntax in Vim asynchronously and fix files              |
| vim-lsp-ale          | Bridge between vim-lsp and ALE                                |
| neoformat            | A vim plugin for formatting code.                             |
| vim-devicons         | Adds file type icons to Vim plugins                           |
| lightline.vim        | A light and configurable statusline/tabline plugin for Vim    |
| vim-cursorworld      | Underlines the word under the cursor                          |
| lightline-bufferline | bufferline functionality for the lightline vim plugin.        |
| lightline-ale        | ALE indicator for the lightline vim plugin                    |
| vimwiki              | Personal Wiki for Vim                                         |
| calendar-vim         | Creates a calendar you can use within vim                     |
| pomodoro.vim         | Bring the beauty of the Pomodoro technique to Vim             |
| Colorizer            | Color hex codes and color names                               |
| indentLine           | display the indention levels with thin vertical lines         |
| vim-test             | Run your tests at the speed of thought                        |
| vim-isort            | sort python imports using isort                               |
| vim-minimap          | A minimap for vim                                             |
| vim-lsp-settings     | Auto configurations for Language Server for vim-lsp           |

# custom preferences

| plugin         | description |
| -              | -           |
| ale.vim        | bla         |
| calendar.vim   | bla         |
| denite.vim     | bla         |
| deoplete.vim   | bla         |
| dirvish.vim    | bla         |
| goyo.vim       | bla         |
| gutentags.vim  | bla         |
| hotkets.vim    | bla         |
| indentLine.vim | bla         |
| jupytext.vim   | bla         |
| ligthline.vim  | bla         |
| lsp.vim        | bla         |
| neoformat.vim  | bla         |
| pandoc.vim     | bla         |
| startify.vim   | bla         |
| test.vim       | bla         |
| tmux.vim       | bla         |
| vimwiki.vim    | bla         |

# autocompletion

blabla bla

# linting

ale.vim

- python support flake8 and pylint
- lua support luacheck
- c support by clang
- erlang support with syntaxerl

# hotkeys

hotkeys.vim

| hotkey | description |
| - | - |
| leader ] | ale next wrap |
| leader [ | ale previous wrap |
|leader -| bla|
|leader \ | bla|
|leader t| bla|
|leader tc| color|
|leader s| update|
|leader z| spelling|
|leader x| buffer delete Bdelete|
|leader e| exit qa!|
|leader d| Denite buffer|
|leader f| DeniteProjectDir -start-filter grep:::!|
|leader Backspace| Denite -resume -cursor-pos=+1|
|leader gy | Goyo |

leader R, replace

leader gg, bla
leader gj, bla
leader gf, bla
leader ga, git fetch
leader gl, git pull
leader gc, git commit
leader gp, git push

leader cg, CMakeGenerate
leader cb, CMakeBuild

leader ct, CMakeBuild test

leader tn, TestNearest

leader tf, TestFile

leader ts, TestSuite -strategy=vimterminal

leader tl, TestLast

I'm also have qe, j, k, qw, qq maped for quickfix stuff (?)

leader qe,

leader j,

leader k,

leader qw,

leader qq

now the F keys

f1, help
f2, maximizer
f3, dirvish
f4, denite
f5, undotree
f5, date on insert mode
f7, calendar.vim
f8, pomodoro.vim

repository: spacebeam/research

repo_name: spacebeam/research


text:
# Laccaria laccata var. bicolor Maire, 1937 VARIETY

#### Status
SYNONYM

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

#### Published in
Publ. Inst. Bot. Barcelona 3(4): 84 (1937)

#### Original name
Laccaria laccata var. bicolor Maire, 1937

### Remarks
null

repository: mdoering/backbone

path: /life/Fungi/Basidiomycota/Agaricomycetes/Agaricales/Hydnangiaceae/Laccaria/Laccaria bicolor/ Syn. Laccaria laccata bicolor/README.md

repo_name: mdoering/backbone


text:
# wikisonnet
Automatically generate sonnets from wikipedia

scraper/src contains files needed for the scraping phase, while server contains files needed to serve up poems

scraper also needs some of the files in server. I haven't figured out how to make this work yet.
Because of this, scraper is actually broken for now

To run the server locally...
cd src
virtualenv /tmp/wikisonnet
source /tmp/wikisonnet/bin/activate
pip install -r requirements
pynt start_server

You'll also need a file called dbconfig.yml in your server directory. It should look like:

name:
  database: <database>
  host: <host>
  user: <user>
  password: <password>

repository: starakaj/wikisonnet

repo_name: starakaj/wikisonnet


text:
Hacker News Redesign

In an effort to learn to react here is a react based hacker news clone from scratch using the official open [Hacker News's API](https://github.com/HackerNews/API) .(No state management library used like redux).

  Live Demo

## Featuring

- React - UI Framework
- React Hook - A way to use state and side-effects in React function components
- Axios - A http client
- Bootstrap - CSS framework
- react-content-loader - SVG component to create placeholder loading

## Set Up

Use the node package manager [npm](https://www.npmjs.com) to set up the development enviroment.

1. Install the needed node packges/modules :

```bash
npm install
```

2. Start the development server :

```bash
npm run start
```

## Contributing

Pull requests are welcome. Please open an issue first to discuss what you would like to change.

repository: thekoding/hacker-news-redesign

repo_name: thekoding/hacker-news-redesign


text:
# Node.js Diagnostics Summit - Spring 2019

- **When:** 2019-03-07 to 2019-03-08
- **Where:** Munich, Germany
- **Issue:** [#203](https://github.com/nodejs/diagnostics/issues/203)
- **Agenda:** [Google Doc](https://docs.google.com/document/d/1Ub4kqznhEXHzKtS4ArK5KGBzwRLa29Kamr4lo2BvzcE/preview)

## Action Items

The following action items are copied from [this Google Doc](https://docs.google.com/document/d/1ftJCXFM_Yi45O2nr5O7YwdOMO7iUbWSx-UStvOYMu28/edit)

Besides these action items, there aren't any proper minutes.
For the best overview see the [Recordings](#recordings) section below.

### Async Hooks

Lead: [Matteo Collina](https://github.com/mcollina)

- Agreement on Benedikt's [document](http://bit.ly/making-async-hooks-fast-enough) (ASAP)
  - This solves the performance issue
  - **Please read and comment**
- Should there be a higher level API for CLS?
  - Vladmir started working on a PR to add CLS to Core

### V8 Signals

Lead: [Yang Guo](https://github.com/hashseed)

- [Document](https://docs.google.com/document/d/1xHl4qF2olKtDEPQFkci8g_wF3oTA-NBoJ6z5cpw1PWk)
- There are more trace events that V8 could be emitting
  - Low-hanging fruit: opt/deopt events
- Identify more use cases
- Move command line flags to actual APIs

### Documentation and Best Practices

Lead: [Michael Dawson](https://github.com/mhdawson)

- Continue to refine the list of use cases
  - Continue to fill those in
- Move heapdump generation to core ([@jasnell](https://github.com/jasnell))
  - Write best practices guide based on that

### Postmortem Debugging

Lead: [Yang Guo](https://github.com/hashseed)

- Move V8 to Torque (DSLification)
  - WIP
  - There's a spreadsheet with the progress
- Move llnode to use the metadata/script generated from DSL
- Heapsnapshot
  - Additional tooling to help uncover issues aside from core dump
  - Also convert core dump to heapsnapshot

### Trace Events and System Tracing

Lead: [James M Snell](https://github.com/jasnell)

- Perfetto: moving forward
- `TRACE_EVENTS` will be our primary instrumentation path
- System tracing will be case-by-case, best effort approach
  - Open an issue notifying stakeholders of this decision ([@jasnell](https://github.com/jasnell))
- Start to instrument more areas of core
- Profiling: doc to circulate ([@psmarshall](https://github.com/psmarshall))
- A flag similar to --prof but based on the CPU Profiler ([@joyeecheung](https://github.com/joyeecheung))

### APM Instrumentation

- V8 exposing a new API is not what we need
- We need to figure out what APM vendors want
- Come up with a blessed instrumentation API for module vendors to instrument their modules
- Document on monkey-patching vs. ESM

## Recordings

_Raw recordings can be found in [Google Drive](https://drive.google.com/drive/folders/1YLrO8XwAdWPaFNmyZZRqPAsSIDGo_RXw)_

### Talks

| Recording | Speaker | Slides |
|-----------|---------|--------|
| [Intro to OpenCensus, OpenTracing, and TraceContext](https://drive.google.com/file/d/1Of-bwwZtv0sb-7R1cEjyIqizDgyT4a4i/view?t=865) | [Thomas Watson](https://github.com/watson) | [SpeakerDeck](https://speakerdeck.com/wa7son/standards-in-distributed-tracing)
| [Perfetto and Node.js](https://drive.google.com/file/d/1Of-bwwZtv0sb-7R1cEjyIqizDgyT4a4i/view?t=2557) | [Kelvin Jin](https://github.com/kjin) |
| [Intro into APM agents, comparison of Node.js and Java](https://drive.google.com/file/d/1Of-bwwZtv0sb-7R1cEjyIqizDgyT4a4i/view?t=4700) | [Gerhard Stöbich](https://github.com/flarna) |
| [Zero cost async stack traces](https://drive.google.com/file/d/1Of-bwwZtv0sb-7R1cEjyIqizDgyT4a4i/view?t=6797) | [Benedikt Meurer](https://github.com/bmeurer) |
| [Status of Async Hooks](https://drive.google.com/file/d/1Of-bwwZtv0sb-7R1cEjyIqizDgyT4a4i/view?t=9870) | [Matteo Collina](https://github.com/mcollina) |
| [How to use a core dump](https://drive.google.com/file/d/1Of-bwwZtv0sb-7R1cEjyIqizDgyT4a4i/view?t=11302) | [Yang Guo](https://github.com/hashseed) |
| [Diagnostics Best Practices documentation](https://drive.google.com/file/d/1Of-bwwZtv0sb-7R1cEjyIqizDgyT4a4i/view?t=12125) | [Michael Dawson](https://github.com/mhdawson) |
| [Diagnostics in Java](https://drive.google.com/file/d/15MzZoIiUKpOUr86inpUqsl2phUsk05x2/view?t=143) | [Felix Barnsteiner](https://github.com/felixbarny) |
| [Status of Node Clinic / Doctor, Bubbleprof, Flame](https://drive.google.com/file/d/15MzZoIiUKpOUr86inpUqsl2phUsk05x2/view?t=2008) | [Matteo Collina](https://github.com/mcollina) |
| [State of CPU Profiling in V8](https://drive.google.com/file/d/1vIdYiFYW7S3804U7_5iznP9M-IO8xvNv/view?t=52) | [Peter Marshall](https://github.com/psmarshall) |
| [CloudFlare Workers](https://drive.google.com/file/d/1zlY37F-AtunGyqMbMC6TaAB40icN8GU0/view) |

### Discussions

| Recording | Notes |
|-----------|-------|
| [V8 Signals](https://drive.google.com/file/d/1LeSfIzArwvJfy2kGtbxF6HiMOukLabOg/view?t=281) | [Google Doc](https://docs.google.com/document/d/1xHl4qF2olKtDEPQFkci8g_wF3oTA-NBoJ6z5cpw1PWk/preview)
| [Documentation best practices](https://drive.google.com/file/d/1LeSfIzArwvJfy2kGtbxF6HiMOukLabOg/view?t=3232) | [Slides](https://github.com/nodejs/diagnostics/files/2957405/Diagnostic.Summit.-.Best.Practices.pdf)
| [Diagnostics Tooling Support Tiers](https://drive.google.com/file/d/1LeSfIzArwvJfy2kGtbxF6HiMOukLabOg/view?t=3388) |
| [Async Hooks](https://drive.google.com/file/d/1LeSfIzArwvJfy2kGtbxF6HiMOukLabOg/view?t=9227) | [Google Doc](https://docs.google.com/document/d/1g8OrG5lMIUhRn1zbkutgY83MiTSMx-0NHDs8Bf-nXxM/preview)
| [Post-mortem debugging](https://drive.google.com/file/d/1Enw2Z0R9pNsoaCVq8LPK6Ja-P-T5QX-h/view?t=2940) |
| [Trace events, system tracing, profiling](https://drive.google.com/file/d/1U9SfKfb83M-AQX3IL-XgX-OGuGAz4c5w/view) |
| [APM instrumentation](https://drive.google.com/file/d/11nk_cZYUCZhUKptHD-4dlS5PxQTeLXlc/view) |

repository: nodejs/diagnostics

repo_name: nodejs/diagnostics


text:
The SSH keys created on one device are available to every device connected by the 'web' access
right:

~~~~
<div="terminal">
<cmd>Alice2> account sync
<cmd>Alice2> ssh private /file=alice2_ssh_prv.pem
</div>
~~~~

repository: vijayrkn/Mathematical-Mesh

repo_name: vijayrkn/Mathematical-Mesh


text:
---
title: "OTA Updates"
slug: "ota-updates"
---

* toc
{:toc}

FarmBot OS is regularly improved to include new features, security enhancements, and bug fixes. It is recommended that you keep your FarmBot updated with the latest version of FarmBot OS at all times so that you can enjoy the best that FarmBot has to offer.

By default, all FarmBots are configured to update automatically at 3AM local time, meaning you don't have to worry about manually staying up-to-date. You can change the **UPDATE TIME** from the settings panel if you wish. You can also turn off **AUTO UPDATE** from the device settings panel, though this is not recommended.

# The update process
Updates will happen **over-the-air** (OTA), meaning FarmBot will download the latest version of the software when it becomes available, apply it, and reboot as necessary. Under normal circumstances there will be no need for reconfiguration or any manual effort required by the user; FarmBot should come back online, re-sync, and resume any scheduled events automatically.

An OTA update will usually take between 15 seconds and 3 minutes to download, depending on network quality and connection speed. The update process will then take 1 to 5 minutes before FarmBot is back online and ready to start work again.

If you're experiencing OTA update issues, remove the microSD card from your FarmBot and [manually flash](../farmbot-os.md#installing-farmbot-os) the latest `.img` file.


text:
# Rotate-Faces-with-Keras-CIFAR

This repository is the answer to the challenge of simple computer vision placed in https://gist.github.com/csaftoiu/9fccaf47fd8f96cd378afd8fdd0d63c1

The exepriments procedure is explained in the 'experiments_documentation.pdf' document.

To reproduce the experiment is necessary to perform the following steps:

1) Place the files: PreProcessing.py, train.py, test.py, rotateImages.py, test.rotfaces.zip (from challenge), train.rotfaces.zip (from challenge) in the same directory.

2) Extract the content of the test.rotfaces.zip and train.rotfaces.zip. Two folders (train and test) and the 'train.truth.csv' file should be seen after the extraction.

3) Run the 'PreProcessing.py' script. The content of the test and train folders will be reorganized and there will be created the following folders: Corrected_images, TensorBoard and valid.

4) Run the 'train.py' script. It will train a CIFAR convolutional network over the train folder samples and validate the training with the content of the valid folder. At the end of the execution it will be available a Tensor Board file inside the TesnsorBoard folder containing the statistics about the model's training. Those statistics can visualized by starting the tensor board server (localhost). Besides, the model trained weights will be saved as 'Rot_Faces_Conv_Net.h5' file.

5) Run the 'test.py' script. This script will classify the content of the test folder acording to the orientation of the pictures and generate the 'preds.csv' file, which contains the filenames of the test samples along with their respective orientations predicted by the model.

6) Run the script 'eval.py' with the 'truth.csv' file (provided by the challenge owner) and the preds.csv generated by the 'test.py' script.

7) Run the 'rotateImages.py', which will adjust the orientation of the test files according to their predicted orientation and save them in the Corrected_images folder. This folder was zipped and is available in the following link:
https://www.dropbox.com/s/nxtv2rs5t2usvbh/Corrected_Images.zip?dl=0


text:
# CTF-Ratings

ctftime.org じゃないレーティングシステム考えて、ついでに色がついたら最高だよねというプロダクト

## レートとパフォーマンス

基本的にAtCoderに準拠している。

- コンテストの対象レーティングが存在しない
- 初期パフォーマンスは1200
- レーティング上限なし

## Difficulty

レートXのチームがその問題を解ける確率が50%のとき、その問題のDifficultyはX

## How to contribute?

### Add CTF Result

Add `<CTF>.json` to `./data/events/`. Scoreboard format is following mainly https://ctftime.org/json-scoreboard-feed.

```json
{
  "tasks": ["task1", "task2", ...],
  "standings": [
    {
      "pos": 1,
      "team": "teamName",
      "score": 1333,
      "taskStats": {
        "task1": {
          "points": 1,
          "time":<PHONE_NUMBER>
        },
        "task2": {
          "points": 1,
          "time":<PHONE_NUMBER>
        }
      }
    },
    { ... }
  ],
  "date":<PHONE_NUMBER>, // added
  "name": "CTF Name" // added
}
```

### Add your team alias

See example https://github.com/theoremoon/ctf-ratings/blob/main/data/teams/zer0pts.json

## Missing CTFs

- D^3 CTF (scoreserver is closed)
- vishwaCTF 2021 (cloudflare protection)
- BCA CTF 2021 (no scoreserver)
- White-Hats Break the Syntax CTF (ssl handshake failed)
- Volga CTF2021 Qualifier (non-scrapable original platform)
- BSides Canberra CTF 2021 (scoreboard closed already)
- Cyber Apocalypse 2021 (how do I scrape htb ctf platform?)
- Hero CTF v3 (bot check)
- WPICTF (cloudflare)
- TAMU CTF (cannot see solved tasks of other teams)
- pwn2win (I forgot to collect the scoreboard ;_;)
- Circle City Con CTF 2021 (scoreboard closed immediately after the competition)
- THC CTF 2021 (registration closed immediately after the competition and challenges were only opened for the competitors)
- CyberThreatForce CTF | 2021 (registration is closed / scoreboard not available)
- CyBRICS CTF (I cannot know each teams solved what challenges)
- ~~RAR CTF (I cannot know each teams solved what challenges)~~ added by @willwam845 at (https://github.com/theoremoon/ctf-ratings/pull/57)
- Really Awesome CTF (ditto)
- InCTF (scoreserver is closed)
- FwordCTF 2021 (scoreserver is unstable to scrape)
- YauzaCTF 2021 (cannot see solved tasks of other teams)
- WORMCON 0x01 (UserAgent Denied)
- GrabCON (cloudflare protection)
- RCTF 2021 (XCTF)

## Author

- theoremoon (zer0pts)

## License

 Apache 2.0

repository: theoremoon/ctf-ratings

repo_name: theoremoon/ctf-ratings


text:
# Blogapplication

- An app I made during the Full Stack Web Development course by New York Code + Design Academy at BSSA, Amsterdam.
- First full-stack app build.
- Build on Node.js, created view with pug and stored data using postgres withg sequelize.
- App stores users, blogs and comments and gives the possibility to add blogs and comments.
- Relational models.
- Database insfranstructure and routes still in one file, app.js.

# Usage
- Adjust sequelize connection.
- Run node src/app.js

repository: PaulvanMotman/blogapplication

repo_name: PaulvanMotman/blogapplication


text:
# Cinch::Plugins::Calculate

[![Gem Version](https://badge.fury.io/rb/cinch-calculate.png)](http://badge.fury.io/rb/cinch-calculate)
[![Dependency Status](https://gemnasium.com/canonical-hackers/cinch-calculate.png)](https://gemnasium.com/canonical-hackers/cinch-calculate)
[![Build Status](https://travis-ci.org/canonical-hackers/cinch-calculate.png?branch=master)](https://travis-ci.org/canonical-hackers/cinch-calculate)
[![Code Climate](https://codeclimate.com/repos/56af1f0989ff0c6781005e97/badges/e33725af89d03971d9b1/gpa.svg)](https://codeclimate.com/repos/56af1f0989ff0c6781005e97/feed)
[![Test Coverage](https://codeclimate.com/repos/56af1f0989ff0c6781005e97/badges/e33725af89d03971d9b1/coverage.svg)](https://codeclimate.com/repos/56af1f0989ff0c6781005e97/coverage)
[![Issue Count](https://codeclimate.com/repos/56af1f0989ff0c6781005e97/badges/e33725af89d03971d9b1/issue_count.svg)](https://codeclimate.com/repos/56af1f0989ff0c6781005e97/feed)

Plugin that alows users to find the answers to math problems.

## Installation

Add this line to your application's Gemfile:

    gem 'cinch-calculate'

And then execute:

    $ bundle

Or install it yourself as:

    $ gem install cinch-calculate

## Usage

Just add the plugin to your list:

    @bot = Cinch::Bot.new do
      configure do |c|
        c.plugins.plugins = [Cinch::Plugins::Calculate]
      end
    end

You will also need to have GNU Units installed. The Units binary that
ships with OSX is old and doesn't work. If you have units installed
some place that's not '/usr/bin/units' you will have to specify the
alternate location.

    c.plugins.options[Cinch::Plugins::Calculate][:units_path] = '/usr/bin/gunits'

Once that's all done, just use !math in the channel.

    17:31 <@xentrac> !math 1000 W/m^2 * pi * earthradius^2
    17:31 < marvin> xentrac: 1.2751652e+17 kg m^2 / s^3
    17:31 <@xentrac> !math (1000 W/m^2 * pi * earthradius^2) / (quadrillion btu / year)
    17:31 < marvin> xentrac: 3814043.9

## Contributing

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

repository: canonical-hackers/cinch-calculate

repo_name: canonical-hackers/cinch-calculate


text:
# Usage

By default, the instance will be called `lighthouse-collection-$gcloudusername-instance0` but you can replace `instance0` by supplying an arg to `run.sh`.

1. Googlers: [set up ssh to gcloud](go/common-fw-policy-flows).
1. Spin up machines and start the collection.
   1. (Prerequiste) Install GCloud SDK and authenticate locally, Run `brew install google-cloud-sdk && gcloud auth login`
    1. (Prerequiste Googlers only) Ensure you're on the corp VPN or you won't be able to SSH into a Google-owned instance (run `gcert`).
   1. (Optional) Run `export TARGET_GIT_REF=<a lighthouse git ref that has been pushed> ` if wanting to run on anything but main.
   1. (Optional) Run `export TARGET_RUNS=<a number> ` if needing more than 1 run per URL.
   1. (Optional) Run `export LIGHTHOUSE_FLAGS=...` to configure Lighthouse CLI.
   1. (Optional) Run `export LIGHTHOUSE_COLLECTION_GCLOUD_PROJECT=<project name> ` to set your GCloud project.
   1. Run `bash core/scripts/gcp-collection/fleet-create.sh path/to/your/url/list.txt` from the repo root.
1. Check status of collection, download data, and kill machines on completion.
   1. Run `bash core/scripts/gcp-collection/fleet-status.sh` to check on status and download the data.
   1. Run `bash core/scripts/gcp-collection/fleet-status.sh --kill` to check on the status and terminate finished instances.
1. Analyze the results
   1. Bespoke for now :)
   1. Example [analysis](https://docs.google.com/document/d/1uoLYWlhRXHo-kCKnte0HZcCjy5VWOStDe0X78XlIf1o/edit?ts=602c4fd1&resourcekey=0-_FA55GhVpUYqfNsnCVzPdw)

## Future Work

- Collect a more comprehensive URL set for `urls.txt`
- Autodetermine the instance collect instance by n+1 the existing instances
- Add analysis scripts (similar to [`preprocess.sh`](https://github.com/patrickhulce/dzl-lighthouse/blob/60447f652dc15cacfa603fdf7c88b1add4229d1d/cwv/analyze/preprocess.sh) and [`analyze-ab-test.js`](https://github.com/patrickhulce/dzl-lighthouse/blob/60447f652dc15cacfa603fdf7c88b1add4229d1d/cwv/analyze/analyze-ab-test.js))

repository: GoogleChrome/lighthouse

gha_language: JavaScript

repo_name: GoogleChrome/lighthouse


text:
# Generate a Keypair and its Public Key

In this section, we will generate a keypair, query it for its public key,
and verify you control its private key. Before you begin, you will need
to:

* [Install the Solana Tool Suite](install-solana-cli-tools.md)
* [Choose a Command-line wallet](../wallet/cli-wallets.md)

## Generate an FS Wallet Keypair

Use Solana's command-line tool `solana-keygen` to generate keypair files. For
example, run the following from a command-line shell:

```bash
mkdir ~/my-solana-wallet
solana-keygen new -o ~/my-solana-wallet/my-keypair.json
```

If you view the file, you will see a long list of numbers, such as:

```text
[42,200,155,187,52,228,32,9,179,129,192,196,149,41,177,47,87,228,5,19,70,82,170,6,142,114,68,85,124,34,165,216,110,186,177,254,198,143,235,59,173,59,17,250,142,32,66,162,130,62,53,252,48,33,148,38,149,17,81,154,95,178,163,164]
```

This file contains your **unencrypted** keypair. In fact, even if you specify
a password, that password applies to the recovery seed phrase, not the file. Do
not share this file with others. Anyone with access to this file will have access
to all tokens sent to its public key. Instead, you should share only its public
key. To display its public key, run:

```bash
solana-keygen pubkey ~/my-solana-wallet/my-keypair.json
```

It will output a string of characters, such as:

```text
ErRr1caKzK8L8nn4xmEWtimYRiTCAZXjBtVphuZ5vMKy
```

This is the public key corresponding to the keypair in `~/my-solana-wallet/my-keypair.json`.
To verify you hold the private key for a given public key, use `solana-keygen verify`:

```bash
solana-keygen verify <PUBKEY> ~/my-solana-wallet/my-keypair.json
```

where `<PUBKEY>` is the public key output from the previous command.
The command will output "Success" if the given public key matches the
the one in your keypair file, and "Failed" otherwise.

## Generate a Paper Wallet Seed Phrase

See [Creating a Paper Wallet](../paper-wallet/paper-wallet-usage.md#creating-a-paper-wallet).

To verify you control the private key of that public key, use `solana-keygen verify`:

```bash
solana-keygen verify <PUBKEY> ASK
```

where `<PUBKEY>` is the keypair's public key and they keyword `ASK` tells the
command to prompt you for the keypair's seed phrase. Note that for security
reasons, your seed phrase will not be displayed as you type. After entering your
seed phrase, the command will output "Success" if the given public key matches the
keypair generated from your seed phrase, and "Failed" otherwise.

## Generate a Hardware Wallet Keypair

Keypairs are automatically derived when you query a hardware wallet with a
[keypair URL](../remote-wallet/README.md#specify-a-hardware-wallet-key).

Once you have your keypair URL, use `solana-keygen pubkey` to query the hardware
wallet for the keypair's public key:

```bash
solana-keygen pubkey <KEYPAIR>
```

where `<KEYPAIR>` is the keypair URL.

To verify you control the private key of that public key, use `solana-keygen verify`:

```bash
solana-keygen verify <PUBKEY> <KEYPAIR>
```

The command will output "Success" if the given public key matches the
the one at your keypair URL, and "Failed" otherwise.

repository: metaversefight/solana

repo_name: metaversefight/solana


text:
# Render

This package contains modules directly related to rendering an MWP React+Redux
application.

Although the Meetup Web Platform is built on the principle of Universal
Javascript with a shared app codebase used for server and browser rendering,
consumer applications will still need to bundle the browser app and the server
app separately. The browser application will be instantiated in an entry point
script that calls `ReactDOM.render()`, while the server application will be
called from a route handler on the server.

## Browser rendering

The root application component in the browser is `BrowserApp`.

```jsx
<BrowserApp routes={routes} store={store} basename={basename} />
```

Although consumer applications can supply the `props` directly, the platform
provides a helper function, `resolveAppProps` that should typically be used to
correctly instantiate the `store`, resolve the `basename` from the app data
provided by the server, and populate any asynchronous route components.

### Example

The browser entry script would typically have the following structure:

```jsx
import { resolveAppProps } from 'meetup-web-platform/lib/renderers/browser-render';
import makeRootReducer from 'meetup-web-platform/lib/store/reducer';

const appReducers = require('./reducers'); // map of reducer keys to reducer functions
const reducer = makeRootReducer(appReducers); // create the root reducer function

resolveAppProps(routes, reducer, middleware).then(props =>
  ReactDOM.render(
    <BrowserApp {...props} />,
    document.getElementById('outlet')
  )
);
```

Notes:

1. Consumer apps _must_ render the application at the element with an `id` of
   `'outlet'` - this div is provided by the platform server renderer.
2. If you need direct access to the `store`, it can be read from `props.store`
   in the resolved value from `resolveAppProps`.

## Components

The React components in `components/` are application-general wrappers of app-
specific UIs that provide the necessary React component lifecycle behavior to
enable navigation-related data fetching, and shared document structure like
`<head>` content and the icon SVG sprite.

- The app wrapper components: `<BrowserApp>` and `<ServerApp>`

  These components provide the top-level entry point for the React application
  tree. They should be used with `ReactDOM.render` and
  `ReactDOMServer.renderToString`, respectively

- `<PageWrap>`

  The top-level _rendering_ component for the React application - this should
  generally be used at root-level route in the passed in routes. _This could be
  phased out as a public component, and instead built into `<BrowserApp>` and
  `<ServerApp>`_

  The code for `PageWrap` is organized in a directory as a standalone 'package'
  because the relevant code is organized into a few separate 'internal' modules.

- `<Dom>`

  A React component used on the server to get a full `<html>` document string
  from `ReactDOMServer.renderToString()`. The actual application markup must
  be supplied as a raw HTML string in the `appMarkup` prop.

repository: patcon/meetup-web-platform

repo_name: patcon/meetup-web-platform