text:
# LinearRegression.jl Documentation
```@contents
```
LinearRegression.jl implements linear regression using the least-squares algorithm (relying on the sweep operator). This package is in the alpha stage. Hence it is likely that some bugs exist. Furthermore, the API might change in future versions.

The usage aims to be straightforward, a call to ```regress``` to build a linear regression model, and a call to ```predict_and_stats``` to predict data using the built linear regression model.

The regress call will compute some statistics about the fitted model in addition to the coefficients.

#### Number of observations and variables
The number of observations ``n`` used to fit the model.

The number of independent variables ``p`` used in the model.

#### Total Sum of Squares
The Total Sum of Squares (SST) is calculated but not presented to the user. In case of model with intercept the SST is computed with the following:
```math
\mathrm{SST}=\sum_{i=1}^{n}\left(y_{i}-\bar{y}\right)^2
```
And when there is no intercept with the following:
```math
\mathrm{SST}=\sum_{i=1}^{n} y_{i}^2
```

#### Error Sum of Squares
The Error Sum of Squares (or SSE) also known as Residual Sum of Square (RSS). This package uses the sweep operator (Goodnight, J. (1979). "A Tutorial on the SWEEP Operator." The American Statistician.) to compute the SSE.

#### Mean Squared Error
The Mean Squared Error (MSE) is calculated as
```math
\mathrm{MSE} = \displaystyle{\frac{{\mathrm{SSE}}}{{n - p}}}
```

The Root Mean Squared Error (RMSE) is calculated as
```math
\mathrm{RMSE} = \sqrt{\mathrm{MSE}}
```

The MSE is the estimator of σ̂² unless at least one robust covariance estimator is requested.

#### R² and Adjusted R²
The R² (R2 or R-squared) see (https://en.wikipedia.org/wiki/Coefficient_of_determination) is calculated with the following formula:
```math
\mathrm{R}^2 = 1 - \displaystyle{\frac{{\mathrm{SSE}}}{{\mathrm{SST}}}}
```
The Adjusted R² (ADJR2) is computed with the following formulas:

when it is a model with an intercept:
```math
\mathrm{ADJR}^2 = 1 - \displaystyle \frac{(n-1)(1-\mathrm{R}^2)}{n-p}
```
And when there is no intercept:
```math
\mathrm{ADJR}^2 = 1 - \displaystyle \frac{(n)(1-\mathrm{R}^2)}{n-p}
```

#### Akaike information criterion
The Akaike information criterion is calculated with the Linear Regression specific formula:
```math
\mathrm{AIC} = \displaystyle n \ln \left( \frac{\mathrm{SSE}}{n} \right) + 2p
```

#### t-statistic and confidence interval
The t-statistic is computed by using the inverse cumulative t-distribution (with ```quantile()```) with parameter (``n - p``) at ``1 - \frac{α}{2}``.

The standard errors of the coefficients are calculated by multiplying the Sigma (estimated by the MSE) with the pseudo inverse matrix (resulting from the sweep operator), out of which the square root of the diagonal elements are extracted.

The t-values are calculated as the coefficients divided by their standard deviation.

The upper bound of the confidence interval for each coefficient is calculated as the coeffiecent + coefficient's standard error * t_statistic.

The lower bound of the confidence interval for each coefficient is calculated as the coeffiecent - coefficient's standard error * t_statistic.

#### p-values

The p-values are computed using the F Distribution, the degree of freedom for each coefficent.

#### Variance inflation factor
Variance inflation factor (VIF) is calculated by taking the  diagonal elements of the inverse of the correlation matrix formed by the independent variables when there is an intercept in the model.

### Robust covariance estimators

#### Heteroscedasticity estimators
The user can select estimators from these list. If the user select "White" as an estimator then HC3 will be selected for a small size (n < 250) otherwise HC0 will be selected.
##### HC0
The following estimators can be calculated.
Having InvMat the pseudo inverse resulting from the sweep operator. And having xe being the matrix of the independent variables times the residuals. Then HC0 is calculated as:
```math
\textup{HC0} = \sqrt{diag(\textup{InvMat } \textup{xe}' \textup{xe} \textup{ InvMat})}
```

##### HC1
Having n being the number of observations and p the number of variables. Then HC1 is calculated as:
```math
\textup{HC1} = \sqrt{diag(\textup{InvMat } \textup{xe}' \textup{xe} \textup{ InvMat } \frac{n}{n-p})}
```

##### HC2
The leverage or hat matrix is calculated as:
```math
\textup{H} = \textup{X} (\textup{X'X})^{-1}\textup{X'}
```

xe is scaled by ``\frac{1}{1 - H}`` then
```math
\textup{HC2} = \sqrt{diag(\textup{InvMat } \textup{xe}' \textup{xe} \textup{ InvMat } )}
```

##### HC3
xe is scaled by ``\frac{1}{{\left( 1 - H \right)^2}}`` then
```math
\textup{HC3} = \sqrt{diag(\textup{InvMat } \textup{xe}' \textup{xe} \textup{ InvMat } )}
```

#### Heteroskedasticity and autocorrelation consistent estimator

Newey-West estimator calculation is not documented yet.
See [reference implementation](https://github.com/mcreel/Econometrics/blob/508aee681ca42ff1f361fd48cd64de6565ece221/src/NP/NeweyWest.jl) [current implementation](https://github.com/ericqu/LinearRegression.jl/blob/docu/src/newey_west.jl) for details.

## Functions
```@docs
regress(f::StatsModels.FormulaTerm, df::DataFrames.DataFrame; α::Float64=0.05, req_stats=["all"], remove_missing=false, cov=[:none])
predict_and_stats(lr::linRegRes, df::DataFrames.DataFrame; α=0.05, req_stats=["none"])
```

## Index

```@index
```


text:
---
layout: post
title: "Looking for Developers / Producer / Systemadministrator"
date: 2008-03-18 13:55
comments: true
categories: Web Development
author: Oliver Thylmann
---

We are looking for a few new people to bolster our development team at [Ormigo](https://ormigo.com/). If you know German, just go to our [jobs section](http://blog.ormigo.com/jobs/), but if you don't we are still happy to hear form you. The entire documentation, trac, wiki, is in english anyway. For those not knowing what we do, we are making the local market advertisable in a scalable way, helping local merchants to gain new customers. So there is ad server stuff to do (on Amazon's AWS Infrastructure), billing backends to handle, statistical analysis with loads of data, optimization of lead processes, design frameworks for landing pages, customer care infrastructure with loads of people on the phone, lots of micro formats, ... . Most of what we have done up till now is not visible to the naked eye. The opportunities are endless, which is exactly why we chose that market.

So here is a short summary of the jobs currently advertised for the development team:

	* Web Developer: Our platform is written in CakePHP and we are looking for a core PHP developer, somebody with the experience to know to write unit tests first, and code second. Knowledge with recommendation engines, ad servers, cloud computing, scaling big systems, ... is always appreciated.
	* Web Designer / Producer: We need somebody that knows HTML and CSS inside out, has design knowledge, understands a bit of JavaScript and possibly PHP. This has a real focus on the generation of customer contacts for local merchants, over hundreds of products, with loads of different partners running ads, ... handling all of this in a scalable manner.
	* System Administrator: This is actually the best overarching title that I came up with. We don't really have titles at Ormigo, but sys admin seems to be fitting to some extent. We need somebody to take care of the servers in-house, which includes handing our Amazon infrastructure, deploy processes, customer care infrastructure, testing environment, and so on. Dependent on the person, I can see them focussing more on the stuff other than direct server management, which would be their responsibility, but possibly not doing.

So those are the main positions we are looking for at the moment. Leave a comment or mail me at oliver at thylmann.com with your documents. Looking forward to hearing from you.

license: MIT

branch_name: refs/heads/master

extension: markdown

license_type: permissive


text:
# Python Overview

Python is a general purpose, dynamically typed and interpreted,
object oriented programming language that was created in the late 1980s by Guido van Rossum.

Python’s design philosophy revolves around readability. It’s meant to be easy to read and
easy to write. This is accomplished by using white-space to delineate code blocks
instead of the more traditional curly brackets and semi-colons.

### How Python Runs
Generally all python code is run using an interpreter.
The most popular and original interpreter is called CPython, because it’s implemented in the c programming language.
Several other interpreters exist however, many of which are implemented in languages other than C like Java and C#.

The most common Python interpreter CPython, uses an automatic garbage collector to manage memory.
And Python is widely known for having a non-traditional, minimalist syntax
which is largely based on white space, and designed to be clean and readable.

### Python Versions

When first getting into python it can be a bit confusing because unlike many
other programming languages Python has two major, non-compatible versions that are currently widely used.

Python version 2.7.3, released in 2012, is the last iteration of version 2 that was released.
 This version is for the most part, backwards compatible with all previous versions.

In 2008, the Founder, Guido van Rossum decided to clean up the Python codebase
and overhaul a lot of the things in Python 2 that he didn’t like, thus creating Python 3.

Python 3 was adopted slowly at first, mainly because it is not backwards compatible with Python 2,
and there was a huge eco-system of package libraries written for Python 2 which now would not work in python 3.

But now-a-day’s the Python 3 ecosystem has for the most part caught up,
making Python 3 the obvious choice for new developers looking to learn the language.

 Python 3 is also the version that will be taught in this tutorial.

### Choosing an IDE

Many developers choose to write Python using a specialized integrated development environment.
Three of the most popular are Eclipse!, PyCharm and Netbeans.

extension: md


text:
Sort Dumb Photos
========

My camera phone creates filenames like<PHONE_NUMBER>.jpg, where the
digits represent mmddyytttt. Well, that's dumb. The years are in the
middle? It makes it extremely hard to sort them into folders. See also
http://xkcd.com/1179/

So this script sorts them into folders for me.

Usage: ./sort_dumb_photos.pl

Run it in a directory with a bunch of jpgs and it will create
a subdirectory for each year and move the jpgs appropriately. I
wouldn't try it when there are jpgs that don't have numeric mmddyy...
filenames.

repository: zimolzak/sort-dumb-photos

repo_name: zimolzak/sort-dumb-photos


text:
# Merge Sort

## Challenge
Implement an mergesort method to sort an array.

## Approach & Efficiency
Big O is (n), I approached it by keep splitting each array until you cannot anymore than sort as you put it back together.

## API

### MergeSort
I implemented an method where it breaks down array divided by 2 until cannot repeat than sort array as it puts it back together.

[Link to Code](https://github.com/Antberry/data-structures-and-algorithms/blob/master/401codechallenges/src/main/java/mergesort/MergeSort.java)

[Link to Test](https://github.com/Antberry/data-structures-and-algorithms/blob/master/401codechallenges/src/test/java/mergesort/MergeSortTest.java)

[Whiteboard](../assets/insertsort.jpg)

[Lecture](https://github.com/Antberry/data-structures-and-algorithms/blob/master/401codechallenges/src/main/java/mergesort/Lecture-notes)

repository: Antberry/data-structures-and-algorithms

gha_language: JavaScript

gha_license_id: MIT

repo_name: Antberry/data-structures-and-algorithms


text:
---
title: "Doctrine 1.2 Nearing Stable Release"
authorName: jwage
authorEmail:
categories: [release]
permalink: /2009/10/06/doctrine-1-2-nearing-stable-release.html
---
Today I am happy to release to you the second ALPHA release of Doctrine
1.2. Honestly, we didn't receive many reports of regressions or problems
with the new things in Doctrine 1.2 and we know lots of people have
upgraded and using it so we feel it is a pretty stable release already.

You can view what all changed in this release by checking the
[changelog](https://www.doctrine-project.org/change_log/1_2_0_ALPHA2) and
you can snag it from the
[download](https://www.doctrine-project.org/download) page.

We hope that everything goes fine from here and the next release will be
BETA1 followed by an RC and stable release. Please give 1.2 a try and
report any regressions to us so that we can be sure to get them fixed
before the final stable release.

repository: doctrine/doctrine-website

gha_language: PHP

repo_name: doctrine/doctrine-website


text:
Contributing to Surf
====================
This document outlines the guidelines for contributing to the project.

* [Issues](#issues)
* [Bug Reports](#bug-reports)
* [Feature Requests](#feature-requests)
* [Pull Requests](#pull-requests)

## Issues

The [issue tracker](https://github.com/headzoo/surf/issues) is
the preferred channel for [bug reports](#bug-reports), [features requests](#feature-requests)
and submitting [pull requests](#pull-requests).

## Bug Reports

A bug is a _demonstrable problem_ that is caused by the code in the repository.

Guidelines for bug reports:

1. **Use the GitHub issue search** - check if the issue has already been reported.

2. **Check if the issue has been fixed** - try to reproduce it using the latest `master` or `dev` branch
in the repository.

## Feature Requests

Feature requests are welcome. But take a moment to find out whether your idea
fits with the scope and aims of the project. It's up to *you* to make a strong
case to convince the project's developers of the merits of this feature. Please
provide as much detail and context as possible.

**IMPORTANT**: By submitting a patch, you agree to allow the project owners to
license your work under the terms of the [MIT License](LICENSE.md).

repository: cardigann/cardigann

gha_language: Go

repo_name: cardigann/cardigann


text:
---
title: Dockerizing your application for Java
permalink: /handbooks/java/
---

## What is this handbook for?

This is a community leader handbook to run "Dockerizing Your Application for JAVA" workshop. This will cover every aspect of conducting workshop starting from setting up an event page till the completion of the successful workshop.

### Features of this workshop

- Audience : 5 to 100
- Technical Skills Required : Basic knowledge of Linux & JAVA
- Length : 4 hours (including coffe and lunch breaks)

## Checklists

### Before the workshop

S.No. | Name of Objectives | Status |
:------------ | :-------------| :-------------|
1 | [Getting Familiar with Bevy Virtual](/housekeeping/virtual/README.md) |  ☑ |
2 | [Planning an Event Agenda](/housekeeping/plan-an-event-agenda/README.md) |  ☑ |
3 | [Setting up Event Registration Page](/housekeeping/event/README.md) | ☑ |
4 | [Sending confirmation email for workshop](/housekeeping/email/README.md) |  ☑ |

### During the workshop

S.No. | Name of Objectives | Status |
:------------ | :-------------| :-------------|
5 | [Conducting Attendee Survey](/housekeeping/attendeesurvey/README.md) |  ☑ |

### After the workshop

S.No. | Name of Objectives | Status |
:------------ | :-------------| :-------------|
6 | [Post-Event FollowUp](/housekeeping/postevent/README.md) |  ☑ |
7 | [Community Leader Survey](/housekeeping/clsurvey/README.md)  |  ☑ |

## Recommended Agenda

| Description | Timing |
| --- | --- |
| Welcome | 8:45 AM to 9:00 AM |
| [Setting up Infrastructure](java/infrastructure/README.md) | 9:00 AM to 9:30 AM |
| [Basics of Docker](#basics-of-docker---1-hour) | 9:30 AM to 10:30 AM |
| [Building a Docker Image](#building-a-docker-image---1-hour) | 10:15 AM to 11:15 AM |
| Coffee/Tea Break | 11:15 AM to 11:30 AM |
| [Building a Docker Image for Java 11](#building-a-docker-image-for-java-11---1-hour) | 11:30 AM to 12:30 PM|
| Lunch | 1:00 PM to 2:00 PM |
| Getting Started with Dockerfile| 2:00 PM to 3:30 PM |
| [Multi-container Application using Docker Compose](#multi-container-application-using-docker-compose---30-min) | 3:30 PM to 4:30 PM|
| [Multi-container Application using Docker Compose & Swarm Mode](#multi-container-application-using-docker-compose-and-swarm---30-min) | 4:00 PM to 4:30 PM |
| Coffee/Tea Break | 4:00 PM to 4:30 PM |
| [Java IDE](#java-ide---1-hour) | 4:45 PM to 5:45 PM |
| [CI-CD using Docker](#ci-cd-using-docker) | 5:45 PM to 6:00 PM |

## Pre-requisite:

repository: inovizz/community

repo_name: inovizz/community


text:
---
layout: default
major_version: 1.0
title: Raw Aggregation Stage
---

## Raw Aggregation Stage

You can also implement aggregate stage using raw BSON (e.g. when there is no convenient stage yet provided), using the [`PipelineOperator`](https://javadoc.io/doc/org.reactivemongo/reactivemongo_{{site._1_0_scala_major}}/{{site._1_0_latest_minor}}/reactivemongo/api/collections/GenericCollection.html#PipelineOperator=AggregationOps.this.AggregationFramework.PipelineOperator) factory.

```scala
import scala.concurrent.ExecutionContext

import reactivemongo.api.bson._
import reactivemongo.api.bson.collection.BSONCollection

def customAgg(coll: BSONCollection)(implicit ec: ExecutionContext) =
  coll.aggregateWith[BSONDocument]() { framework =>
    import framework.PipelineOperator

    val customStage = // { $sample: { size: 2 } }
      PipelineOperator(BSONDocument("$sample" -> BSONDocument("size" -> 2)))

    List(customStage)
  }
```

[Previous: Aggregation Framework](./aggregation.html)

repository: SamTheisens/reactivemongo-site

branch_name: refs/heads/gh-pages

gha_language: HTML

repo_name: SamTheisens/reactivemongo-site


text:
```@docs
LGG09
```

## Method

In the following subsections we outline the method of [[LGG09]](@ref) to solve
linear set-based recurrences using support functions, first the homogeneous case
and then the inhomogeneous case without wrapping effect.
We also discuss the special case of real eigenvalues.

## Homogeneous case

Consider the set-based recurrence

```math
X_{k+1} = \Phi X_k,\qquad 0 \leq k \leq N
```
where $\Phi \in \mathbb{R}^{n\times n}$ and $X_0 \subseteq \mathbb{R}^n$ are given.
By unrwapping the recurrence, $X_k = \Phi^k X_0$ for all $k \geq 0$. Let $d \in \mathbb{R}^n$ be a given
*template direction*. Using the property of support functions $\rho(d, A X) = \rho(A^T d, X)$
for any matrix $A$ and set $X$, we have that

```math
ρ(d, X_k) = \rho(d, \Phi^k X_0) = \rho((\Phi^T)^k d, X_0).
```
In this way we are able to reason with the sequence $\{X_0, X_1, X_2, \ldots, X_N\}$
by evaluating the support function of the initial set $X_0$ along the directions
$\{d, \Phi^T d, (\Phi^T)^2 d, \ldots, (\Phi^T)^N d\}$.

## Inhomogeneous case

The inhomogeneous case generalizes the previous case by taking, at each step,
the Minkowski sum with an element from the sequence $\{V_0, V_1, V_2, \ldots, V_N\}$:

```math
X_{k+1} = \Phi X_k \oplus V_k,\qquad 0 \leq k \leq N.
```
Let us write such recurrence in the unrapped form,

```math
\begin{aligned}
\quad X_1 &= \Phi X_0 \oplus V_0 \\[1mm]
\quad X_2 &= \Phi X_1 \oplus V_1 = \Phi^2 X_0 \oplus \Phi V_0 \oplus V_1 \\[1mm]
\quad X_3 &= \Phi X_2 \oplus V_2 = \Phi^3 X_0 \oplus \Phi^2 V_0 \oplus \Phi V_1  \oplus V_2 \\[1mm]
\quad &\vdots \\[1mm]
\quad X_k &= \Phi^k X_0 \oplus \left( \bigoplus_{i=0}^{k-1} \Phi^{k-i-1} V_i \right)
\end{aligned}
```
where the big Minkowski sum is just an abbreviation for
$\Phi^{k-1} V_0 \oplus \Phi^{k-2} V_1 \oplus \Phi^{k-3} V_2 \oplus \ldots \oplus \Phi V_{k-2} \oplus V_{k-1}$.

Let $d \in \mathbb{R}^n$ be a given template direction. Using the additive property of
support functions, $\rho(d, X \oplus Y) = \rho(d, X) + \rho(d, Y)$ for any sets $X$ and $Y$,
we have that

```math
\begin{aligned}
\quad \rho(d, X_1) &= \rho(\Phi^T d, X_0) + \rho(d, V_0) \\[1mm]
\quad \rho(d, X_2) &= \rho((\Phi^T)^2 d, X_0) + \rho(\Phi^T d, V_0) + \rho(d, V_1) \\[1mm]
\quad \rho(d, X_3) &= \rho((\Phi^T)^3 d, X_0) + \rho((\Phi^T)^2 d, V_0) + \rho(\Phi^T d, V_1) + \rho(d, V_2) \\[1mm]
\quad &\vdots \\[1mm]
\quad \rho(d, X_k) &= \rho((\Phi^T)^k d, X_0) + \sum_{i=0}^{k-1} \rho( (\Phi^T)^{k-i-1} d,  V_i).
\end{aligned}
```
In a similar fashion to the homogeneous case, the method allows to efficiently reason
about the the sequence $\{X_0, X_1, X_2, \ldots, X_N\}$ by evaluating the support
function of the initial set $X_0$ and the input sets $\{V_k\}_k$ along the directions
$\{d, \Phi^T d, (\Phi^T)^2 d, \ldots, (\Phi^T)^N d\}$. Implementation-wise, we update
two sequences, one that accounts for the homogeneous term, and another
sequence that accounts for the effect of the accumulated inputs.

## Implementation details

The reach-set representation used is a [TemplateReachSet](@ref), which stores the
directions used (vector of vectors) and the support function evaluated at each direction
(matrix, see below). The set representation, `set(R::TemplateReachSet)`, is either a polyhedron in constraint form
(`HPolyhedron`), or a polytope (`HPolytope`) if the directions are bounding, i.e.
the template directions define a bounded set.

The computed support function values can accessed directly through the field
`sf::SN` of each template reach-set. Here `sf` is an array view of type `::Matrix{N}(undef, length(dirs), NSTEPS)`:
each row corresponds to one of the template directions and each column corresponds to a fixed iteration index $k \geq 0$.

If you use directions from the canonical basis of $\mathbb{R}^n$, it is recommended to define `LazySets.Arrays.SingleEntryVector`
or "one-hot" arrays as they are commonly called, because there are methods that dispatch on such type of arrays efficiently.

## Parallel formulation

The support functions of the sequence $\{X_k\}_k$ along different directions can be
computed in parallel. Indeed, if $d_1$ and $d_2$ are two given template directions, two different processes
can independently compute $\rho(d_1, X_k)$ and $\rho(d_2, X_k)$ for all $k = 0, 1, \ldots, N$
using the methods described above. Once both computations have finished, we can store
the resulting support functions in the same array. Use the flag `threaded=true` to
use this method.

Implementation-wise the function `_reach_homog_dir_LGG09!` spawns differen threads
which populate the matrix `ρℓ::Matrix{N}(undef, length(dirs), NSTEPS)` with the computed
values. Hence each thread computes a subset of distinct rows of `ρℓ`.

## Real eigenvalues

If the spectrum of the state matrix only has real eigenvalues, the sequence of
support functions can be computed efficiently if we work with a template
consisting of eigenvectors of $\Phi^T$. This idea is described in [[LGG09]](@ref)
and we recall it here for convenience.

The method stems from the fact that if $(\lambda, d)$ is an eigenvalue-eigenvector
pair of the matrix $\Phi^T$, with $\lambda \in \mathbb{R}$, then
$\Phi^T d = \lambda d$, and if we apply $\Phi^T$ on both sides of this identity, we get
$(\Phi^T)^2 d = \Phi^T (\Phi^T d) = \Phi^T(\lambda d) = \lambda^2 d$.
In more generality, it holds that $(\Phi^T)^k d  = \lambda^k d$ for all $k \ge 1$.
Applying this relation to the support function recurrence described above, we get
for the general inhomogeneous and possibly time-varying inputs case:

```math
\rho(d, X_k) = \rho(\lambda^k d, X_0) + \sum_{i=0}^{k-1} \rho(\lambda^{k-i-1} d, V_i).
```
To further simplify this formula, we analyze different cases of $\lambda$.
If $\lambda = 0$, then $\rho(d, X_k) = \rho(d, V_k)$ for all $k \geq 1$, so we focus
on either $\lambda$ being positive or negative. To further simplify the computation
of $\rho(d, X_k)$, we can use the property $\rho(\lambda d, X) = \lambda \rho(d, X)$
if $\lambda \geq 0$. We now consider the cases $\lambda > 0$ and $\lambda < 0$.

**Case $\lambda > 0$.** Then $\lambda^k > 0$ for all $k \geq 1$,
and

```math
\rho(d, X_k) = \lambda^k \rho(d, X_0) +  \sum_{i=0}^{k-1} \lambda^{k-i-1} \rho(d, V_i).
```
We are left with evaluating the support function only at $\rho(d, X_0)$  and $\rho(d, V_i)$
to construct the full sequence $\{\rho(d, X_k)\}_{k}$. Moreover, if the $V_i$'s are constant
we can extract them from the right-hand side sum and use that
```math
\sum_{i=0}^{k-1} \lambda^{k-i-1} = 1 + \lambda + \ldots + \lambda^{k-1} = \dfrac{1 - \lambda^k}{1 - \lambda}.
```

**Case $\lambda < 0$.** Since $\lambda^k = (-1)^k (-\lambda)^k$ and $\lambda < 0$, then
$\lambda^k$ is positive if $k$ is even, otherwise it is negative. So we can write:

```math
\rho(d, X_k) = (-\lambda)^k \rho((-1)^k d, X_0) + \sum_{i=0}^{k-1} (-\lambda)^{k-i-1} \rho((-1)^{k-i-1} d, V_i).
```
The main difference between this case and the previus one is that now we have to evaluate
support functions $\rho(\pm d, X_0)$ and $\rho(\pm d, V_i)$. Again, simplification takes place
if the $V_i$'s are constant and such special case is considered in the implementation.


text:
# Diamond Selection Order

This is a selection problem solved using recursion.

## The Problem

There are *n* diamonds of different values in a queue. It is possible that *2* or more diamonds can have the same price. You are competing against an opponent and your goal is to maximize your winnings. Design an algorithm that returns which diamonds you should choose in order to achieve your goal.

### The Rules

Both you and the opponent can take a diamond either from the start or the end of the queue. You play first.

#### Key Assumption

The opponent **always** chooses the most valuable diamond.

repository: gkamtzir/diamond-selection-order

repo_name: gkamtzir/diamond-selection-order


text:
# How to create a WebHelp custom component

This topic demonstrates how to use several customization methods of the WebHelp output to define and implement a custom component for the generated HTML pages.

## Predefined components

The WebHelp output is based on a set of [HTML Page Layout Files](https://www.oxygenxml.com/doc/versions/23.0/ug-webhelp-responsive/topics/whr_publishing_template_contents.html#ariaid-title8) which define the default layout of the generated pages. Each layout file is made of a set of various components. Each component is described using an associated XML element that is processed at the generation time resulting in its associated component being included in the output HTML pages.

Here are a few examples of predefined components: **Logo**, **Title**, **Menu**, **Search Input**, **Topics Tiles**, **Topic Breadcrumb**, **Topic Content**, **Publication Table of Contents**, etc. A complete list with all the available components is available here: [Layout of the Responsive Page Types](https://www.oxygenxml.com/doc/versions/23.0/ug-webhelp-responsive/topics/whr-html5-pages.html).

For example the page component that is used to define the Search Input available in the WebHelp HTML pages is defined as follows:

```xml
<!-- Search form -->
<whc:webhelp_search_input class="navbar-form wh_topic_page_search search" role="form"/>
```

At publishing time the above component will be expanded into:

```xml
<div class=" wh_search_input navbar-form wh_topic_page_search search">
    <form id="searchForm" method="get" role="search" action="../search.html">
        <div>
            <input type="search" placeholder="Search "
                class="wh_search_textfield ui-autocomplete-input" id="textToSearch"
                name="searchQuery" aria-label="Search query" required="required" autocomplete="off"/>
            <button type="submit" class="wh_search_button" aria-label="Search">
                <span class="search_input_text">Search</span>
            </button>
        </div>
    </form>
</div>
```

## Customization methods

The most common customization methods of the WebHelp Responsive output include:

-   applying [custom CSS styles](https://www.oxygenxml.com/doc/versions/23.0/ug-webhelp-responsive/topics/webhelp-customizing-with-css.html) to change the default layout and styles
-   [inserting additional HTML content](https://www.oxygenxml.com/doc/versions/23.0/ug-webhelp-responsive/topics/wh-add-custom-html.html) using one of the available [HTML Fragments Extension Points](https://www.oxygenxml.com/doc/versions/23.0/ug-webhelp-responsive/topics/whr_publishing_template_contents.html#ariaid-title6)
-   extending the default processing using [XSLT Extension Points](https://www.oxygenxml.com/doc/versions/23.0/ug-webhelp-responsive/topics/whr_publishing_template_contents.html#ariaid-title5)
-   configuring the available [Transformation Parameters](https://www.oxygenxml.com/doc/versions/23.0/ug-webhelp-responsive/topics/webhelp-responsive-plugin-additional-parameters.html)

## Use case

Let's consider the following use case: you have a DITA project for the User Manual of one of your products. It contains various topics describing the product's features. You also have various video demonstrations available on your website. You may want to link a video demonstration for certain feature with its associated DITA topic in the User Manual.

You could simply add a link somewhere in your DITA topic's content \(topic's body \), but this approach would not be very suitable for the printable version \(PDF for example\) of your User Manual. Thus you need to include the link to the associated video demonstration only in the WebHelp output of your User Manual.

One way to link a video with its associated topic is to include its URL in the topic's metadata section. For example:

```xml
<prolog>
    <metadata>
        <othermeta name="video-link" content="https://www.youtube.com/watch?v=zNmXfKWXwO8"/>
    </metadata>
</prolog>
```

Next, you need to instruct WebHelp to pick up the URL from the topic's metadata and generate a link in a specific location of the HTML output page. You can achieve this by creating your own WebHelp custom component.

## Custom component

You can combine several of the available customization methods to define and implement your own WebHelp custom component.

![Custom component](custom-component.png "Custom component")

To create a custom component that displays a link to the current topic's associated video tutorial follow these steps:

1.  Define your component. For example it may have the following form:

    ```xml
    <comp:video-link xmlns:comp="http://example.com/custom-components"/>
    ```

    As you can see, the component is an XML element belonging to a custom defined namespace.

2.  Next you have to insert the component in your topic pages. To do this you will have to save the associated XML element in an HTML Fragment file \(let's consider that the file is named video-link-fragment.xml\).
3.  Next you have to reference the HTML Fragment file in you current Publishing Template's [descriptor file](https://www.oxygenxml.com/doc/versions/23.0/ug-webhelp-responsive/topics/whr_publishing_template_contents.html#ariaid-title2) and associate it with an HTML Fragment placeholder that is available for the topic pages \(`webhelp.fragment.before.topic.toolbar` in this case\):

    ```xml
    <html-fragments>
        <fragment file="component/html-fragment/video-link-fragment.xml" placeholder="webhelp.fragment.before.topic.toolbar"/>
    </html-fragments>
    ```

    **Note:** The HTML Fragment file is referenced using a path relative to the Publishing Template's root directory.

4.  Create a custom XSLT file that processes the custom component and picks up the video URL available in the current topic's metadata and generates a link to the page containing the video:

    ```xml
    <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
        xmlns:xs="http://www.w3.org/2001/XMLSchema"
        xmlns:comp="http://example.com/custom-components"
        exclude-result-prefixes="xs comp"
        version="3.0">

        <!-- Custom component implementation -->
        <xsl:template match="comp:video-link" mode="copy_template">
            <xsl:param name="ditaot_topicContent" tunnel="yes"/>
            <!-- Look for a 'video-link' <meta> element in the current topic content -->
            <xsl:variable name="videoLinkMeta"  select="$ditaot_topicContent//*:meta[@name='video-link']"/>
            <xsl:if test="exists($videoLinkMeta)">
                <div class="video-link-container">
                    <a href="{$videoLinkMeta[1]/@content}"
                       class="video-link" target="_blank" aria-label="Video">
                        <span>Video</span>
                    </a>
                </div>
            </xsl:if>
        </xsl:template>

    </xsl:stylesheet>
    ```

    The HTML content generated for your component will look as follows:

    ```xml
    <div class="video-link-container">
        <a href="https://www.youtube.com/watch?v=zNmXfKWXwO8" class="video-link" target="_blank"
            aria-label="Video">
            <span>Video</span>
        </a>
    </div>
    ```

5.  Reference the above XSL file in your Publishing Template's descriptor file using the XSLT extension point associated with the XSL module that generates an HTML file for each DITA topic:

    ```xml
    <xslt>
        <extension file="component/xsl/video-link-impl.xsl" id="com.oxygenxml.webhelp.xsl.dita2webhelp"/>
    </xslt>
    ```

6.  Create a custom CSS file containing the rules for styling the output for your component:

    ```css
    @import url('https://fonts.googleapis.com/icon?family=Material+Icons');

    .video-link-container {
        display: flex;
        align-items: center;
        flex-grow: 10;
        justify-content: flex-end;
    }

    .video-link {
        display: flex;
        align-items: center;
        color: #fff !important;
    }

    .video-link:before {
        content: "smart_display";
        font-family: 'Material Icons';
        font-size: 20px;
        display: inline-block;
        word-wrap: normal;
        white-space: nowrap;
    }

    .video-link span {
        display: none;
    }

    .wh_right_tools {
        padding: 0;
    }
    ```

7.  Reference the above CSS file in your Publishing Template's descriptor file:

    ```xml
    <resources>
        <!-- .... -->
        <css file="component/css/video-link.css"/>
    </resources>
    ```

8.  The output will look like in the following image:

    ![Link to video tutorial](link-to-video.png "Link to video tutorial")


text:
# VueJS Demo

## About

This demo showcases the capabilities of VueJS and Bulma.  VueJS is a lightweight, JavaScript application framework while Bulma is a lightweight CSS framework.  Both libraries are good for building rich, interactive web applications such as Single Page Applications (SPA) or Progressive Web Applications (PWA).

## **Incomplete**

Due to time limitations this demo is still a **work in progress**


text:
---
"title": "Error Reporting Logs"
---
You can download the error logs for every run using Databand UI. With the help of the logs, you can access the command-line arguments that were executed and the log file for the actual task with the full log from the database.

Error logs make the monitoring of different states and task run attempts easier. They also simplify customer support as you can send your logs to Databand for troubleshooting without omissions, errors, missing database states, etc.

Exporting logs is available for both [Tracking Quickstart](doc:tracking-quickstart) and [Orchestration Quickstart](doc:orchestration-quickstart) as this feature is global and covers an entire task run.

### Downloading the logs
To download the error reporting logs for a run in a pipeline:
* Open the pipeline to see the run and open it

![Error reporting logs 01](https://files.readme.io/9af3ca4-Error-reporting-logs-01.png)

* In the upper right corner of Databand UI for that run, click the ‘Download Logs’ button. The web server will pack the logs for this run into a \*.tar.gz archive file that will be downloaded to your machine.

![Error reporting logs 02](https://files.readme.io/d272077-Error-reporting-logs-02.png)

The resulting \*.tar.gz archive file encapsulates an entire task run and contains logs of all the attempts at task execution in a separate folder with subfolders for task attempts, and a separate system task folder `dbnd_driver` (for the DBND SDK-performed tracking; for non-DBND runs, the name of the driver folder will be `orchestrator-name_driver`).

![Error reporting logs 03](https://files.readme.io/bcfc1fc-Error-reporting-logs-03.png)

Let’s take a closer look at the logging artifacts.

### System task folder (dbnd_driver)

`dbnd_driver` is the system task that runs all other tasks. Its log documents the entire Databand task run and Spark logs. Within `dbnd_driver`, you can find the number of task run attempts and states.

The information within the `dbnd_driver` folder will provide the most accurate clues to the existing issues in general execution, such as issues with Kubernetes or Spark dependencies. The system task folder will only appear as`dbnd_driver` for pipelines that use the [DBND SDK orchestration](doc:orchestration-quickstart).

Logs’ archive for tasks that were run on Airflow and are only tracked by DBND will not contain a dbnd_driver task. In this case, there will be an archive with folder(s) that describe(s) task(s) and a system \*_driver folder (for example, pyspark_driver). A \*_driver log folder also contains \*.log and a \*.cli files that help identify and resolve an issue. The names of such files match the task run attempt number.

If you switch to a specific task attempt log folder for this run, you’ll see a shorter, more concise log.

### Task run attempt folders and states
Task run attempt folders help identify the issues in specific tasks and make it easier to navigate the different steps of the execution, for example, a Python task that failed or some code that doesn’t work.

There are three possible attempt states:
* failed - run attempt failed
* success - run attempt was successful
* canceled - run attempt was canceled

If a task was run three times, failed during the first two attempts, and eventually succeeded, you will see three attempt folders under this task - two in a ‘failed’ state and one that is a ‘success’. The number in the name of the folder is the task run attempt number.

![Error reporting logs 04](https://files.readme.io/1342524-Error-reporting-logs-04.png)

All task run attempt folders contain \*.log and \*.cli files that help identify and resolve an issue. Logs for a specific task only contain the commands and the log for this particular task. The names of such files match the task run attempt number.

### CLI files
The \*.cli files in the log archive are text files with the list of the command-line arguments that were executed.

Example contents of a \*.cli file in a log archive:
```
dbnd run dbnd_docker.docker.docker_build.DockerBuild --set docker_file=etc/build_docker/Dockerfile.dbnd_examples --set image_name=gcr.io/dbnd-dev-260010/databand --set tag=dbnd_build_20210127_105541 --env gcp_k8s --set task_target_date=2021-01-27 --set task_version=20210127_105559
```

These files are added to the log archive for convenience and are mostly used for context. A \*.cli file doesn’t describe the whole configuration, but it provides useful hints towards what was changed in the configuration. It also contains the ‘parent’ task - like the root pipeline that was executed.

This is helpful for providing more clarity to a \*.log file as \*.cli files contain such small helpful pieces of information like configuration values. For example, there can be different Spark tasks, and the \*.cli file can provide the information on Python the wheel file used for the dependencies.

### Log files
The \*.log files provide better observability and an overview of the execution, dividing it into smaller tasks and describing all the steps and events in the task run. There is one \*.log file per task (all of them are also contained in the dbnd_driver log, but they are divided by tasks in the task folders, making it easier to read and navigate the logs).

Example \*.log file contents:

```bash
[2021-01-27 10:57:56,764] {tracking_store_console.py:103} INFO -
[36m====================
[0m[36m= Running task dbnd_sanity_check__48f02c8ac2(dbnd_sanity_check)
[0m [1mTASK[0m       : task_id=dbnd_sanity_check__48f02c8ac2  task_version=1  env=gcp_k8s  env_cloud=gcp  env_label=dev  task_target_date=2021-01-27
 [1mTIME[0m       : start=2021-01-27 10:57:56.760983+00:00
 [1mTRACKER[0m    : http://databand-demo-develop.dbnd.local/app/jobs/dbnd_sanity_check/34bc8b52-608e-11eb-8982-acde48001122/541f05b0-608e-11eb-9bde-acde48001122
 [1mTASK RUN[0m   : task_run_uid=541f05b0-608e-11eb-9bde-acde48001122  task_run_attempt_uid=541f218a-608e-11eb-b5d2-acde48001122  state=TaskRunState.RUNNING
 [1mLOG[0m        : local=/Users/user/development/databand-delta/data/dbnd/log/2021-01-27/2021-01-27T105545.132695_dbnd_sanity_check_elastic_swirles/tasks/dbnd_sanity_check__48f02c8ac2/1.log  remote=gs://dbnd-dev-260010/dev/dbnd_root/dev/2021-01-27/dbnd_sanity_check/dbnd_sanity_check_48f02c8ac2/meta/attempt_1_541f218a-608e-11eb-b5d2-acde48001122/1.log.csv
 [1mPARAMS:[0m    :
Name        Kind    Type      Format    Source                               -= Value =-
check_time  param   datetime            d.t.b.s.dbnd_sanity_check[defaults]  2021-01-27T125541.799523
result      output  str       .txt                                           "gs://dbnd-dev-260010/dev/dbnd_root/dev/2021-01-27/dbnd_sanity_check/dbnd_sanity_check_48f02c8ac2/result.txt"
[36m=
[0m[36m====================
[0m
[2021-01-27 10:57:56,767] {api_client.py:38} INFO - Webserver session does not exist, creating new one
[2021-01-27 10:57:56,767] {api_client.py:69} INFO - Initialising session for webserver
[2021-01-27 10:57:56,798] {api_client.py:85} INFO - Got csrf token from session
[2021-01-27 10:57:56,799] {api_client.py:89} INFO - Attempting to login to webserver
[2021-01-27 10:57:56,953] {sanity.py:15} INFO - Running Sanity Check!
[2021-01-27 10:57:56,954] {tracking_store_console.py:168} INFO - Task dbnd_sanity_check metric: Happiness Level=High
[2021-01-27 10:57:56,985] {sanity.py:17} INFO - Your system is good to go! Enjoy Databand!
[2021-01-27 10:57:57,290] {tracking_store_console.py:168} INFO - Task dbnd_sanity_check metric: marshalling_result=303.5738468170166
[2021-01-27 10:57:57,747] {tracking_store_console.py:98} INFO - Task dbnd_sanity_check__48f02c8ac2(dbnd_sanity_check) has been completed!
```

### Privacy considerations and recommendations
The information provided in the log archives might sometimes contain API tokens or other valuable information and credentials. This is why we do not recommend putting such information into the CLI, as a general rule.

If you absolutely need to, manually delete the sensitive information from the logs before sending the logs to Databand for troubleshooting.

repository: databand-ai/dbnd

branch_name: refs/heads/develop

gha_language: Python

repo_name: databand-ai/dbnd


text:
---
title: Notifications
description: Notifications are a way to keep your users/customers notified of any Incidents update your System may have. Viewers of your Status Page can access the Choices below by clicking the Subscribe button.
date: 2018-10-12T17:28:04Z
permalink: /guide/notifications
---

# Notifications <Badge text="0.2.0+"/>

Notifications are a way to keep your users/customers notified of any Incidents update your System may have. Viewers of your Status Page can access the Choices below by clicking the Subscribe button.

::: tip
Most of these Notifications Features are enabled by default, but you can disable them in your config file. More info [here](../config/README.md#notifications).
:::

## Web Push <Badge text="0.4.0+"/>

Your users/customers can subscribe to Web Push notifications from their browsers. These notifications can only be sent to users who have opted-in to receive these notifications. Web push notifications or browser notifications are supported by Chrome, Firefox, Edge, and Safari.

Currently, Statusfy supports only one Provider: [OneSignal](#onesignal).

### OneSignal <Badge text="0.4.0+"/>

[OneSignal][onesignal-home] is a Free, high volume, and reliable push notification service for websites and mobile applications.

## Atom and RSS Feeds <Badge text="0.2.0+"/>

These feeds include all past Incidents and Scheduled Maintenances. Your users/customers can use Feeds Readers or tools like [IFTT][iftt-rss] and [Zapier][zapier-rss] to receive updates from these feeds.

## iCalendar <Badge text="0.2.0+"/>

Your users/customers can subscribe to a calendar containing all of your upcoming and past Scheduled Maintenances. The Calendar is published using iCalendar, a popular format that is supported by most modern calendar applications.

These are the events that are included in the Calendar:

- All active and completed Scheduled Maintenances.
- All upcoming Scheduled Maintenances.

## Twitter <Badge text="0.2.0+"/>

Currently, with this option, you can define Twitter accounts that your users can access to receive updates.

## Support Site <Badge text="0.2.0+"/>

Define an external Support Site your users can access to receive updates from other sources you may want to provide.

[iftt-rss]: https://ifttt.com/feed
[zapier-rss]: https://zapier.com/apps/rss/integrations
[onesignal-home]: https://onesignal.com/


text:
title: Cleaver Select Theme
author:
  name: Falko Krause
  github: select
  url: https://github.com/select/cleaver-select-theme
output: dist/cleaver-select-theme.html
theme: select/cleaver-select-theme

controls: true

--
# Cleaver
 Select Theme
##Press ESC and select a slide

--
### Usage

At the beginning of your presentation add

```
 theme: select/cleaver-select-theme
 title: My Title
 …

 --
 # Title slide
 ## Sub header

 --
 ### My first slide
 Some content
```

--
### ESC overview

Try pressing the ESC button to get and overview of all slides.

Click on a slide to select it.

Press ESC again to exit the overview.

--
### Fragments
This theme also supports fragments

One

Two

Tree

--
### Fragments markup
Here is the markup of the last slide
```
This theme also supports fragments
<div class="fragment">One</div>
<div class="fragment">Two</div>
<div class="fragment">Tree</div>
```
--
### Background image

Put `background-image.jpg` in the same directory as the HTML output.

The CSS style is set to one large image.
```
background: url('background-image.jpg') center center no-repeat;
```

--
### Fonts

Open `style.css` and change

```
@import url(https://fonts.googleapis.com/css?family=Hind:400,500,600,700,300);
@import url(https://fonts.googleapis.com/css?family=Open+Sans:400,300,600,700);
@import url(https://fonts.googleapis.com/css?family=Fira+Mono:400,700);
body {
  font-family: 'Open Sans', sans-serif;
  …
```
to fit your needs. Use http://fontpair.co/ to find matching fonts.

repository: select/learn-web-development

repo_name: select/learn-web-development


text:
# Concepts

This area contains explanations and guidance on the concepts in Cratis.

| Topic | Description |
| ------- | ----------- |
| [Event](./event.md) | What constitutes an event |
| [Event Type](./event-type.md) | What is an event type |
| [Event Source](./event-source.md) | What is an event source |
| [Event Store](./event-store.md) | What is the event store |
| [Event Sequence](./event-sequence.md) | What is an event sequence |
| [Observer](./observer.md) | What is an observer |
| [Projection](./projection.md) | What is a projection |
| [Tenancy](./tenancy.md) | What does tenancy mean |

repository: aksio-insurtech/Cratis

branch_name: refs/heads/main

gha_language: C#

repo_name: aksio-insurtech/Cratis


text:
# simple-logstash-logger

A simple nodejs logger for synchronously writing json/yaml logs in logstash-format to stdout.

## Why would I use this instead of bunyan/winston/pino?

* You are running a nodejs service on kubernetes, and simply want to log to stdout and feed it to logstash using `filebeat`.
* It is simpler. Not faster (pino). Not more flexible (bunyan/winston). Not asynchronous (winston).

## Usage

```javascript
const {createLogger} = require('simple-logstash-logger');

 // Using __filename as the first argument is recommended.
 // This will set the `file` field in the output to the relative path of the current file.
const logger = createLogger(__filename);

logger.info("Hello World");
```
Output
```json
{"@timestamp":"2019-03-24T15:10:56.414Z","@version":1,"level":"INFO","file":"examples/simple.js","message":"Hello World"}
```

### Setting the log level

```javascript
const {createLogger, LoggerConfig, LogLevel} = require('simple-logstash-logger');

const logger = createLogger(__filename);

// LoggerConfig can be modified after logger instantiation, allowing for
// modification of log level during runtime.
LoggerConfig.level = LogLevel.DEBUG; // default: INFO

logger.debug("Hello World");

// Setting the log level to OFF effectively disables all logging
LoggerConfig.level = LogLevel.OFF;

logger.error("Even this will not be seen. Good while running tests, bad in production");
```

### Setting the output format to YAML

While developing, it is useful to use the YAML output format. Especially nice for
stack traces (see section below).

```javascript
const logger = createLogger(__filename);

// Order does not matter, you can set the format after instantiating the logger
LoggerConfig.format = LogFormat.YAML;

logger.info("Hello World");
```

Output

```yaml

---
'@timestamp': '2019-03-24T15:13:00.424Z'
'@version': 1
level: INFO
file: examples/yaml.js
message: Hello World
```

### Adding contextual information

```javascript
// Contextual information can be added

// 1) globally on the LoggerConfig
LoggerConfig.context = {application: "my-application"};

// 2) as part of the logger creation
const logger = createLogger(__filename, {loggerType: "request-logs"});

// 3) and in each event
logger.info("Received request", {
    request: {
        path: "/hello",
        headers: {
            "content-type": "application/json"
        }
    }
});
```

Output

```yaml

---
'@timestamp': '2019-03-24T15:19:55.204Z'
'@version': 1
level: INFO
application: my-application
file: examples/contextual.js
loggerType: request-logs
message: Received request
request:
  path: /hello
  headers:
    content-type: application/json
```

### Adding stack traces

If an error object is given as the last argument to a logger method, the stack trace
for that object is added.

```javascript
try {
    throw new Error("Oops, my bad!");
} catch (err) {
    logger.error("Caught unexpected exception", err);
}
```

Output

```yaml

---
'@timestamp': '2019-03-24T15:25:51.014Z'
'@version': 1
level: ERROR
file: examples/errors.js
message: Caught unexpected exception
stackTrace: |-
  Error: Oops, my bad!
      at Object.<anonymous> (/.../examples/errors.js:6:11)
      at Module._compile (internal/modules/cjs/loader.js:701:30)
      at Object.Module._extensions..js (internal/modules/cjs/loader.js:712:10)
      at Module.load (internal/modules/cjs/loader.js:600:32)
      at tryModuleLoad (internal/modules/cjs/loader.js:539:12)
      at Function.Module._load (internal/modules/cjs/loader.js:531:3)
      at Function.Module.runMain (internal/modules/cjs/loader.js:754:12)
      at startup (internal/bootstrap/node.js:283:19)
      at bootstrapNodeJSCore (internal/bootstrap/node.js:622:3)
```

## FAQ

### Why synchronous?

Being synchronous means that any slowdown in stdout blocks the event loop,
forcing the application to slow down. The alternative is either:
* having log statements return promises, which would force any function that wants to log to
  become asynchronous too, or
* buffer unbounded in memory, which can lead to the process crashing loosing all buffered logs

However, being synchronized means that the application can stop responding if stdout
becomes a bottleneck. This library was built with the philosophy that, in the event
of a overloaded service, logging properly is *more important* than being able to serve
incoming http requests.

In practice, this should only be a problem if you are logging a *lot* of events.
A small throughput test when redirecting to file on a modern laptop yielded a
throughput of ~50k log events per second.

license: ISC

repository: remen/simple-logstash-logger

gha_license_id: ISC

repo_name: remen/simple-logstash-logger


text:
# Redux Hello World;

This is a simple React app with the sole aim of being refactored to use Redux. Pretty basic stuff. Ideal for Absolute Redux beginners.

## Directions

1. Clone the repo
   `git clone https://github.com/SafdarJamal/redux-helloworld.git`

2. Change directory
   `cd redux-helloworld`

3. Run the application
   `npm i && npm start`

4. Go on and refactor to use Redux!

repository: kennywam/redux-helloworld

repo_name: kennywam/redux-helloworld


text:
{
  "title": "arkhe",
  "description": ["A Collection of R S4 Classes that Represent Archaeological Data."],
  "links": {
    "GitHub": "https://github.com/tesselle/arkhe",
    "CRAN": "https://cloud.r-project.org/package=arkhe",
    "Website": "https://packages.tesselle.org/arkhe/"
  },
  "authors": ["nfrerebeau", "tesselle"],
  "categories": ["Packages and libraries"],
  "tags": ["Schemas and ontologies"],
  "doi": "10.5281/zenodo.3526659"
}

<!-- Generated by csv2md.R – do not edit by hand -->

A Collection of R S4 Classes that Represent Archaeological Data.

repository: zackbatist/open-archaeo

repo_name: zackbatist/open-archaeo


text:
# Class 11-2

## Agenda

1. [Warm-Up Exercise](https://docs.google.com/document/d/1Q81anGG4GLnZfXUuuksvHnnz6DjjKcj8MsZstQSug60)
1. [Lecture Code](https://github.com/IGME-202-17F6/lecture-code-wander) - [Summary : Wandering](https://docs.google.com/presentation/d/1cCS4SGfdSFuB5eLd6q-RrroswVQURINY-lsnbj-8joU)

## Exercise

No exercise. Instead I'll be doing another Project 3 check-in that counts as an Exercise grade on Tuesday. You should be mostly done with milestone 2 (roughly, you're welcome to pick and choose from the other milestones as you see fit).

## Readings

No readings, work on Project 3!

## Quiz

No quiz this week. We'll have one next week!


text:
---
layout: post
title: "Graph based Neural Networks for Event Factuality Prediction using Syntactic and Semantic Structures"
date: 2019-07-07 06:02:05
categories: arXiv_CL
tags: arXiv_CL Prediction
author: Amir Pouran Ben Veyseh, Thien Huu Nguyen, Dejing Dou
mathjax: true
---

* content
{:toc}

##### Abstract
Event factuality prediction (EFP) is the task of assessing the degree to which an event mentioned in a sentence has happened. For this task, both syntactic and semantic information are crucial to identify the important context words. The previous work for EFP has only combined these information in a simple way that cannot fully exploit their coordination. In this work, we introduce a novel graph-based neural network for EFP that can integrate the semantic and syntactic information more effectively. Our experiments demonstrate the advantage of the proposed model for EFP.

##### Abstract (translated by Google)

##### URL
[http://arxiv.org/abs/1907.03227](http://arxiv.org/abs/1907.03227)

##### PDF
[http://arxiv.org/pdf/1907.03227](http://arxiv.org/pdf/1907.03227)


text:
[![License]][LICENSE.txt]
[![Telegram]][Teletram join]

--------------------------------------------------------------------------------

# Tapin

[tapin][Teletram join] is a python-based faucet for Graphene-based blockchains
(e.g.  BitShares).

## Installation

* edit `config.py` and provide private keys and settings
* `python manage.py install`

## Usage

* `python manage.py runserver`

The faucet is then available at URL `http://localhost:5000`

## Deploy on Heroku

[![Deploy](https://www.herokucdn.com/deploy/button.svg)](https://heroku.com/deploy)

Remark: Please understand the risks of exposing private keys to heroku!

## Nginx configuration

Run `uwsgi --ini wsgi.ini`

and use a configuration similar tothis

```
user bitshares;
worker_processes  4;

events {
    worker_connections  2048;
}

http {
    include       mime.types;
    default_type  application/octet-stream;
    access_log  /www/logs/access.log;
    error_log  /www/logs/error.log;
    log_not_found off;
    sendfile        on;
    keepalive_timeout  65;
    gzip  on;

    upstream websockets {
      server localhost:9090;
      server localhost:9091;
    }

    server {
        listen       80;
        if ($scheme != "https") {
                return 301 https://$host$request_uri;
        }

        listen       443 ssl;
        server_name  bitshares-wallet.com;
        ssl_certificate      /etc/nginx/ssl/bitshares-wallet.com.crt;
        ssl_certificate_key /etc/nginx/ssl/bitshares-wallet.com.key;
        ssl_session_cache    shared:SSL:1m;
        ssl_session_timeout  5m;
        ssl_ciphers  HIGH:!aNULL:!MD5;
        ssl_prefer_server_ciphers  on;

        location ~ /ws/? {
            access_log on;
            proxy_pass http://websockets;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header Host $host;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_http_version 1.1;
            proxy_set_header Upgrade $http_upgrade;
            proxy_set_header Connection "upgrade";
            proxy_next_upstream     error timeout invalid_header http_500;
            proxy_connect_timeout   2;
        }
        location ~ ^/[\w\d\.-]+\.(js|css|dat|png|json)$ {
            root /www/wallet;
            try_files $uri /wallet$uri =404;
        }
        location / {
            root /www/wallet;
        }
        location /api {
                include uwsgi_params;
                uwsgi_pass unix:/tmp/faucet.sock;
        }

    }
}
```
# Use with prebuild Docker images

Create a service directory and navigate to it:
```bash
mkdir faucet && cd faucet
```

Download [Dockerfile-prebuild] and [docker-compose-prebuild.yml] into this
directory by running the command:
```bash
wget https://raw.githubusercontent.com/fincubator/tapin/master/Dockerfile-prebuild \
     https://raw.githubusercontent.com/fincubator/tapin/master/docker-compose-prebuild.yml
```

Create a file `config.yml` in this directory and fill it with the contents of
approximately like in the `config-example.yml` file, where:
* `secret_key` - is your random secret key. Generate it, for example, in your
password manager.
* `mail_host` - server of your SMTP provider.
* `mail_user` and mail_pass - login and password from your SMTP provider.
* `mail_from` - your mail address.
* `admins` - list here the mail addresses of administrators.
* `witness_url` - specify the address of your node.
* `registrar` - specify a registrar account.
* `default_referrer` - specify default_referrer, which will receive the reward.
* `referrer_percent` - specify the percentage of payments to the referral.
* `wif` - specify your private key.
* `balance_mailthreshold` - specify a minimum balance, after which a warning
message will be sent to your mail.
* `core_asset` - specify the tiker at which the fee will be paid.

If you use Gmail, then `mail_host` will be smtp.gmail.com:587, `mail_user` and
`mail_pass` - your login and password from your mailbox, `mail_from` - full
address your mailbox, like<EMAIL_ADDRESS>
Start your service by executing the command:
```bash
sudo docker-compose -f docker-compose-prebuild.yml up --build
```

[License]: https://img.shields.io/github/license/fincubator/tapin
[LICENSE.txt]: LICENSE.txt
[Telegram]: https://img.shields.io/badge/Telegram-fincubator-blue?logo=telegram
[Teletram join]: https://t.me/fincubator
[Dockerfile-prebuild]: Dockerfile-prebuild
[docker-compose-prebuild.yml]: docker-compose-prebuild.yml

repository: fincubator/tapin

repo_name: fincubator/tapin


text:
# cache.aws.crossplane.io/v1beta1 API Reference

Package v1beta1 contains managed resources for AWS caching services such as ElastiCache.

This API group contains the following Crossplane resources:

* [ReplicationGroup](#ReplicationGroup)
* [ReplicationGroupClass](#ReplicationGroupClass)

## ReplicationGroup

A ReplicationGroup is a managed resource that represents an AWS ElastiCache Replication Group.

Name | Type | Description
-----|------|------------
`apiVersion` | string | `cache.aws.crossplane.io/v1beta1`
`kind` | string | `ReplicationGroup`
`metadata` | [meta/v1.ObjectMeta](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.15/#objectmeta-v1-meta) | Kubernetes object metadata.
`spec` | [ReplicationGroupSpec](#ReplicationGroupSpec) | A ReplicationGroupSpec defines the desired state of a ReplicationGroup.
`status` | [ReplicationGroupStatus](#ReplicationGroupStatus) | A ReplicationGroupStatus defines the observed state of a ReplicationGroup.

## ReplicationGroupClass

A ReplicationGroupClass is a resource class. It defines the desired spec of resource claims that use it to dynamically provision a managed resource.

Name | Type | Description
-----|------|------------
`apiVersion` | string | `cache.aws.crossplane.io/v1beta1`
`kind` | string | `ReplicationGroupClass`
`metadata` | [meta/v1.ObjectMeta](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.15/#objectmeta-v1-meta) | Kubernetes object metadata.
`specTemplate` | [ReplicationGroupClassSpecTemplate](#ReplicationGroupClassSpecTemplate) | SpecTemplate is a template for the spec of a dynamically provisioned ReplicationGroup.

## Endpoint

Endpoint represents the information required for client programs to connect to a cache node. Please also see https://docs.aws.amazon.com/goto/WebAPI/elasticache-2015-02-02/Endpoint

Appears in:

* [NodeGroup](#NodeGroup)
* [NodeGroupMember](#NodeGroupMember)
* [ReplicationGroupObservation](#ReplicationGroupObservation)

Name | Type | Description
-----|------|------------
`address` | string | Address is the DNS hostname of the cache node.
`port` | int | Port number that the cache engine is listening on.

## MinorVersion

MinorVersion represents a supported minor version of Redis. Alias of string.

## NodeGroup

NodeGroup represents a collection of cache nodes in a replication group. One node in the node group is the read/write primary node. All the other nodes are read-only Replica nodes. Please also see https://docs.aws.amazon.com/goto/WebAPI/elasticache-2015-02-02/NodeGroup

Appears in:

* [ReplicationGroupObservation](#ReplicationGroupObservation)

Name | Type | Description
-----|------|------------
`port` | string | NodeGroupID is the identifier for the node group (shard). A Redis (cluster mode disabled) replication group contains only 1 node group; therefore, the node group ID is 0001. A Redis (cluster mode enabled) replication group contains 1 to 15 node groups numbered 0001 to 0015.
`nodeGroupMembers` | [[]NodeGroupMember](#NodeGroupMember) | NodeGroupMembers is a list containing information about individual nodes within the node group (shard).
`primaryEndpoint` | [Endpoint](#Endpoint) | PrimaryEndpoint is the endpoint of the primary node in this node group (shard).
`slots` | string | Slots is the keyspace for this node group (shard).
`status` | string | Status of this replication group - creating, available, etc.

## NodeGroupConfigurationSpec

A NodeGroupConfigurationSpec specifies the desired state of a node group.

Appears in:

* [ReplicationGroupParameters](#ReplicationGroupParameters)

Name | Type | Description
-----|------|------------
`primaryAvailabilityZone` | Optional string | PrimaryAvailabilityZone specifies the Availability Zone where the primary node of this node group (shard) is launched.
`replicaAvailabilityZones` | Optional []string | ReplicaAvailabilityZones specifies a list of Availability Zones to be used for the read replicas. The number of Availability Zones in this list must match the value of ReplicaCount or ReplicasPerNodeGroup if not specified.
`replicaCount` | Optional int | ReplicaCount specifies the number of read replica nodes in this node group (shard).
`slots` | Optional string | Slots specifies the keyspace for a particular node group. Keyspaces range from 0 to 16,383. The string is in the format startkey-endkey.  Example: "0-3999"

## NodeGroupMember

NodeGroupMember represents a single node within a node group (shard). Please also see https://docs.aws.amazon.com/goto/WebAPI/elasticache-2015-02-02/NodeGroupMember

Appears in:

* [NodeGroup](#NodeGroup)

Name | Type | Description
-----|------|------------
`cacheClusterId` | string | CacheClusterID is the ID of the cluster to which the node belongs.
`cacheNodeId` | string | CacheNodeID is the ID of the node within its cluster. A node ID is a numeric identifier (0001, 0002, etc.).
`currentRole` | string | CurrentRole is the role that is currently assigned to the node - primary or replica. This member is only applicable for Redis (cluster mode disabled) replication groups.
`preferredAvailabilityZone` | string | PreferredAvailabilityZone is the name of the Availability Zone in which the node is located.
`readEndpoint` | [Endpoint](#Endpoint) | ReadEndpoint is the information required for client programs to connect to a node for read operations. The read endpoint is only applicable on Redis (cluster mode disabled) clusters.

## PatchVersion

PatchVersion represents a supported patch version of Redis. Alias of string.

## ReplicationGroupClassSpecTemplate

A ReplicationGroupClassSpecTemplate is a template for the spec of a dynamically provisioned ReplicationGroup.

Appears in:

* [ReplicationGroupClass](#ReplicationGroupClass)

Name | Type | Description
-----|------|------------
`forProvider` | [ReplicationGroupParameters](#ReplicationGroupParameters) | ReplicationGroupParameters define the desired state of an AWS ElastiCache Replication Group. Most fields map directly to an AWS ReplicationGroup: https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_CreateReplicationGroup.html#API_CreateReplicationGroup_RequestParameters

ReplicationGroupClassSpecTemplate supports all fields of:

* [v1alpha1.ClassSpecTemplate](../crossplane-runtime/core-crossplane-io-v1alpha1.md#classspectemplate)

## ReplicationGroupObservation

ReplicationGroupObservation contains the observation of the status of the given ReplicationGroup.

Appears in:

* [ReplicationGroupStatus](#ReplicationGroupStatus)

Name | Type | Description
-----|------|------------
`automaticFailoverStatus` | string | AutomaticFailover indicates the status of Multi-AZ with automatic failover for this Redis replication group.
`clusterEnabled` | bool | ClusterEnabled is a flag indicating whether or not this replication group is cluster enabled; i.e., whether its data can be partitioned across multiple shards (API/CLI: node groups).
`configurationEndpoint` | [Endpoint](#Endpoint) | ConfigurationEndpoint for this replication group. Use the configuration endpoint to connect to this replication group.
`memberClusters` | []string | MemberClusters is the list of names of all the cache clusters that are part of this replication group.
`nodeGroups` | [[]NodeGroup](#NodeGroup) | NodeGroups is a list of node groups in this replication group. For Redis (cluster mode disabled) replication groups, this is a single-element list. For Redis (cluster mode enabled) replication groups, the list contains an entry for each node group (shard).
`pendingModifiedValues` | [ReplicationGroupPendingModifiedValues](#ReplicationGroupPendingModifiedValues) | PendingModifiedValues is a group of settings to be applied to the replication group, either immediately or during the next maintenance window.
`status` | string | Status is the current state of this replication group - creating, available, modifying, deleting, create-failed, snapshotting.

## ReplicationGroupParameters

ReplicationGroupParameters define the desired state of an AWS ElastiCache Replication Group. Most fields map directly to an AWS ReplicationGroup: https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_CreateReplicationGroup.html#API_CreateReplicationGroup_RequestParameters

Appears in:

* [ReplicationGroupClassSpecTemplate](#ReplicationGroupClassSpecTemplate)
* [ReplicationGroupSpec](#ReplicationGroupSpec)

Name | Type | Description
-----|------|------------
`applyModificationsImmediately` | bool | If true, this parameter causes the modifications in this request and any pending modifications to be applied, asynchronously and as soon as possible, regardless of the PreferredMaintenanceWindow setting for the replication group.  If false, changes to the nodes in the replication group are applied on the next maintenance reboot, or the next failure reboot, whichever occurs first.
`atRestEncryptionEnabled` | Optional bool | AtRestEncryptionEnabled enables encryption at rest when set to true.  You cannot modify the value of AtRestEncryptionEnabled after the replication group is created. To enable encryption at rest on a replication group you must set AtRestEncryptionEnabled to true when you create the replication group.  Only available when creating a replication group in an Amazon VPC using redis version 3.2.6 or 4.x.
`authEnabled` | Optional bool | AuthEnabled enables mandatory authentication when connecting to the managed replication group. AuthEnabled requires TransitEncryptionEnabled to be true.  While ReplicationGroupSpec mirrors the fields of the upstream replication group object as closely as possible, we expose a boolean here rather than requiring the operator pass in a string authentication token. Crossplane will generate a token automatically and expose it via a Secret.
`automaticFailoverEnabled` | Optional bool | AutomaticFailoverEnabled specifies whether a read-only replica is automatically promoted to read/write primary if the existing primary fails. If true, Multi-AZ is enabled for this replication group. If false, Multi-AZ is disabled for this replication group.  AutomaticFailoverEnabled must be enabled for Redis (cluster mode enabled) replication groups.  Amazon ElastiCache for Redis does not support Multi-AZ with automatic failover on: * Redis versions earlier than 2.8.6. * Redis (cluster mode disabled): T1 and T2 cache node types. * Redis (cluster mode enabled): T1 node types.
`cacheNodeType` | string | CacheNodeType specifies the compute and memory capacity of the nodes in the node group (shard). For a complete listing of node types and specifications, see: * Amazon ElastiCache Product Features and Details (http://aws.amazon.com/elasticache/details) * Cache Node Type-Specific Parameters for Memcached (http://docs.aws.amazon.com/AmazonElastiCache/latest/mem-ug/ParameterGroups.Memcached.html#ParameterGroups.Memcached.NodeSpecific) * Cache Node Type-Specific Parameters for Redis (http://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/ParameterGroups.Redis.html#ParameterGroups.Redis.NodeSpecific)
`cacheParameterGroupName` | Optional string | CacheParameterGroupName specifies the name of the parameter group to associate with this replication group. If this argument is omitted, the default cache parameter group for the specified engine is used.  If you are running Redis version 3.2.4 or later, only one node group (shard), and want to use a default parameter group, we recommend that you specify the parameter group by name. * To create a Redis (cluster mode disabled) replication group, use CacheParameterGroupName=default.redis3.2. * To create a Redis (cluster mode enabled) replication group, use CacheParameterGroupName=default.redis3.2.cluster.on.
`cacheSecurityGroupNames` | Optional []string | CacheSecurityGroupNames specifies a list of cache security group names to associate with this replication group.
`cacheSubnetGroupName` | Optional string | CacheSubnetGroupName specifies the name of the cache subnet group to be used for the replication group. If you're going to launch your cluster in an Amazon VPC, you need to create a subnet group before you start creating a cluster. For more information, see Subnets and Subnet Groups (http://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/SubnetGroups.html).
`engine` | string | Engine is the name of the cache engine (memcached or redis) to be used for the clusters in this replication group.
`engineVersion` | Optional string | EngineVersion specifies the version number of the cache engine to be used for the clusters in this replication group. To view the supported cache engine versions, use the DescribeCacheEngineVersions operation.  Important: You can upgrade to a newer engine version (see Selecting a Cache Engine and Version (http://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/SelectEngine.html#VersionManagement)) in the ElastiCache User Guide, but you cannot downgrade to an earlier engine version. If you want to use an earlier engine version, you must delete the existing cluster or replication group and create it anew with the earlier engine version.
`nodeGroupConfiguration` | Optional [[]NodeGroupConfigurationSpec](#NodeGroupConfigurationSpec) | NodeGroupConfigurationSpec specifies a list of node group (shard) configuration options.  If you're creating a Redis (cluster mode disabled) or a Redis (cluster mode enabled) replication group, you can use this parameter to individually configure each node group (shard), or you can omit this parameter. However, when seeding a Redis (cluster mode enabled) cluster from a S3 rdb file, you must configure each node group (shard) using this parameter because you must specify the slots for each node group.
`notificationTopicArn` | Optional string | NotificationTopicARN specifies the Amazon Resource Name (ARN) of the Amazon Simple Notification Service (SNS) topic to which notifications are sent. The Amazon SNS topic owner must be the same as the cluster owner.
`notificationTopicStatus` | Optional string | NotificationTopicStatus is the status of the Amazon SNS notification topic for the replication group. Notifications are sent only if the status is active.  Valid values: active | inactive
`numCacheClusters` | Optional int | NumCacheClusters specifies the number of clusters this replication group initially has. This parameter is not used if there is more than one node group (shard). You should use ReplicasPerNodeGroup instead.  If AutomaticFailoverEnabled is true, the value of this parameter must be at least 2. If AutomaticFailoverEnabled is false you can omit this parameter (it will default to 1), or you can explicitly set it to a value between 2 and 6.  The maximum permitted value for NumCacheClusters is 6 (1 primary plus 5 replicas).
`numNodeGroups` | Optional int | NumNodeGroups specifies the number of node groups (shards) for this Redis (cluster mode enabled) replication group. For Redis (cluster mode disabled) either omit this parameter or set it to 1.  Default: 1
`port` | Optional int | Port number on which each member of the replication group accepts connections.
`preferredCacheClusterAzs` | Optional []string | PreferredCacheClusterAZs specifies a list of EC2 Availability Zones in which the replication group's clusters are created. The order of the Availability Zones in the list is the order in which clusters are allocated. The primary cluster is created in the first AZ in the list.  This parameter is not used if there is more than one node group (shard). You should use NodeGroupConfigurationSpec instead.  If you are creating your replication group in an Amazon VPC (recommended), you can only locate clusters in Availability Zones associated with the subnets in the selected subnet group.  The number of Availability Zones listed must equal the value of NumCacheClusters.  Default: system chosen Availability Zones.
`preferredMaintenanceWindow` | Optional string | PreferredMaintenanceWindow specifies the weekly time range during which maintenance on the cluster is performed. It is specified as a range in the format ddd:hh24:mi-ddd:hh24:mi (24H Clock UTC). The minimum maintenance window is a 60 minute period.  Example: sun:23:00-mon:01:30
`primaryClusterId` | Optional string | PrimaryClusterId is the identifier of the cluster that serves as the primary for this replication group. This cluster must already exist and have a status of available.  This parameter is not required if NumCacheClusters, NumNodeGroups or ReplicasPerNodeGroup is specified.
`replicasPerNodeGroup` | Optional int | ReplicasPerNodeGroup specifies the number of replica nodes in each node group (shard). Valid values are 0 to 5.
`replicationGroupDescription` | string | ReplicationGroupDescription is the description for the replication group.
`securityGroupIds` | Optional []string | SecurityGroupIDs specifies one or more Amazon VPC security groups associated with this replication group. Use this parameter only when you are creating a replication group in an Amazon VPC.
`snapshotArns` | Optional []string | SnapshotARNs specifies a list of Amazon Resource Names (ARN) that uniquely identify the Redis RDB snapshot files stored in Amazon S3. The snapshot files are used to populate the new replication group. The Amazon S3 object name in the ARN cannot contain any commas. The new replication group will have the number of node groups (console: shards) specified by the parameter NumNodeGroups or the number of node groups configured by NodeGroupConfigurationSpec regardless of the number of ARNs specified here.
`snapshotName` | Optional string | SnapshotName specifies the name of a snapshot from which to restore data into the new replication group. The snapshot status changes to restoring while the new replication group is being created.
`snapshotRetentionLimit` | Optional int | SnapshotRetentionLimit specifies the number of days for which ElastiCache retains automatic snapshots before deleting them. For example, if you set SnapshotRetentionLimit to 5, a snapshot that was taken today is retained for 5 days before being deleted. Default: 0 (i.e., automatic backups are disabled for this cluster).
`snapshotWindow` | Optional string | SnapshotWindow specifies the daily time range (in UTC) during which ElastiCache begins taking a daily snapshot of your node group (shard).  Example: 05:00-09:00  If you do not specify this parameter, ElastiCache automatically chooses an appropriate time range.
`snapshottingClusterID` | Optional string | SnapshottingClusterID is used as the daily snapshot source for the replication group. This parameter cannot be set for Redis (cluster mode enabled) replication groups.
`tags` | Optional [[]Tag](#Tag) | A list of cost allocation tags to be added to this resource. A tag is a key-value pair.
`transitEncryptionEnabled` | Optional bool | TransitEncryptionEnabled enables in-transit encryption when set to true.  You cannot modify the value of TransitEncryptionEnabled after the cluster is created. To enable in-transit encryption on a cluster you must TransitEncryptionEnabled to true when you create a cluster.  This parameter is valid only if the Engine parameter is redis, the EngineVersion parameter is 3.2.6 or 4.x, and the cluster is being created in an Amazon VPC.  If you enable in-transit encryption, you must also specify a value for CacheSubnetGroup.  Required: Only available when creating a replication group in an Amazon VPC using redis version 3.2.6 or 4.x.  Default: false  For HIPAA compliance, you must specify TransitEncryptionEnabled as true, an AuthToken, and a CacheSubnetGroup.

## ReplicationGroupPendingModifiedValues

ReplicationGroupPendingModifiedValues are the settings to be applied to the Redis replication group, either immediately or during the next maintenance window. Please also see https://docs.aws.amazon.com/goto/WebAPI/elasticache-2015-02-02/ReplicationGroupPendingModifiedValues

Appears in:

* [ReplicationGroupObservation](#ReplicationGroupObservation)

Name | Type | Description
-----|------|------------
`automaticFailoverStatus` | string | AutomaticFailoverStatus indicates the status of Multi-AZ with automatic failover for this Redis replication group.
`primaryClusterId` | string | PrimaryClusterID that is applied immediately or during the next maintenance window.
`resharding` | [ReshardingStatus](#ReshardingStatus) | Resharding is the status of an online resharding operation.

## ReplicationGroupSpec

A ReplicationGroupSpec defines the desired state of a ReplicationGroup.

Appears in:

* [ReplicationGroup](#ReplicationGroup)

Name | Type | Description
-----|------|------------
`forProvider` | [ReplicationGroupParameters](#ReplicationGroupParameters) | ReplicationGroupParameters define the desired state of an AWS ElastiCache Replication Group. Most fields map directly to an AWS ReplicationGroup: https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_CreateReplicationGroup.html#API_CreateReplicationGroup_RequestParameters

ReplicationGroupSpec supports all fields of:

* [v1alpha1.ResourceSpec](../crossplane-runtime/core-crossplane-io-v1alpha1.md#resourcespec)

## ReplicationGroupStatus

A ReplicationGroupStatus defines the observed state of a ReplicationGroup.

Appears in:

* [ReplicationGroup](#ReplicationGroup)

Name | Type | Description
-----|------|------------
`atProvider` | [ReplicationGroupObservation](#ReplicationGroupObservation) | ReplicationGroupObservation contains the observation of the status of the given ReplicationGroup.

ReplicationGroupStatus supports all fields of:

* [v1alpha1.ResourceStatus](../crossplane-runtime/core-crossplane-io-v1alpha1.md#resourcestatus)

## ReshardingStatus

ReshardingStatus is the status of an online resharding operation. Please also see https://docs.aws.amazon.com/goto/WebAPI/elasticache-2015-02-02/ReshardingStatus

Appears in:

* [ReplicationGroupPendingModifiedValues](#ReplicationGroupPendingModifiedValues)

Name | Type | Description
-----|------|------------
`slotMigration` | [SlotMigration](#SlotMigration) | Represents the progress of an online resharding operation.

## SlotMigration

SlotMigration represents the progress of an online resharding operation. Please also see https://docs.aws.amazon.com/goto/WebAPI/elasticache-2015-02-02/SlotMigration

Appears in:

* [ReshardingStatus](#ReshardingStatus)

Name | Type | Description
-----|------|------------
`progressPercentage` | int | ProgressPercentage is the percentage of the slot migration that is complete.

## Tag

A Tag is used to tag the ElastiCache resources in AWS.

Appears in:

* [ReplicationGroupParameters](#ReplicationGroupParameters)

Name | Type | Description
-----|------|------------
`key` | string | Key for the tag.
`value` | string | Value of the tag.

This API documentation was generated by `crossdocs`.


text:
# # Ping

## Properties

Name | Type | Description | Notes
------------ | ------------- | ------------- | -------------
**source_type** | **string** | OA3 Schema type name for the source info which is used as the discriminator value to ensure that data binding works correctly |
**event_id** | **string** | UUID id of the source event in the Velo platform |
**created_at** | **\DateTime** | ISO8601 timestamp indicating when the source event was created |

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

repository: velopaymentsapi/velo-php

repo_name: velopaymentsapi/velo-php


text:
# ember-babel-transform-classnames-convention
Note this is a proof of concept and not fully tested. Your mileage may vary.

Transforms:
```js
// components/user-component.js
export default Component.extend({
  // properties
});
```
To:
```js
// components/user-component.js
export default Component.extend({
  classNames: ['user-component']
});
```

## Installation
```js
const EmberBabelClassNamesPreprocessor = require('ember-babel-transform-classnames-convention');
// ...

module.exports = function(defaults) {
  let app = new EmberApp(defaults, {
    babel: {
      plugins: [EmberBabelClassNamesPreprocessor]
    }
    // ...
  });
};
```

## Running

* `ember serve`
* Visit your app at [http://localhost:4200](http://localhost:4200).

## Running Tests

* `npm test` (Runs `ember try:each` to test your addon against multiple Ember versions)
* `ember test`
* `ember test --server`

## Building

* `ember build`

For more information on using ember-cli, visit [https://ember-cli.com/](https://ember-cli.com/).


text:
Do not lock the Event Loop!
===========================

This is a demo to show the importance of not locking the Javascript Event Loop. This usually happens when the developer run CPU intensive work without call browser API. The demo proposes a simple solution to this problem based on the use of generators and the proposed `yieldControl` function.

Go [here](https://lucarin91.github.io/yield-control-demo/) to see the actual demo!

More details about the Javascript Event Loop can be founded here:
- [Philip Roberts: What the heck is the event loop anyway? | JSConf EU](https://www.youtube.com/watch?v=8aGhZQkoFbQ)
- [Concurrency model and Event Loop | Mozilla](https://developer.mozilla.org/en-US/docs/Web/JavaScript/EventLoop)

License
-------
[MIT license](LICENSE)


text:
# Changelog

All notable changes to this project will be documented in this file, in reverse chronological order by release.

## 0.4.1 - 2019-03-06

### Added

- Nothing.

### Changed

- [#6](https://github.com/xtreamwayz/expressive-messenger/pull/6) uses container locators for handlers and senders.

### Deprecated

- Nothing.

### Removed

- Nothing.

### Fixed

- [#6](https://github.com/xtreamwayz/expressive-messenger/pull/6) fixes senders being wrapped in callables where SenderInterface objects are expected.

## 0.4.0 - 2018-12-31

### Added

- [#5](https://github.com/xtreamwayz/expressive-messenger/pull/5) added messenger 4.2 compatibility.

### Changed

- Nothing.

### Deprecated

- Nothing.

### Removed

- Nothing.

### Fixed

- Nothing.

## 0.3.2 - 2018-12-31

### Added

- Added phpunit support for phpstan.

### Changed

- Locked to Symfony 4.1 packages as 4.2 contains BC.
- Changed dev dependencies to fix a phpcodesniffer-composer-installer issue.

## 0.3.1 - 2018-09-10

### Added

- Nothing.

### Changed

- Nothing.

### Deprecated

- Nothing.

### Removed

- Nothing.

### Fixed

- [#4](https://github.com/xtreamwayz/expressive-messenger/pull/4) adds the missing LoggingMiddlewareFactory.

## 0.3.0 - 2018-08-22

### Added

- [#3](https://github.com/xtreamwayz/expressive-messenger/pull/3) adds message handling middleware which sends messages
  to multiple handlers.

- [#3](https://github.com/xtreamwayz/expressive-messenger/pull/3) adds configuration for transports with DNS. This
  enables support for all available enqueue transports.

### Changed

- [#3](https://github.com/xtreamwayz/expressive-messenger/pull/3) changes how a message bus and enqueue transport is
  created. This comes with a major configuration overhaul.

### Deprecated

- Nothing.

### Removed

- [#3](https://github.com/xtreamwayz/expressive-messenger/pull/3) removes the redis factory class. The preferred way is
  to use DNS to configure enqueue transports.

### Fixed

- Nothing.

## 0.2.1 - 2018-08-02

### Added

- Nothing.

### Changed

- Nothing.

### Deprecated

- Nothing.

### Removed

- Nothing.

### Fixed

- [#2](https://github.com/xtreamwayz/expressive-messenger/pull/2) fixes the console command to be compatible with xtreamwayz/expressive-console.

## 0.2.0 - 2018-08-02

### Added

- [#1](https://github.com/xtreamwayz/expressive-messenger/pull/1) adds support for messenger 4.1.

### Changed

- Nothing.

### Deprecated

- Nothing.

### Removed

- Nothing.

### Fixed

- Nothing.

## 0.1.0 - 2018-08-02

Initial tagged release.

### Added

Everything.

### Deprecated

Nothing.

### Removed

Nothing.

### Fixed

Nothing.

repository: iampersistent/expressive-messenger

repo_name: iampersistent/expressive-messenger


text:
CMS Page Bundle
===============

Bundle extending [SonataPageBundle](https://github.com/sonata-project/SonataPageBundle) in order to simplify the use by developers and future users, trying to not alter the original flexibility, and to give them new basic tools and views.

[![SensioLabsInsight](https://insight.sensiolabs.com/projects/e11f072f-d128-459c-8100-e50bf565e99a/mini.png)](https://insight.sensiolabs.com/projects/e11f072f-d128-459c-8100-e50bf565e99a) [![Latest Stable Version](https://poser.pugx.org/th3mouk/cms-page-bundle/v/stable.svg)](https://packagist.org/packages/th3mouk/cms-page-bundle) [![Total Downloads](https://poser.pugx.org/th3mouk/cms-page-bundle/downloads.svg)](https://packagist.org/packages/th3mouk/cms-page-bundle) [![Build Status](https://travis-ci.org/Th3Mouk/CMSPageBundle.svg?branch=master)](https://travis-ci.org/Th3Mouk/CMSPageBundle) [![Latest Unstable Version](https://poser.pugx.org/th3mouk/cms-page-bundle/v/unstable.svg)](https://packagist.org/packages/th3mouk/cms-page-bundle) [![License](https://poser.pugx.org/th3mouk/cms-page-bundle/license.svg)](https://packagist.org/packages/th3mouk/cms-page-bundle)

This bundle is part of the preconfigured CMS based on Symfony and Sonata : [CMSStarter](https://github.com/Th3Mouk/CMSStarter) | [CMSCoreBundle](https://github.com/Th3Mouk/CMSCoreBundle)

## SonataPageBundle

The use of this bundle require understanding of the [SonataPageBundle](https://sonata-project.org/bundles/page/master/doc/index.html).

## Installation

### Composer

```sh
composer require th3mouk/cms-page-bundle ^2.0
```

### SonataPageBundle

Install the original [SonataPageBundle](https://sonata-project.org/bundles/page/master/doc/index.html).

### Easy extends

```sh
app/console sonata:easy-extends:generate Th3MoukCMSPageBundle
```

### Update Kernel

```php
# app/AppKernel.php
...
new Th3Mouk\CMSPageBundle\Th3MoukCMSPageBundle(),
new Application\Th3Mouk\CMSPageBundle\ApplicationTh3MoukCMSPageBundle(),
...
```

### Configuration

Create the following files:

```yaml
# app/config/bundles/override.yml
parameters:
    #Overload PageAdmin
    sonata.page.admin.page.class: Th3Mouk\CMSPageBundle\Admin\PageAdmin
    #Overload PageManager
    sonata.page.manager.page.class: Th3Mouk\CMSPageBundle\Entity\PageManager
    #Overload Transformer otherwise additional attributes will be non-serialized
    sonata.page.transformer.class: Th3Mouk\CMSPageBundle\Entity\Transformer
    #Overload PageAdminController
    sonata.page.admin.page.controller: Th3MoukCMSPageBundle:PageAdmin
```

```yaml
# app/config/sonata/sonata_page.yml
sonata_page:
    class:
        page:     Application\Th3Mouk\CMSPageBundle\Entity\Page
        snapshot: Application\Th3Mouk\CMSPageBundle\Entity\Snapshot
        block:    Application\Th3Mouk\CMSPageBundle\Entity\Block
        site:     Application\Th3Mouk\CMSPageBundle\Entity\Site
```
Include them:

```yaml
# app/config/config.yml
imports:
    # Sonata Page Bundle
    - { resource: sonata/sonata_page.yml }

    # Override Vendors Parameters
    - { resource: bundles/override.yml }
```

## Please

Feel free to improve all of this work, project or bundles.


text:
> This package was moved to the pnpm monorepo: https://github.com/pnpm/pnpm/tree/main/packages/file-reporter

# @pnpm/file-reporter

> A file reporter for pnpm

[![Build Status](https://img.shields.io/travis/pnpm/file-reporter/master.svg?style=flat-square)](https://travis-ci.org/pnpm/file-reporter) [![npm version](https://img.shields.io/npm/v/@pnpm/file-reporter.svg?style=flat-square)](https://www.npmjs.com/package/@pnpm/file-reporter)

## Installation

```
<pnpm|yarn|npm> add @pnpm/file-reporter
```

## License

[MIT](LICENSE) © [Zoltan Kochan](https://kochan.io)

repository: pnpm/file-reporter

gha_language: TypeScript

repo_name: pnpm/file-reporter


text:
# MultilevelTT

Example [Julia](https://julialang.org/) code for <https://arxiv.org/abs/1802.09062>. This package is for Julia 0.6, a version for Julia 1.0+ will be provided soon.

Includes a basic implementation of the tensor train format, assembly of the preconditioned low-rank representations developed in the paper, generic iterative solvers (including a wrapper for AMEn as implemented in [ttpy](https://github.com/oseledets/ttpy)) and some routines for running tests.

To install the package, run Pkg.clone("https://github.com/mbachmayr/MultilevelTT.jl.git") in Julia 0.6.

`using MultilevelTT` only modifies the module search path `LOAD_PATH` so that the following modules can be loaded separately via `using`:
- `TT`, basic tensor train functions.
- `TTFEM`, routines for assembling tensor representations from <https://arxiv.org/abs/1802.09062>.
- `TTAlg`, iterative solvers implemented in Julia (following [this paper](http://dx.doi.org/10.1007/s10208-016-9314-z)).
- `TTPy`, wrapper for AMEn in [ttpy](https://github.com/oseledets/ttpy); requires this python package to be installed, see instructions in the source file. Required only by the `PoissonAMEn` and `MultiscaleAMEn` modules.
- `TTCondition`, auxiliary routines for evaluating representation condition numbers (see §4 in <https://arxiv.org/abs/1802.09062>).
- `Poisson`, test routines for 1D and 2D Poisson problems, using `TTAlg`.
- `Multiscale`, test routines for a 1D problem with oscillatory coefficient, using `TTAlg`.
- `PoissonAMEn`, test routines for 1D and 2D Poisson problems, using `TTPy`.
- `MultiscaleAMEn`, test routines for a 1D problem with oscillatory coefficient, using `TTPy`.


text:
⚠ **In March 2023, Cisco CTA stopped supporting the STIX/TAXII API. We recommend that you [use our new REST API instead](https://api.cta.eu.amp.cisco.com).** ⚠

Please see the project homepage https://github.com/CiscoCTA/taxii-log-adapter/wiki

#### RELEASE NOTES

##### Version 2.0.0

* Configuration property `taxiiService` was renamed to `taxii-service`.
  Camel case configuration properties are no longer supported.

* Slash character `/` in JSON output is now escaped by default and it's returned as `\/` according to the changes in Saxon-HE 9.7.0-8.
  If you'd like to keep backward compatibility you can modify the stylesheet and use character maps as shown in the following example:
  ```
    <xsl:variable name="character-map" as="map(xs:string, xs:string)">
        <xsl:map>
            <xsl:map-entry key="'/'" select="'/'"/>
        </xsl:map>
    </xsl:variable>

    <xsl:variable name="serialize-options" as="map(xs:string, xs:anyAtomicType)">
        <xsl:map>
            <xsl:map-entry key="'method'" select="'json'"/>
            <xsl:map-entry key="'use-character-maps'" select="$character-map"/>
        </xsl:map>
    </xsl:variable>

    <xsl:value-of select="f:replace-doubles-ints(fn:serialize(fn:parse-json(fn:xml-to-json($xml)), $serialize-options))"/>
  ```
  You need to also add XML namespace support `xmlns:xs="http://www.w3.org/2001/XMLSchema"` if it's not already in the stylesheet.

repository: CiscoCTA/taxii-log-adapter

gha_language: Java

repo_name: CiscoCTA/taxii-log-adapter


text:
# VAE-NCA

This repo provides the code to replicate the experiments in the paper:

>  Image Generation With Neural Cellular Automatas [arxiv link](https://arxiv.org/abs/2010.04949)

In this paper, we propose a novel approach to generate images (or other artworks) by using neural cellular automatas (NCAs). Rather than training NCAs based on single images one by one, we combined the idea of variational autoencoders (VAEs), and hence explored some applications, such as image restoration and style fusion.

Welcome to cite our work:

```
@article{chen2020image,
  title={Image Generation With Neural Cellular Automatas},
  author={Chen, Mingxiang and Wang, Zhecheng},
  journal={arXiv preprint arXiv:2010.04949},
  year={2020}
}
```

The trained models can be downloaded from:

https://drive.google.com/drive/folders/1sGXbnsZCF4w3FhvTi0J6bXBKlP-XebmY?usp=sharing