text:
# BIOMD0000000315: Oligator

## Installation

Download this repository, and install with distutils

`python setup.py install`

Or, install using pip

`pip install git+https://github.com/biomodels/BIOMD0000000315.git`

To install a specific version (in this example, from the 2014-09-16 BioModels release)

`pip install git+https://github.com/biomodels/BIOMD0000000315.git@20140916`

## Usage

Importing the model package.

`import BIOMD0000000315 as model`

Get the SBML string from the model

`print model.sbmlString`

If [python-libsbml](https://pypi.python.org/pypi/python-libsbml) bindings are
installed, the libsbml.SBMLDocument object is also accessible

`model.sbml`

# Model Notes

This is the model of the in vitro DNA oscillator called oligator with the
optmized set of parameters described in the article:
**Programming an in vitro DNA oscillator using a molecular networking strategy.**
Montagne K, Plasson R, Sakai Y, Fujii T, Rondelez Y. Mol Syst Biol. 2011 Feb
1;7:466. PubmedID: [21283142](http://www.ncbi.nlm.nih.gov/pubmed/21283142) ,
Doi: [10.1038/msb.2010.120](http://dx.doi.org/10.1038/msb.2010.120)

Abstract:
Living organisms perform and control complex behaviours by using webs of
chemical reactions organized in precise networks. This powerful system
concept, which is at the very core of biology, has recently become a new
foundation for bioengineering. Remarkably, however, it is still extremely
difficult to rationally create such network architectures in artificial, non-
living and well-controlled settings. We introduce here a method for such a
purpose, on the basis of standard DNA biochemistry. This approach is
demonstrated by assembling de novo an efficient chemical oscillator: we encode
the wiring of the corresponding network in the sequence of small DNA templates
and obtain the predicted dynamics. Our results show that the rational
cascading of standard elements opens the possibility to implement complex
behaviours in vitro. Because of the simple and well-controlled environment,
the corresponding chemical network is easily amenable to quantitative
mathematical analysis. These synthetic systems may thus accelerate our
understanding of the underlying principles of biological dynamic modules.

The model reproduces the time courses in fig 2B. The parameter identifiers of
the reaction constants are not the same as in the supplemental material, but
are just called kXd and kXr for the forward and backwards constant of reaction
X respectively.

This model originates from BioModels Database: A Database of Annotated
Published Models (http://www.ebi.ac.uk/biomodels/). It is copyright (c)
2005-2011 The BioModels.net Team.
For more information see the [terms of
use](http://www.ebi.ac.uk/biomodels/legal.html) .
To cite BioModels Database, please use: [Li C, Donizelli M, Rodriguez N,
Dharuri H, Endler L, Chelliah V, Li L, He E, Henry A, Stefan MI, Snoep JL,
Hucka M, Le Novère N, Laibe C (2010) BioModels Database: An enhanced, curated
and annotated resource for published quantitative kinetic models. BMC Syst
Biol., 4:92.](http://www.ncbi.nlm.nih.gov/pubmed/20587024)


text:
## Deployed Website

The production version of this website is running at: https://www.waterreuseapp.org/

## About This Project

This project was developed for the non-profit Recode (https://www.recodenow.org/).
It is a web application to record and store various "water reuse rules," providing a central place
to record how and where water can be re-used. Each reuse rule also links to the pertinent city, county or
state codes.

This application was developed by the Winter-Spring 2020 Capstone team at Portland State University, consisting of:

- Dmitri Murphy
- Tyler Race
- Davis Giang
- Alexander Wallace
- Paul Hubbard
- Jubal Gonzalez-Santos
- Steven Schulze

## How to Run the Project Locally

To run the project locally, please see the [Laravel installation instructions](https://laravel.com/docs/7.x/installation) to first install Laravel on your machine.

After installing Composer and Laravel, and cloning the project, it can be served locally by running the command `php artisan serve` in the project directory.

The following two sections are taken from the Laravel Readme file:

## About Laravel (framework used for this project)

Laravel is a PHP web application framework with expressive, elegant syntax.
We believe development must be an enjoyable and creative experience to be truly fulfilling.
Laravel takes the pain out of development by easing common tasks used in many web projects.
Laravel is accessible, powerful, and provides tools required for large, robust applications.

## Learning Laravel

Laravel has the most extensive and thorough [documentation](https://laravel.com/docs) and video tutorial library of all modern web application frameworks, making it a breeze to get started with the framework.

If you don't feel like reading, [Laracasts](https://laracasts.com) can help. Laracasts contains over 1500 video tutorials on a range of topics including Laravel, modern PHP, unit testing, and JavaScript. Boost your skills by digging into our comprehensive video library.

## Contributing

Please contact Recode [here](https://www.recodenow.org/contact-us/) if you would like to contribute to this project.

## License

This code is licensed under the [MIT license](https://opensource.org/licenses/MIT).

license: MIT

repository: Capstone-Team-E/water-reuse-app

branch_name: refs/heads/master

extension: md

gha_language: Blade

gha_license_id: MIT

license_type: permissive

repo_name: Capstone-Team-E/water-reuse-app


text:
# TestDiff
[![Build Status](https://travis-ci.org/grantspeelman/test_diff.svg?branch=master)](https://travis-ci.org/grantspeelman/test_diff)

Gem that attempts to find the tests that are required to run for the changes you have made.

## Project requirements

* RSpec 2+
* project tracked with git

## Installation

Add this line to your application's Gemfile:

```ruby
gem 'test_diff', group: :test
```

And then execute:

    $ bundle

## Rails Setup

If `eager_load` is enabled in `config/environments/test.rb`, disable it based on `ENV['TEST_DIFF_COVERAGE']`
EG:

```ruby
config.eager_load = ENV['TEST_DIFF_COVERAGE'].blank?
```

Also make sure to disable `simple_cov` if you use it when `ENV['TEST_DIFF_COVERAGE']` is set
EG:

```ruby
unless ENV['TEST_DIFF_COVERAGE']
  require 'simplecov'
  SimpleCov.start 'rails'
end
```

## Usage

Building the test coverage index (run once a day on your main branch)

```bash
    $ bundle exec test_diff build_coverage spec/spec_helper.rb
    $ # part here to upload test_diff_coverage to a shared space, ie aws
```

Running a test difference (after commit on your separate branch)

```bash
    $ # part here to download test_diff_coverage from shared space, ie aws
    $ bundle exec test_diff rspec
```

Updating the test coverage index (after separate branch merge into main branch)

```bash
    $ # part here to download test_diff_coverage from shared space, ie aws
    $ bundle exec test_diff build_coverage_diff spec/spec_helper.rb
    $ # part here to upload test_diff_coverage to a shared space, ie aws
```

## Development

After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/console` for an interactive prompt that will allow you to experiment.

To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release` to create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).

## Contributing

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


text:
# Python Module

AtlasHDF gets a nice python module.  Let me comment:

## The module

At the moment, the module implements three functions as a PoC

```python
    .def("import_immediate", &AtlasHDF::import)
    .def("set_nodes_filter", &AtlasHDF::set_nodes_filter)
    .def("set_container", &AtlasHDF::set_container)
```

All of them support method chaining such that the following snippet works

```python
x = atlashdf.AtlasHDF()
x.set_container("berlin.h5").set_nodes_filter("select(.ele!=null) | .").import_immediate("berlin-latest.osm.pbf")
```

Similarly, you can filter just some content to suppress unneeded attributes. For example, the following query
would suppress all attributes except elevation, but elevation would even have a good structure in the sense that the key will exist in all nodes (which was not true before), but can have a null value for those that did not have
the elevation key in the input:

```python
set_nodes_filter("{\"ele\":.ele}")
```

Without this filter, the file `berlin.h5` starts like this:

```python
>>> h5py.File("berlin.h5")["osm"]["nodes_attr"][:10]
array([[b'{"ele":"39.1"}'],
       [b'{}'],
       [b'{}'],
       [b'{}'],
       [b'{}'],
       [b'{"crossing":"uncontrolled","crossing:island":"yes","highway":"crossing","tactile_paving":"yes"}'],
       [b'{}'],
       [b'{}'],
       [b'{}'],
       [b'{"bus":"yes","name":"Londoner Stra\xc3\x9fe","public_transport":"stop_position","ref:BVG":"103010","website":
"https:\\/\\/qr.bvg.de\\/h103010"}']],
      dtype=object)
```

But with this filter, it has the following structure:

```python
>>> import h5py
>>> h5py.File("berlin.h5")["osm"]["nodes_attr"][:10]
array([[b'{"ele":"39.1"}'],
       [b'{"ele":null}'],
       [b'{"ele":null}'],
       [b'{"ele":null}'],
       [b'{"ele":null}'],
       [b'{"ele":null}'],
       [b'{"ele":null}'],
       [b'{"ele":null}'],
       [b'{"ele":null}'],
       [b'{"ele":null}']], dtype=object)
>>>
```

## Usage and Roadmap

At the moment, filtering is enabled for the nodes, which does not make ultimate sense. Any JQ query across the
attributes is allowed. Any empty result `null` leads to omit of the nodes. This has to be extended to ways and
relations. In a common setting, JQ queries will first be used to suppress all elements that we are not interested in.

For example, a query on polygons could look like
```
select(.natural != null) | select(.natural == "water") | {"natural": .natural}
```
This example would select all polygons with a tag "natural==water" and then suppresses all other attributes by building
a new output object. In essence, if the "natural==water" is not present, it will suppress the whole polygon entry, if
it is there, the attributes will be `{"natural":"water"}` but can be extended in the query.

JQ is a beast, but the best beast I know. See [https://stedolan.github.io/jq/manual/v1.5/](https://stedolan.github.io/jq/manual/v1.5/)

We will have to extend this to ways and relations, but this is easy, I will do so soon.

## Development Decision

While jq and oniguruma should be embedded (to compile on Windows later), I decided not to make them submodules at the
moment as I had to even change the Makefile.am to compile them. I hope that this compilation can later by pythonized,
but it might not be so easy. Hence, we will (at least for Windows) have to cross-compile or compile independently.

jq and onig are the upstreams with just adding -fPIC to AM_LDFLAGS, AM_CFLAGS and AM_CPPFLAGS followed by an

```bash
autoreconf -vfi
./configure
make
```

This generates libraries that are explicitly added in `setup.py`.

If you have problem with non-relocatable code, triple-check your settings. And don't rebuild the lexer of JQ, especially not on Mac (they have an old bison).

## Requirements

- Install dependencies from Debian using apt

This depends on

- libosmpbf
- protobuf-lite
- zlib
- hdf5 (serial version)

repository: tum-bgd/atlashdf

branch_name: refs/heads/main

gha_language: C

repo_name: tum-bgd/atlashdf


text:
BlockLocker
===========

[![Build Status](https://img.shields.io/github/actions/workflow/status/rutgerkok/BlockLocker/build.yml?branch=master)](https://github.com/rutgerkok/BlockLocker/actions/workflows/build.yml) [![Download at SpigotMC.org](https://img.shields.io/badge/download-SpigotMC.org-orange.svg)](http://www.spigotmc.org/resources/blocklocker.3268/)
[![Latest release](https://img.shields.io/github/release/rutgerkok/BlockLocker.svg)](https://github.com/rutgerkok/BlockLocker/releases)
[![Commits since latest release](https://img.shields.io/github/commits-since/rutgerkok/BlockLocker/latest.svg)](https://github.com/rutgerkok/BlockLocker/releases)

Plugin for locking individual blocks in Minecraft (like chests) using signs.

Current features:

* Locks chests, furnaces, doors and a few other containers using the familiar `[Private]` and `[More Users]` signs.
* Signs placed against a container are automatically filled with `[Private]` and the name of the player.
* Only the owner of a protection can destroy a protection.
* Admins can still open protected doors and containers.
* UUID support
  * UUIDs are saved to hidden hover text data on the sign, never visible for users.
  * Automatically looks up UUIDs for signs from Lockette and Deadbolt when they are read.
* Fully configurable
  * All messages can be translated.
  * You can change which block types can be protected. Even more complex blocks like levers work correctly.
* Group support: adding `[MyGroup]` to the sign will allow anyone with the permission node `blocklocker.group.mygroup` (grant the lowercase node) and anyone in a scoreboard team or in a faction of MassiveCraft Factions called `MyGroup` (case insensitive).
* Correctly handles complex blocks:
  * Double door support: protecting one half also protects the other half, opening one half opens the other half.
  * Doors can be set to close automatically. BlockLocker does not just toggle the open state, it will actually close the door.
  * Double chest support: protecting one half also proects the other half.
  * Trapdoor support: the sign can be attached to either the "hinge"-block or the trapdoor itself.
  * Fence gate support: the sign can be attached to either the the fence gate block or the block below.
* The owner of a protection can change the signs after creating them using the `/blocklocker <line number> <name>` command.
* Auto-updater, so that you are notified when there is a new version available.

Compilation
-----------

BlockLocker uses Maven.

* Install [Maven 3](http://maven.apache.org/download.html)
* Download this repo and run the command `mvn clean install`

After running the command there will be a file `blocklocker-XX.jar` (where `XX` is a version number) in the `target` folder.

Hooking into BlockLocker
------------------------

BlockLocker has two APIs for other plugins to use: version 1 and version 2. Right now, the only difference between them is that version 1 uses `com.google.common.base.Optional` while version 2 uses `java.util.Optional`. Version 1 was first included in BlockLocker 0.1, and the plan is to include it in all future versions of BlockLocker as long as the class `com.google.common.base.Optional` exists. Version 2 was realeased on November 17, 2019 with BlockLocker 1.7.

* If your plugin supports Minecraft 1.14, chances are that people are still using BlockLocker 1.6, and you should use API version 1.
* If your plugin supports Minecraft 1.13 or older, you'll have to use API version 1, as version 2 is not available for Minecraft 1.13.
* If your plugin only supports Minecraft 1.15 and newer, then you can safely use API version 2.

### Maven
Add the following repository to your `pom.xml` file:

```xml
<repository>
	<id>codemc-repo</id>
	<url>https://repo.codemc.org/repository/maven-public/</url>
</repository>
```

Add the following file:

```xml
<dependency>
	<groupId>nl.rutgerkok</groupId>
	<artifactId>blocklocker</artifactId>
	<version>1.9</version>
	<scope>provided</scope>
</dependency>
```

If you want to use API version 1, use BlockLocker version 0.1, otherwise for API version 2 use BlockLocker 1.7. Other BlockLocker versions are not uploaded to this repository.

### Check whether the plugin is enabled
```java
boolean enabled = Bukkit.getPluginManager().getPlugin("BlockLocker") != null;
```

### The BlockLockerAPI - version 1
The nice thing about API version 1 is that it works with all old BlockLocker versions, all the way back to version 0.1. Version 1 still uses the `com.google.common.base.Optional` class. Because Java 8 also includes an `Optional` class, it can be expected that Google's `Optional` will be removed at some point in the future. At this moment, this API will also dissappear. However, currently the `Optional` class is not deprecated by Google, so it will take at least two years for that class to get removed. So it's still safe to use this API.

Example usage:

```java
Optional<OfflinePlayer> owner = BlockLockerAPI.getOwner(block);
```

In version 0.1 these methods were available in the BlockLockerAPI class:

```
getOwner(Block block)
getOwnerDisplayName(Block block)
isAllowed(Player player, Block block, boolean serverAdminsAlwaysAllowed)
isOwner(Player player, Block block)
isProtected(Block block)
```

You can view the complete class, along with documentation, [here](https://github.com/rutgerkok/BlockLocker/blob/master/src/main/java/nl/rutgerkok/blocklocker/BlockLockerAPI.java).

If you solely use these methods, your plugin will work with *all* versions of BlockLocker from the past.

### The BlockLockerAPI - version 2
Use the class `BlockLockerAPIv2` instead of `BlockLockerAPI`. There are no differences between version 2 and version 1 yet, except that the API now uses `java.util.Optional` instead of the older `com.google.common.base.Optional`.

### More advanced functionality
To block placement of protection signs in certain areas, you can listen to the `PlayerProtectionCreateEvent` of BlockLocker or the `BlockPlaceEvent` of Bukkit. This works even for auto-placed signs.

I have kept the number of methods in BlockLockerAPI small, as each method will need
to be around in all future versions of BlockLocker. If you need to do something more
advanced, you need to venture outside the class. Keep in mind that your plugin might
break in the future. Here are some things that you can do.

Here's an example for checking whether redstone is allowed in the protection:

```java
private boolean isRedstoneAllowed(Block block) {
    BlockLockerPlugin plugin = BlockLockerAPIv2.getPlugin();
    Optional<Protection> protection = plugin.getProtectionFinder().findProtection(block);
    if (!protection.isPresent()) {
        // Not protected, so redstone is allowed to change things here
        return true;
    }
    Profile redstoneProfile = plugin.getProfileFactory().fromRedstone();
    // Will return true when [Redstone] or [Everyone] is on one of the signs
    return protection.get().isAllowed(redstoneProfile);
}
```

Here's an example of how to add a custom group system:

```java
BlockLockerAPIv2.getPlugin().getGroupSystems().addSystem(new GroupSystem() {

            @Override
            public boolean isInGroup(Player player, String groupName) {
                // TODO Auto-generated method stub
                return false;
            }});
```

Here's an example of how to add another block type as a protectable type:

```java
    BlockLockerAPIv2.getPlugin().getChestSettings().getExtraProtectables().add(new ProtectableBlocksSettings() {

            @Override
            public boolean canProtect(Block block) {
                // Return whether the block can be protected by ANY of the protection types (CONTAINER, DOOR, etc.)
		// Must be consistent with the method below
                return false;
            }

            @Override
            public boolean canProtect(ProtectionType type, Block block) {
                // Return whether the block can be protected by the given protection types (CONTAINER, DOOR, etc.)
		// Must be consistent with the method above
                return false;
            }});
```

If you believe that a method should be added to BlockLockerAPI, please create a Github issue in this repository.

repository: rutgerkok/BlockLocker

gha_language: Java

repo_name: rutgerkok/BlockLocker


text:
# Visualizer

> Visualizer is a Node.js application that citizens or government institutions can use, in order to visualize .n3 decisions in their web browsers.

## Build Setup

``` bash
# install n3-composer dependencies
$ npm install
# Open visualizer
$ node index.js
```

## Usage Instructions

Visualizer takes two `GET` parameters (namely `decisionFolder` and `iun`) on `visualize` route. For demonstration reasons, a `const DECISIONS_DIRECTORY` is set in `index.js (line:9)` to point to [rdf samples folder](https://github.com/eellak/gsoc17-diavgeia/tree/master/rdf/samples) and it is something that the current production code of Diavgeia should change according to its needs.

For instance, a call to `localhost:3333/vizualize?decisionFolder=Appointment&iun=ΨΟΗΩ46ΨΖΣ4-Ι56`, will result to the visualization of this `.n3` [appointment decision](https://github.com/eellak/gsoc17-diavgeia/blob/master/rdf/samples/Appointment/%CE%A8%CE%9F%CE%97%CE%A946%CE%A8%CE%96%CE%A34-%CE%9956.n3), as follows:

![Visualization of an appointment decision](http://image.ibb.co/g1Y0U5/visualization.png)


text:
# pvc-remover

Kubernetes controllers to remove a `PersistentVolumeClaim` (PVC) of a particular
`StorageClass` when an associated `Pod` is completed.

This project's primary purpose is the early deletion of volumes provisioned by
[cache-provisioner](https://github.com/mgoltzsche/cache-provisioner) so that the
volume contents can be committed and quickly reused for the next (build) job.

## How it works

The *Pod controller* annotates and deletes matching PVCs (`storageClassName`, `accessMode=ReadWriteOnce`)
that are associated with a matching, completed Pod (`annotations`?, `labels`?, `status.phase=Succeeded`, `restartPolicy=Never`).
The *PVC controller* removes the finalizer `kubernetes.io/pvc-protection` from PVCs
that have a deletion timestamp and the annotation `pvc-remover.mgoltzsche.github.com/no-pvc-protection`
allowing unsafe deletion while still referenced by Pods.

## Build

```
make
```

## Test

Run controller tests:
```
make test
```

Test interactively against a real cluster:
```
make manager
./bin/manager --storage-class=<your-ephemeral-storage-class-name>
```

repository: mgoltzsche/pvc-remover

repo_name: mgoltzsche/pvc-remover


text:
# Sentimental Bot: tsep-by-step code snippets

This folder contains the partial code snippets found in each of the step-by-step instructions of [Build an Emotionally-Aware Chatbot in 15 Minutes](https://blog.algorithmia.com/building-an-emotionally-aware-chatbot/)

If you aren't working the step-by-step tutorial, you probably want [this folder instead](../)

repository: algorithmiaio/integrations

gha_language: Python

repo_name: algorithmiaio/integrations


text:
# Mount host volume into Docker container

This application shows how to mount a folder of the host so it is accessible from within the container.

## Application

The `glob.py` application simply finds all the files in the `/data` folder of the container and prints the list of files, including their relative path.

```python
# glob.py
from pathlib import Path

if __name__ == "__main__":

    p = Path("/data")
    files = p.glob("*")

    for file in files:
        print(file.as_posix())
```

## Dockerfile

The `Dockerfile` simply copies the `glob.py` application and runs it.

```Dockerfile
FROM python:3

COPY glob.py ./

CMD [ "python", "glob.py" ]
```

## Usage

### Build

```
$ docker build -t glob .
```

### Run

Use the `-v` option to mount the host path to `/data` in the container.

```
$ docker run --rm -v absolute_host_path:/data glob
```

This will print out the content of `absolute_host_path`.

## References

1. https://docs.docker.com/storage/volumes/.

license: Unlicense

repository: DrGFreeman/docker-reference

repo_name: DrGFreeman/docker-reference


text:
# Release notes for April 4th - April 18th

## Table of contents
* [Chat](#chat)
* [Network Traversal](#network-traversal)
* [Virtual Visits](#virtual-visits)

## Chat

### Android
#### [1.1.0 (2022-04-11)](https://github.com/Azure/azure-sdk-for-android/blob/main/sdk/communication/azure-communication-chat/CHANGELOG.md#110-2022-04-11)
- Added GA support for push notifications.

### iOS
#### [1.1.0 (2022-04-11)](https://github.com/Azure/azure-sdk-for-ios/blob/main/sdk/communication/AzureCommunicationChat/CHANGELOG.md#110-2022-04-11)
- Released GA version of the SDK.
- Added meta data to chat messages.
- Added display name to typing indicator.

## Network Traversal

### Java
#### [1.1.0-beta.2 (2022-04-13)](https://github.com/Azure/azure-sdk-for-java/blob/main/sdk/communication/azure-communication-networktraversal/CHANGELOG.md#110-beta2-2022-04-13)
- Update of `azure-core` to 1.27.0
- Update of` azure-communication-common` to 1.1.2

### Bugs Fixed
- Set Ttl parameter in the Communication Relay Async client

## Virtual Visits
Virtual Visits is a web app you can host to provide your customers with a branded virtual consultation experience.

### [JS](https://github.com/Azure-Samples/communication-services-virtual-visits-js)
- Lobby, calling, and chat experiences for your clients. Browser-based and mobile-friendly, clients won't need to install any apps.
- Quick customization options for colors, themes, and features via a .json config file.
- Integration with Microsoft Teams. Let your staff host and join meetings using familiar Teams UI, while the clients join the same call via your custom branded web app.
- Integration with Microsoft Bookings. Configure Bookings to allow your clients to schedule appointments and receive join links to your own hosted app.
- Open source and customizable meeting UI controls. The app is built using ACS UI Library which has many options for customizing layouts, rendering, and behaviors.

repository: Azure/Communication

repo_name: Azure/Communication


text:
---
layout: post
title: trifoil
cover: cover.jpg
date:   2021-01-31 12:00:00
categories:
permalink: trifoil
size: small
cardImage: albums/crystalball/0.png
hidden: true
---

Winner of Best Blinks Game at the Playcrafting Global Game Jam 2021. Made in collaboration with Spencer Kee.

<!--more-->

Trifoil is a long-form, 2 player turn based strategy game in the vein of chess or go that can be played with 6 or more blinks. Players take turns placing links, pushing them, and rotating sections of the board to try to build a long chain before their opponent can.

More information and ways to play without Blinks here: https://github.com/aaronsantiago/trifoil

Technologies used: Arduino

gha_language: JavaScript


text:
---
layout: feature
title: 'Rel'
shortdef: 'relational'
udver: '2'
---

  Values:
  Cont
  NCont

`Rel` is a morpheme that combines with lexical roots and postpositions. They signalize the
adjacency or contiguity (Rel=Cont) and non-adjacency or non-contiguity (Rel=NCont) of head and depenent,
e.g., possessor-noun, object-postposition.

### `Cont`: contiguous

Contiguity is more often associated with

#### Examples

* _ne r-ɛhɛ _ “about you (preceding element)"
* _ne r-ɛhɛ _ “about you (preceding element)"

### `NCont`: non-contiguous

Non-contiguity is more often associated with

#### Examples

* _ɛhɛ _ “about”
* _ɛhɛ _ “about”

## Diffs

### Prague Dependency Treebank

The PDT tagset does not distinguish `Ptan` from `Plur` and `Coll` from `Sing`,
therefore this distinction is not being made in the converted data.

repository: UniversalDependencies/docs

branch_name: refs/heads/pages-source

gha_language: HTML

repo_name: UniversalDependencies/docs


text:
# NAME
Openresty-digest-auth

# INSTALL
lua-resty-memcached is required

```
sudo luarocks install lua-resty-memcached
```

modify nginx.conf

```
    location /members {
        access_by_lua_file /path/2/digest.lua;
    }
```

restart the openresty-process
```
sudo systemctl restart openresty.service
```

# CONFIGURE

```
vim digest.lua
```

set your memcached's hostname, port
```
local memcachedConfig = {
	hostname = "<IP_ADDRESS>", -- meybe cannot resolve "localhost"
	port = 11211,
	expireSec = 10 * 60, -- 10 minute
}
```

set your digest-auth accounts
```
-- user = plain-password
local Users = {
	abc = "def",
}
```

repository: LightningDAISY/openresty-digest-auth

repo_name: LightningDAISY/openresty-digest-auth


text:
# Poseidon Cluster [![Build Status](https://travis-ci.org/bsm/poseidon_cluster.png?branch=master)](https://travis-ci.org/bsm/poseidon_cluster) [![Coverage Status](https://coveralls.io/repos/bsm/poseidon_cluster/badge.png?branch=master)](https://coveralls.io/r/bsm/poseidon_cluster?branch=master)

Poseidon Cluster is a cluster extension of the excellent [Poseidon](http://github.com/bpot/poseidon) Ruby client for Kafka 0.8+. It implements the distribution concept of self-rebalancing *Consumer Groups* and supports the consumption of a single topic from multiple instances.

Consumer group instances share a common group name, and each message published to a topic is delivered to one instance within each subscribing consumer group. Consumer instances can be in separate processes or on separate machines.

## Usage

Launch a consumer group:

```ruby
require 'poseidon_cluster'

consumer = Poseidon::ConsumerGroup.new(
            "my-group",                               # Group name
            ["kafka1.host:9092", "kafka2.host:9092"], # Kafka brokers
            ["kafka1.host:2181", "kafka2.host:2181"], # Zookeepers hosts
            "my-topic")                               # Topic name

consumer.partitions # => [0, 1, 2, 3] - all partitions of 'my-topic'
consumer.claimed    # => [0, 1] - partitions this instance has claimed
```

Fetch a bulk of messages, auto-commit the offset:

```ruby
consumer.fetch do |partition, bulk|
  bulk.each do |m|
    puts "Fetched '#{m.value}' at #{m.offset} from #{partition}"
  end
end
```

Get the offset for a partition:

```ruby
consumer.offset(0) # => 320 - current offset from partition 0
```

Fetch more messages, commit manually:

```ruby
consumer.fetch commit: false do |partition, bulk|
  bulk.each do |m|
    puts "Fetched '#{m.value}' at #{m.offset} from #{partition}"
  end

  consumer.commit partition, bulk.last.offset+1 unless bulk.empty?
end
```

Initiate a fetch-loop, consume indefinitely:

```ruby
consumer.fetch_loop do |partition, bulk|
  bulk.each do |m|
    puts "Fetched '#{m.value}' at #{m.offset} from #{partition}"
  end
end
```

For more details and information, please see the [Poseidon::ConsumerGroup](http://rubydoc.info/github/bsm/poseidon_cluster/Poseidon/ConsumerGroup) documentation and the [Examples](https://github.com/bsm/poseidon_cluster/tree/master/examples).

## Running Tests

The test suite will automatically download, configure and run Kafka locally, you only need a JRE. Run the suite via:

```bash
bundle exec rake spec
```

## Licence

```
Copyright (c) 2014 Black Square Media

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

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

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

gha_language: Ruby


text:
# EcomDev::ChefSpec

A set of valuable helper to make writing ChefSpecs even more easier.

Features:

 * You can define matchers for your LWRP and HWRP by using DSL based file in your specs directory.
    * By default it looks in `spec/matchers.rb`, `spec/matchers/*.rb`,  `spec/library/matchers.rb`, `spec/library/matchers/*.rb`
    * Example of the file DSL

      ```ruby
      matcher :resource_name, :action
      matcher :resource_name, [:delete, :create]
      runner :resource_name
      ```

    * It automatically includes matchers from other recipes, that contain such a Ruby file

 * By default it mocks any inclusion of recipes, except described one. You can specify additional one by calling `allow_recipe` in spec DSL.
 * Allows to supply additional cookbook directory for your specs. Just add in `spec_helper.rb` file the following code

   ```ruby
   EcomDev::ChefSpec::Configuration.cookbook_path('path/to/your/test/cookbooks')
   EcomDev::ChefSpec::Configuration.cookbook_path('another/path/to/your/test/cookbooks')
   ```

    It will automatically include the following paths for cookbook search:

    * Berkshelf or Librarian path if any of those was included before
    * `path/to/your/test/cookbooks`
    * `another/path/to/your/test/cookbooks`

 * Allows to create platform based test cases by calling `platform(*filters)` method. Platform file is a json of such a structure:

   ```javascript
   {
       "os": {
           "ubuntu": ["10.04", "12.04", "13.10", "14.04"],
           "debian": ["6.0.5", "7.2", "7.4"],
           "freebsd": "9.2",
           "centos": ["5.8","6.4", "6.5"],
           "redhat": ["5.6", "6.3", "6.4"],
           "fedora": ["18", "19", "20"]
       },
       "family": {
           "debian": ["ubuntu", "debian"],
           "rhel": ["redhat", "centos"],
           "fedora": ["fedora"],
           "freebsd": ["freebsd"]
       }
   }
   ```

    By default this file is read from such location spec/platform.json. You can override it by specifying `EcomDev::ChefSpec::Helpers::Platform.platform_path='path/to/dir'` and `EcomDev::ChefSpec::Helpers::Platform.platform_file='file.json'` or directly by calling `platform_load(file, path)` in your test case body

    When calling `platform` method you can pass a ruby block, so it will iterate over specified platforms:

    ```ruby
    platform(:debian, :ubuntu) do |os, version|
      context 'In scope of ' + os + ' ' + version do
         it 'does crazy thing' do
             # .. you test code
         end
      end
    end
    ```

     it will produce the following output:

    ```
    In scope of ubuntu 14.04
       does crazy things
    In scope of debian 7.4
       does crazy things
    ```

## Build Status

[![Develop Branch](https://api.travis-ci.org/EcomDev/ecomdev-chefspec.svg?branch=develop)](https://travis-ci.org/EcomDev/ecomdev-chefspec) **Next Release Branch**

[![Master Branch](https://api.travis-ci.org/EcomDev/ecomdev-chefspec.svg)](https://travis-ci.org/EcomDev/ecomdev-chefspec) **Current Stable Release**

## Installation

Add this line to your application's Gemfile:

```ruby
gem 'ecomdev-chefspec'
```

And then execute:

```bash
bundle
```

Or install it yourself as:

```bash
gem install ecomdev-chefspec
```

## Usage

Inside of your specs helper you should include this library after chefspec

```ruby
require 'ecomdev/chefspec'
```

Please note, that you should include it in the end, after all the chef spec files are included. E.g. if you use bershelf loader for your cookbooks, you should include `ecomdev/chefspec` after you've included `chefspec/berkshelf`

## Contributing

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

repository: EcomDev/ecomdev-chefspec

repo_name: EcomDev/ecomdev-chefspec


text:
# kitchensink - Pyrene Kitchensink

Design principles and demo project for [pyrene](../pyrene).

## Development

In order to ease development of pyrene, we recommend to use the kitchensink together with your local version of pyrene.

Make pyrene available and keep watching it (in your pyrene folder):
```bash
npm run expose
```

Link it in kitchensink and fire up the development server (in your kitchensink folder):
```bash
npm install
npm link pyrene
npm run watch
```

If you want to use pyrene-graphs instead you can also expose with tuktuktwo:
```bash
cd ~/git/tuktuktwo
npm run expose
cd ~/git/pyrene-graphs
npm run expose-tuktuktwo
```

If you don't want to use your local copy of pyrene any longer, just do a fresh package install:
```bash
npm install
```

## Update Pyrene

- `npm install -E<EMAIL_ADDRESS>
## Release

- Push `master` branch
- Wait for bamboo to build it

repository: ibaldi/pyrene

repo_name: ibaldi/pyrene


text:
ppx\_module\_timer
==================

A ppx extension to record module startup times.

Modules using `ppx_module_timer` (included in `ppx_jane_kernel`) now have
instrumentation to record their startup time. If the environment variable
`PPX_MODULE_TIMER` is set (to anything), each module records its startup time,
and before exiting the process prints out all of the module times in the order
they occurred.

gha_language: OCaml


text:
---
name: Pull Request
title: "[feat | fix](scope): (short-title)"
labels: "needs review"
assignees: "codejedi365"
---

<!--
Thank you for providing a solution to make this project better!
Please fill in as much of the template below as you’re able.
-->

## Purpose

<!-- Reason for the PR (solves an issue/problem, adds a feature, etc) -->

## Rationale

<!-- How did you come to this conclusion as the solution? What was your
reasoning? What were you trying to do? -->

## How did you test?

<!-- How did you verify this solution? -->

## How to Verify

<!-- List of steps to validate your PR -->

<!-- I prefer Test Driven Development (TDD) or BDD so ideally you have added to
the unit test suite to prove it was a problem before and now the problem is
solved -->

<!-- EXAMPLE Steps
1. Fetch this branch

   ```sh
   git remote add <fork_name> <fork_url.git>
   git fetch <fork_name>
   # start from master at base of branch
   git checkout $(git merge-base master <fork_name/branch>)
   ```

2. Grab relevant test files & pkgs

    ```sh
    git checkout <fork_name/branch> -- path/to/testfile(s)
    npm install
    ```
3. [...]
-->

repository: gabrieli/jest-serial-runner

gha_language: Shell

repo_name: gabrieli/jest-serial-runner


text:
![](images/300/300.JPG)
Updated: August 13, 2017 for BDCSCE Version 17.3.1-20

# Lab: R and Zeppelin

## Introduction

This lab will show you how to use **R** with the **Zeppelin notebook** of **Oracle Big Data Cloud (BDC)**.

In particular, this lab will show you how to use R/SparkR functionality within Zeppelin notebooks.  This functionality will allow you to use R to query hive tables and read data directly from the Object Store.  It will also allow you to query R data with Spark SQL and to leverage some of Spark's advanced machine learning algorithms.

Please direct comments to: David Bayard<EMAIL_ADDRESS>
## Objectives

- Use R and SparkR with Zeppelin Notebooks

## Required Artifacts

- A running BDCS-CE instance and Storage Cloud Object Store instance, created as per the instructions in the New Data Lake Journey Lab 100.  These instructions included the use of a special "bootstrap.sh" script which setup the BDCS-CE environment for this workshop.
- You completed the tutorials in the New Data Lake Journey Lab 200 Getting to know BDCS-CE
- You completed the Data Science Acceleration Journey Lab 200 Setup R, SparkR, and RStudio Server

# Connect to the BDCS-CE Console

## Steps

### **STEP 1**: Navigate/login to the Oracle Cloud My Services Dashboard

![](images/200/snap0011988.jpg)

### **STEP 2**: Navigate to the My Services page for your BDCS-CE cluster

![](images/200/snap0011989.jpg)

### **STEP 3**: Launch the Big Data Cluster Console

![](images/200/snap0012205.jpg)

# Learn how to use R and SparkR with Zeppelin Notebooks

## Open and run the "DataSci Tutorial 2 Using R with Zeppelin" note in the notebook

### **STEP 1**: Click on the Notebook tab.  Then click on the "DataSci Tutorial 2 Using R with Zeppelin" tutorial to open it.

![](images/300/snap0012220.jpg)

### **STEP 2**: Read and follow the instructions in the Tutorial

![](images/300/snap0012221.jpg)

# What you Learned

- Learned how to use R and SparkR with Zeppelin Notebook in BDCS-CE

# Next Steps

- Proceed to the next Lab to see R and SparkR in action with RStudio Server running on BDCS-CE

# Want to Learn More?

- [R project](https://www.r-project.org/)

- [SparkR (R on Spark)](http://spark.apache.org/docs/latest/sparkr.html)

repository: jdavies/learning-library

repo_name: jdavies/learning-library


text:
# Forking the Repository

1. Set up publishing.
    1. Create a [Docker Hub account](https://hub.docker.com/signup?next=%2F%3Fref%3Dlogin).
    1. Go to your [Security settings](https://hub.docker.com/settings/security).
    1. Click **New Access Token**.
    1. Enter an **Access Token Description**.
    1. Click **Create**.
    1. Note down your access token for later.
1. Set up CI/CD.
    1. Create a [GitLab](https://gitlab.com/users/sign_in#register-pane) account.
    1. [Connect](https://docs.gitlab.com/ee/ci/ci_cd_for_external_repos/github_integration.html) the GitHub repo to a GitLab repo.
    1. In the GitLab repo, create the following environment variables [via the UI](https://docs.gitlab.com/ee/ci/variables/#via-the-ui).

        |Key|Value|Masked|
        |---|---|---|
        |`DOCKER_HUB_USER`|Your Docker Hub username|No|
        |`DOCKER_HUB_PASSWORD`|The Docker Hub access token you noted down|Yes|

repository: garg-saurav/spacy-server

repo_name: garg-saurav/spacy-server


text:
# ADR 023: ABCI Codespaces

## Changelog

- *2018-09-01* Initial version

## Context

ABCI errors should provide an abstraction between application details
and the client interface responsible for formatting & displaying errors to the user.

Currently, this abstraction consists of a single integer (the `code`), where any
`code > 0` is considered an error (ie. invalid transaction) and all type
information about the error is contained in the code. This integer is
expected to be decoded by the client into a known error string, where any
more specific data is contained in the `data`.

In a [previous conversation](https://github.com/tendermint/abci/issues/165#issuecomment-353704015),
it was suggested that not all non-zero codes need to be errors, hence why it's called `code` and not `error code`.
It is unclear exactly how the semantics of the `code` field will evolve, though
better lite-client proofs (like discussed for tags
[here](https://github.com/tendermint/tendermint/issues/1007#issuecomment-413917763))
may play a role.

Note that having all type information in a single integer
precludes an easy coordination method between "module implementers" and "client
implementers", especially for apps with many "modules". With an unbounded error domain (such as a string), module
implementers can pick a globally unique prefix & error code set, so client
implementers could easily implement support for "module A" regardless of which
particular blockchain network it was running in and which other modules were running with it. With
only error codes, globally unique codes are difficult/impossible, as the space
is finite and collisions are likely without an easy way to coordinate.

For instance, while trying to build an ecosystem of modules that can be composed into a single
ABCI application, the Cosmos-SDK had to hack a higher level "codespace" into the
single integer so that each module could have its own space to express its
errors.

## Decision

Include a `string code_space` in all ABCI messages that have a `code`.
This allows applications to namespace the codes so they can experiment with
their own code schemes.

It is the responsibility of applications to limit the size of the `code_space`
string.

How the codespace is hashed into block headers (ie. so it can be queried
efficiently by lite clients) is left for a separate ADR.

## Consequences

## Positive

- No need for complex codespacing on a single integer
- More expressive type system for errors

## Negative

- Another field in the response needs to be accounted for
- Some redundancy with `code` field
- May encourage more error/code type info to move to the `codespace` string, which
  could impact lite clients.

repository: Alex-duzhichao/tendermint

repo_name: Alex-duzhichao/tendermint


text:
693  cd (change directory)
  694  cd Desktop/DBC_Stuff/
  695  git clone https://github.com/lucasrim/phase-0-gps-1.git (copy repository locally)
  696  ls (list files in directory)
  697  cd phase-0-gps-1/
  698  touch awesome_page.md (makes awesome_page.md)
  699  git add . (stages all the changes)
  700  git commit . -m "add aweesome_page.md" (commits changes to online repository)
  701  git push (pushes changes to online repository)
  702  git status (checks what's staged, committed)
  703  git checkout -b add-command-log (creates a branch called add-command-log)
  704  history (history of all terminal commands)
  705  history 15 (history of last 15 terminal commands)
  706  history 15 > README.md (copies the last 15 terminal commands to README.md)


text:
Ingress for Windows Phone 8
===========

Fully playable Google's AR Game Ingress port for Windows Phone.

- Windows Phone 8 required.
- Not working on simulator, GPS is needed.

Download
--------

You need to be developer to install it.

Support
-------

If you enjoy this software, please consider making a small donation, so I can continue to maintain and improve this app.

TODO
----

-Actually get it to load using Ingress API.

Videos
------

Screenshots
-----------

Attribution & License
---------------------

This project is licensed under the permissive ISC license. Parts imported from other projects remain under their respective licenses.

license: ISC

repository: Sakith/IngressWP

repo_name: Sakith/IngressWP


text:
## Cracking the Coding Interview, Fourth Edition

- Code on paper.
- Know your resume.
- Don't memorize solutions.
- Talk out loud.
- Behind the scenes for MS, Amazon, Google, Apple--system design and memory limits.
- "Would I have a beer with this guy?" and "Will I mind working next to this guy for six months?"
  - Smell nice. Don't ask if there are hot chicks.

### Before the Interview: Resume Advice

- Strong bullets:
  - "Accomplished X by implementing Y which led to Z."
- Projects.
- Programming Languages and Software. Languages: Ruby, prior experience with JavaScript, PHP. Currently studying Elixir.
- No personal information.
- Questions to ask the interviewer:
  - Genuine questions. Ex: 'How much of your day do you spend coding?', 'How many meetings do you have every week?', 'What is the ratio of testers to developers to product managers?' and 'How does project planning happen on the team?'
  - Insightful questions: Demonstrate your deep knowledge of programming or technologies.
  - Passion questions: 'I'm interested in scalability. How did you learn this?' and "I'm not familiar with technology X, but it sounds like a very interesting solution. Could you tell me about how it works?"

### Before the Interview: Technical Preparations

- Data structures: Linked lists, binary trees, tries, stacks, queues, vectors/`ArrayLists`, Hash tables.
- Algorithms: Breadth first search, depth first search, binary search, merge sort, quick sort, tree insert/find/etc.
- Concepts: Bit manipulation, singleton, factory design pattern, memory (stack vs heap), recursion, Big-O time.

### At the Interview: Handling Technical Questions.

- Ask your interviewer questions to resolve ambiguity.
  - Ex: sorting a list, what kind of list (array or linked list), what does it hold (numbers), are those numbers integers, are they positive always, how many need to be sorted?
- Design an algorithm.
  - Space and time complexities, what happens if there is a lot of data.
- Write pseudocode first, but make sure to tell your interviewer that you're writing pseudocode.
- Write your code, not too slow and not too fast.
- Test your code and carefully fix any mistakes.
  - 0, negative, null, maximums, general case

### At the Interview: Top Ten Mistakes Candidate Make

- **Practicing on a computer.** No computers, get out the old pen and paper.
- **Not rehearsing behavioral questions.** Behavioral questions are also asked too.
- **Not doing a mock interview.**
- **Trying to memorize solutions.**
- **Talking too much.** "What was the hardest bug?" Situation, action, response. Issue 1, issue 2, issue 3.
- **Talking too little.**
- **Rushing.**
- **Not debugging.**
- **Sloppy coding.** Imagine that you're writing for real-world maintainability.
- **Giving up.** You'll always be given a hard problem.

### At the Interview: Frequently Asked Questions

- You don't have to get every questions right, they want you to struggle with a hard problem.
- Tell the interview if you know the question--this demonstrates integrity.
- Dressing: one step above the nicest dressed employees in their position.
- Reapplying: after 6 months-1 year.

### Data Structures

- Hash tables.
- ArrayList (dynamically resizing array). When a vector is full, the array doubles in size.

1.1 Iterate over the array, storing the result of an iteration in an array. O(n) space and O(n) time.
1.2. Reversing a C-Style string: You can do the `.reverse`, but you can also iterate over the array then create a new array where you add at the start.
- Removing duplicate characters in a string:

```
abc
def
ghi

cba
def
ghi

cfa
deb
ghi

ifa
deb
ghc

gda
heb
ifc

```

repository: daryllxd/lifelong-learning

gha_language: Elixir

gha_license_id: Unlicense

repo_name: daryllxd/lifelong-learning


text:
# SndLatr source code

**DISCONTINUED**

## Project Structure:
I did not maintain this code for quite while, many things are probably outdated.
I won't be accepting pull requests here, but am happy to link anyones fork who's willing to maintain it.

### gae/
Server-side Google Appengine Code.
Save your `client_secrets.json` from the API manager of the Google Cloud Console
here.

### client/
Client side code injected by extension into gmail ui.  Build it with `npm install &&
bower install && grunt`. The code in `gae/` is copied to the build output
(`dist/`) and is intended to be depolyed as-is to GAE.

Hosts configuration is in `client/app/scripts/sndlatr/constants\*.js`

### website/
Pure informational website. Build with grunt just like client.

### chrome-extension\* / firefox-addons-\*
Browser extensions for Chrome/Firefox

## local dev
For local development run `dev_appserver.py .` in `gae`, run `grunt server` in
`client` and start Chrome with `client/local_insecure_chrome.sh`.

### client unitt tests
Run `karma start` in `client/` to run tests in watch mode.

### gae tests
Run tests with `./run_tests.py` .
Test setup might need some fixing due to changes in gae / nosegae since I used
it the last time.

repository: Schibum/sndlatr

repo_name: Schibum/sndlatr


text:
## kumactl generate public-key

Generate public key out of signing key

### Synopsis

Generate a public key for validating tokens.

```
kumactl generate public-key [flags]
```

### Examples

```

Extract a public key out of signing key used to issue tokens.

$ kumactl generate signing-key --format=pem > /tmp/key.pem
$ kumactl generate public-key --signing-key-path=/tmp/key.pem

```

### Options

```
  -h, --help                      help for public-key
      --signing-key-path string   path to a file with PEM-encoded private signing key
```

### Options inherited from parent commands

```
      --api-timeout duration   the timeout for api calls. It includes connection time, any redirects, and reading the response body. A timeout of zero means no timeout (default 1m0s)
      --config-file string     path to the configuration file to use
      --log-level string       log level: one of off|info|debug (default "off")
      --no-config              if set no config file and config directory will be created
```

### SEE ALSO

* [kumactl generate](kumactl_generate.md)	 - Generate resources, tokens, etc

repository: kumahq/kuma

gha_language: Go

repo_name: kumahq/kuma


text:
---
title: We're off to a great start
date: "2017-09-06T10:56:58+00:00"
author: georgeadams
description: AdoptOpenJDK has certainly come a long way over the last few months!
tags:
  - announcement
---
AdoptOpenJDK has certainly come a long way over the last few months!

We have a clean, bright [website](http://www.adoptopenjdk.net) to distribute binaries of [OpenJDK](http://openjdk.java.net/), with exciting plans for how it can be improved in the future.

Behind the website "shop front" there is a large continuous integration build and test farm, covering [multiple operating system and hardware combinations](https://github.com/AdoptOpenJDK/openjdk-infrastructure/blob/master/docs/adoptopenjdk.pdf).  The farm is put to good use compiling the OpenJDK code and running it through a suite of tests before publishing it.

All of our code is out there in [Github](https://github.com/AdoptOpenJDK) for you to study, so you know exactly what those binaries contain and how they were built.  We believe in open build and open testing of the open source code!

We started with OpenJDK version 8 as the latest stable code stream.  Now that the OpenJDK project is close to declaring the OpenJDK version 9 final, we have started building and testing that too, and expect to have tested binaries available from [the AdoptOpenJDK website](https://adoptopenjdk.net/?variant=openjdk9) and [via our API](https://api.adoptopenjdk.net/README) simultaneously.

We are also happy to see the proposal for [Eclipse OpenJ9](http://projects.eclipse.org/proposals/eclipse-openj9) as another main stream open source Java Virtual Machine.  Once that code is available we will take a look with a view to building and testing OpenJDK with Eclipse OpenJ9 binaries too.

As an open build, test and distribution project we aim to be the "go to" location for high quality OpenJDK-based runtimes; and we are working hard to earn that reputation.  If you are maintaining an OpenJDK derived runtime, drop us a note.

There are many interesting and challenging tasks ahead.  Everyone is welcome to participate at whatever level suits you best.  Take a look at some of [the work we know we need to do](https://github.com/AdoptOpenJDK/openjdk-build/issues), or join us on [Slack](https://adoptopenjdk.slackarchive.io/) to talk about your new ideas.

We are grateful to [the sponsors](https://adoptopenjdk.net/sponsors.html) who recognize the value of this project and have generously provided services and resources to make it successful.

The next few months are going to be equally exciting!  Join in.

repository: AdoptOpenJDK/blog

repo_name: AdoptOpenJDK/blog


text:
---
layout: default
title: Noze.io - Evented I/O streams for Swift
tags: nodejs swift server side streams
---

**Noze.io** is an attempt to carry over the
[Node.js](http://nodejs.org/)
ideas into *pure*
[Swift](http://swift.org/).
It uses
[libdispatch](https://github.com/apple/swift-corelibs-libdispatch")
for event-driven, non-blocking I/O.
**Noze.io** is built around type-safe back-pressure aware pull-streams
(using Swift generics)
operating on batches of items. Instead of working with just bytes,
deal with batches of Unicode lines or database records or HTML
responses or - you get the idea.
Be efficient: Stream everything and ßatch.

**Note**: Consider this deprecated. Noze.io works on top of GCD and is overall really inefficient and slow for various reasons. [Macro.swift](https://github.com/Macro-swift) is an effort the eventually rewrite it on top of SwiftNIO.

A focus is to keep the API similar to Node. Not always possible -
Swift is not JavaScript - but pretty close.
It comes with rechargeables included, Noze.io is self-contained and
doesn't require any extra dependencies.
No extra C modules, pure Swift.

Haz awezome modules such as:
[cows](https://github.com/NozeIO/Noze.io/tree/master/Sources/cows),
[leftpad](https://github.com/NozeIO/Noze.io/tree/master/Sources/leftpad),
[express](https://github.com/NozeIO/Noze.io/tree/master/Sources/express), and
[redis](https://github.com/NozeIO/Noze.io/tree/master/Sources/redis).

**Noze.io** works in Cocoa environments as well as on Linux.
It uses Swift 3 or 4 on macOS or tuxOS.
Head over to our [Start](http://noze.io/start/) page
for install instructions.

*Is it a good idea?* You [tell us](/about/).
Not sure, but we think it might be,
because:
*a)*
While Swift looks like JavaScript, it is actually a very
high performance, statically typed and AOT-compiled language,
*b)*
Code often looks better in Swift, mostly due to the trailing-closure syntax,
*c)*
No monkey patching while still providing extensions.
~~There are cons too.~~

#### Shows us some code!

There is a reasonably large collection of simple, focused:
[Noze.io examples](https://github.com/NozeIO/Noze.io/tree/master/Samples).
But here you go, the "standard" Node example, a
HelloWorld httpd:

```swift
import http

http.createServer { req, res in
  res.writeHead(200, [ "Content-Type": "text/html" ])
  res.end("<h1>Hello World</h1>")
}
.listen(1337)
```

An echo daemon, just piping the in-end of a socket into its own out-end:

```swift
import net

net.createServer { sock in
  sock.write("Welcome to Noze.io!\r\n")
  sock | sock
}
.listen(1337)
```

More complex stuff including a
[Todo-MVC backend](https://github.com/NozeIO/Noze.io/blob/master/Samples/todo-mvc-redis/main.swift)
can be found in the
[Noze.io examples](https://github.com/NozeIO/Noze.io/tree/master/Samples).
Like what you see? Head over to our
[Start page](/start/)
to get started.

  {% for post in site.posts %}

{{ post.title }}

        {{ post.excerpt }}

            {{ post.date | date: "%B %e, %Y" }}
            Read More

  {% endfor %}


text:
## Spacelapser

![Example of Spacelapser being used.](docs/images/gui.gif)

Spacelapser is a tool for exploring the three-dimensional volumes created by loading an entire video into memory. Depending on the motion of the camera, this volume can resemble a lightfield, a slit-scan camera, or a special relativity simulator.

![Example of Spacelapser output.](docs/images/vertical_motion.gif)

![Example of Spacelapser output.](docs/images/ocean.gif)

### Installation

The project was built in OpenFrameworks and should be cross-platform. It is tested built with Xcode on OS X.

repository: fitzgen/spacelapser

repo_name: fitzgen/spacelapser


text:
# rsx
idea: how would first-hand support for reactive programming in JS look like?

## Proposed Rules

  RSX Code
  JS Equivalent

```jsx
const x@ = 2
```

```jsx
const x = new BehaviorSubject(2)
```

```jsx
const a = @b + @c * 2
```

```jsx
const a = computed(() => $(b) + $(c) * 2)

```

repository: loreanvictor/rsx

repo_name: loreanvictor/rsx


text:
---
templateKey: blog-post
title: My ___logical Family
date: 2018-10-12T19:04:00.000Z
description: >-
  The idealistic perception that your relationships will be better in the future
  is just plain wrong. Here is my story about how my biological family stopped
  talking to me.
tags:
  - family
  - relationships
  - conflict
---

![family](/img/family.png)

## The Beginning

I grew up in a relatively small New England seacoast town. I played hockey, was on a swim team, and eventually went to private boarding school. My family was tight-knit. I recall frequently hearing my mother say, "Levesque's root for Levesque's," as she coached my sister and me on how to overcome life's challenges.

During my teenage years, I often felt frustrated that despite my hard work and full attention, I was always in someone else's shadow. At first it was my Father because he seemed to have all the answers; He was wise and calculated. Many of my curiosities were myth-busted by him. I felt inadequate and behind in "getting it."

Then it was my sister.

repository: DarinLevesque/DL-cms

repo_name: DarinLevesque/DL-cms


text:
# Lovelace - graph-chartjs-card

## Date Format

And here are the named masks provided by default (you can easily change these or add your own):

| Name           | Mask                         | Example                  |
| :------------- | :--------------------------- | :----------------------- |
| default        | ddd mmm dd yyyy HH:MM:ss     | Sat Jun 09 2021 17:46:21 |
| shortDate      | m/d/yy                       | 6/9/07                   |
| mediumDate     | mmm d, yyyy                  | Jun 9, 2021              |
| longDate       | mmmm d, yyyy                 | June 9, 2021             |
| fullDate       | dddd, mmmm d, yyyy           | Saturday, June 9, 2021   |
| shortTime      | h:MM TT                      | 5:46 PM                  |
| mediumTime     | h:MM:ss TT                   | 5:46:21 PM               |
| longTime       | h:MM:ss TT Z                 | 5:46:21 PM EST           |
| isoDate        | yyyy-mm-dd                   | 2021-06-09               |
| isoTime        | HH:MM:ss                     | 17:46:21                 |
| isoDateTime    | yyyy-mm-dd'T'HH:MM:ss        | 2021-06-09T17:46:21      |
| week           | W                            | 17                       |
| quater         | Q                            | Q1/2021                  |
| second         | HH:mm:ss l                   | 2021-06-09T22:46:21Z     |
| minute         | HH:mm l                      | 2021-06-09T22:46:21Z     |
| hour           | HH:mm                        | 2021-06-09T22:46:21Z     |
| day            | ddd, d.mmm                   | 2021-06-09T22:46:21Z     |
| month          | mmm yyyy                     | 2021-06-09T22:46:21Z     |
| year           | yyyy                         | 2021-06-09T22:46:21Z     |

Following are the special characters supported.

| Mask             | Description                                                  |
| :--------------- | :----------------------------------------------------------- |
| `d`              | Day of the month as digits; no leading zero for single-digit days. |
| `dd`             | Day of the month as digits; leading zero for single-digit days. |
| `ddd`            | Day of the week as a three-letter abbreviation.              |
| `dddd`           | Day of the week as its full name.                            |
| `m`              | Month as digits; no leading zero for single-digit months.    |
| `mm`             | Month as digits; leading zero for single-digit months.       |
| `mmm`            | Month as a three-letter abbreviation.                        |
| `mmmm`           | Month as its full name.                                      |
| `yy`             | Year as last two digits; leading zero for years less than 10. |
| `yyyy`           | Year represented by four digits.                             |
| `h`              | Hours; no leading zero for single-digit hours (12-hour clock). |
| `hh`             | Hours; leading zero for single-digit hours (12-hour clock).  |
| `H`              | Hours; no leading zero for single-digit hours (24-hour clock). |
| `HH`             | Hours; leading zero for single-digit hours (24-hour clock).  |
| `M`              | Minutes; no leading zero for single-digit minutes. Uppercase M unlike CF `timeFormat`'s m to avoid conflict with months. |
| `MM`             | Minutes; leading zero for single-digit minutes. Uppercase MM unlike CF `timeFormat`'s mm to avoid conflict with months. |
| `s`              | Seconds; no leading zero for single-digit seconds.           |
| `ss`             | Seconds; leading zero for single-digit seconds.              |
| `l` *or* `L`     | Milliseconds. `l` gives 3 digits. `L` gives 2 digits.        |
| `t`              | Lowercase, single-character time marker string: *a* or *p*. No equivalent in CF. |
| `tt`             | Lowercase, two-character time marker string: *am* or *pm*. No equivalent in CF. |
| `T`              | Uppercase, single-character time marker string: *A* or *P*. Uppercase T unlike CF's t to allow for user-specified casing. |
| `TT`             | Uppercase, two-character time marker string: *AM* or *PM*. Uppercase TT unlike CF's tt to allow for user-specified casing. |
| `Z`              | US timezone abbreviation, e.g. *EST* or *MDT*. With non-US timezones or in the Opera browser, the GMT/UTC offset is returned, e.g. *GMT-0500* No equivalent in CF. |
| `o`              | GMT/UTC timezone offset, e.g. *-0500* or *+0230*. No equivalent in CF. |
| `S`              | The date's ordinal suffix (*st*, *nd*, *rd*, or *th*). Works well with `d`. No equivalent in CF. |
| `'…'` *or* `"…"` | Literal character sequence. Surrounding quotes are removed. No equivalent in CF. |
| `UTC:`           | Must be the first four characters of the mask. Converts the date from local time to UTC/GMT/Zulu time before applying the mask. The "UTC:" prefix is removed. No equivalent in CF. |
| `W`              | Returns the week number within the year that corresponds to the specified date. |
| `Q`              | A calendar quarter is a period of three consecutive months, and there are four quarters per calendar year. |

repository: MadeinTaly/lovelace-graph-chart-card

repo_name: MadeinTaly/lovelace-graph-chart-card


text:
## ZEPIO IS NO LONGER ACTIVELY MAINTAINED
*We will be archiving this repo soon. If you would like a shielded-first desktop wallet, we recommend [ZecWallet](https://www.zecwallet.co/).*

Zepio is a Sapling-enabled shielded-address-first Zcash wallet, featuring cross-platform applications (macOS, Windows and Linux), built-in full node with support for `mainnet` and `testnet`, as well as `dark` and `light` themes.

![Build Status](https://app.bitrise.io/app/a5bc7a8391d5501b/status.svg?token=SOuGNc3Qf9rCj3Osl-eHyQ&branch=master)
![Flow Coverage](./public/flow-coverage-badge.svg)

### [Latest Documentation](https://zepiowallet.com)

### [Latest Release](https://github.com/ZcashFoundation/zepio/releases)

![Zepio Wallet](https://raw.githubusercontent.com/ZcashFoundation/zepio-docs/develop/docz/assets/dashboard.png)

## Stack Information

List of the main open source libraries and technologies used in building **Zepio**:

- [zcashd](https://github.com/zcash/zcash): Zcash node daemon
- [Electron](https://github.com/electron/electron): Desktop application builder
- [React](https://facebook.github.io/react/): User interface view layer
- [Redux](https://redux.js.org/): Predictable application state container
- [Styled Components](https://www.styled-components.com/): Visual primitives for theming and styling applications
- [webpack](https://webpack.github.io/): Application module bundler (and more)
- [Babel](https://babeljs.io/): ES7/JSX transpilling
- [ESLint](https://eslint.org/): Code linting rules
- [Flow](https://flow.org): JavaScript static type checker
- [Docz](https://docz.site): Documentation builder
- [BigNumber.js](https://github.com/MikeMcl/bignumber.js#readme): Arbitrary-precision decimal and non-decimal arithmetic with safety

## Installing and Running From Source

To run **Zepio** from source you'll need to perform the following steps:
```bash
# Ensure you have Node LTS v8+
# https://nodejs.org/en/

# Clone Codebase
git clone git@github.com:ZcashFoundation/zepio.git

# Install Dependencies
# inside of the `zepio` folder
yarn install
# or
npm install

# Start Application
# webpack development server hosts the application on port
# 8080 and launches the Electron wrapper, which also hosts
# the `zcashd` node daemon process.
yarn start
# or
npm start
```

## Building Application Locally

To build the application locally follow the instructions below:
```bash
# Make sure you are inside of the main `zepio` folder

# Run Build Script
yarn electron:distall

# Executables and binaries available under `/dist` folder
```

## Flow Coverage (Static Type Checker)

For a deeper look on the static typing coverage of the application, please follow below:
```bash
# Make sure you are inside of the main `zepio` folder

# Generate Flow Coverage Report
# this can take a couple seconds
yarn flow:report

# Browser should open with the file `index.html` opened
# Files are also available at `zepio/flow-coverage/source`
```

## Component Library (Docz)

To see Zepio's React component library, please visit https://zepio-components.now.sh. We're always looking for folks to help keep the styleguide updated.

To run the component library locally, run the following:
```bash
# Make sure you are inside of the main `zepio` folder

# Run Docz Development Script
yarn docz:dev

# Visit http://<IP_ADDRESS>:4000/
```

To build the component library locally, run the following:
```bash
# Make sure you are inside of the main `zepio` folder

# Run Build Script
yarn docz:build

# Check `/.docz/dist` folder for built static assets
```

## Tests

To run the application's tests, please run the below:
```bash
# Make sure you are inside of the main `zepio` folder

# For Unit Tests: Run Jest Unit Test Suite
yarn test:unit

# For E2E (end-to-end) Tests: Run Jest E2E Suite
yarn e2e:serve
# on another terminal window
yarn test e2e
```

## Contributing

In order to contribute and submit PRs to improve the **Zepio** codebase, please check our [CONTRIBUTING](https://github.com/ZcashFoundation/zepio/blob/master/CONTRIBUTING.md) guide.

## License

MIT © Zcash Foundation 2019 [zfnd.org](https://zfnd.org)

repository: ZcashFoundation/zepio

repo_name: ZcashFoundation/zepio


text:
OpenID-Connect-Authenticator
----------------------------

OpenID Connect authenticator for Agresso Business World Milestone 3 and later.

### Disclaimer

This authenticator is used at own risk. UNIT4 is not responsible for any damages caused by using
this authenticator.

### Build

Requires these Agresso-libraries.

* ACT.dll
* Agresso.Base.dll
* Agresso.Interface.Authentication.dll
* Agresso.Interface.CoreServices.dll

The project is created with Visual Studio 2012.

### Install

* Newtonsoft.Json.dll must be copied to binary folder
* Appsettings from app.config must be put into web.config
* Install with TAG107
* Set as default autenticator with TAG106

### Map users

The mapping will match users by looking for the OpenID email in the "Domain user" (User master file / TAG064 -> Security -> Single sign-on -> Domain user) field. The default client must be set.

### Limitations

* JWT Token signature is not verified. HTTPS is required.

### Google setup

Follow instructions to [setup client](https://developers.google.com/accounts/docs/OAuth2Login?hl=no#appsetup)

### Further work

* When the OpenID Connect identity is not mapped to an Agresso user, there could be a feature that allows users to link accounts by entering Agresso credentials. This "Login-with-Agresso-user-to-link-accounts"-diaglog will only be displayed once per user to establish mapping between accounts.

### Troubleshoot

#### System will not load authenticator. Failed security check.

This error message is displayed because the system fails to compare the equality of assembly checksum of the executed assembly and the assembly checksum calculated when the authenticator was installed (TAG107).

##### Solution during development

Enter AG23 - Common parameters and locate the parameter VERIFY_AUTH_CHECKSUM. Turn it off. Then you won't have to update the checksum each time the authenticator is built (next solution).

##### Solution in production

Enter TAG107 - Authenticators and check the authenticator and click "Update Checksum".

**Note**: Caches might have to be cleared in both cases!

### License

Copyright (c) 2014-2015 UNIT4

Released under the MIT license


text:
# Ping-Pong: Week Three - JavaScript Arrays and Looping Independent Project

[Home] (../index.html)
[Ping Pong] (../ping-pong.html)

# _Ping-Pong: Week Three - JavaScript Arrays and Looping Independent Projects_

#### _Ping Pong, June 10, 2016 _

#### By _**Noah Yasskin**_

## Specifications (Specs)

Behavior                                                          | Input  | Output
----------------------------------------------------------------- | ------ | ------
It can count up to the number provided by the user | 2 | [1, 2]
It can create an array of all the numbers from one to any number a user inputs | 2001 | [1,2, 3 ... 2001]
It can output all of the numbers up to and including the number provided by the user | 5 | [1, 2, 3, 4, 5]
It can output all the array of numbers as a list | 5 | [in a list: 1, 2, 3, 4, 5]
It can output "ping", "pong", and "ping-pong" along with the numbers | 3 | [1, 2, 3, ping, pong, ping-pong]
3 is replaced with "ping", 5 with "pong", and 15 with "ping-pong" | 3, 5, 15 | ["ping", "pong", "ping pong"]
All numbers divisible by 3 are replaced with "ping" | [3, 6, 9] | ["ping", "ping", "ping"]
All numbers divisible by 5 are replaced with "pong" | [5, 10, 100] | ["pong", "pong", "pong"]
All numbers divisible by 15 are replaced with "pingpong" | [15, 30] | ["pingpong", "pingpong"]
A user enters a new number and sees new results over and over again | [3, 4] | [(1, 2, "ping"), (1, 2, "ping", 4)]

## Objectives
*JavaScript business logic and user interface logic are separate.
*Variable names are descriptive and use lower camel case (e.g. myVariableExample).
*Code has proper indentation and spacing.
*All previous objectives have been met.

## Setup/Installation Requirements

* _The Ping-Pong application runs in most web browsers that support JavaScript_

## Known Bugs

_No known issues to resolve_

## Support and contact details

_If you run into any issues or have questions, ideas or concerns, I encourage you to contact me on GitHub or make a contribution to the code._

## Technologies Used

_HTML and CSS._
_JavaScript and jQuery_
_Google Fonts_

### License

*The MIT License (MIT)

Copyright © 2016 Noah Yasskin

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

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

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

Copyright (c) 2016 **_Epicodus Student Project by Noah Yasskin_**

repository: yasskin/ping-pong

repo_name: yasskin/ping-pong


text:
# [State Farm Distracted Driver Detection](https://www.kaggle.com/c/state-farm-distracted-driver-detection)
I took on project after the deadline of the competition, while due to this project highly related to my other side project ([SODA](http://soda.datashanghai.gov.cn/?lang=en)), I decided to explore the data by myself. Using pretrained [ResNet-50](https://github.com/KaimingHe/deep-residual-networks) provided by [Keras](https://github.com/fchollet/keras/) (personally favorite high level framework for Deep Learning), I got good performance on both validation set and test set.

Since I didn't use stack trick so far (the competition has already ended up, why I need to take so much time on tuning = ,= ), there is still large room to improve, even for the boosting trees model. And considering it's possible to include the driver information in NN models (like embedding), this can also be used to make progress.

# How-To
To run the code, download and unzip the data from Kaggle in "data" folder.

Install Keras (network part) and Graphlab Create (boosting tree part).

The other packages are all included in Anaconda.

# Methodology
|=> Resize the images to 224 x 224 (like the images from ImageNet)

|=> High level features from pretrained CNN (ResNet-50)

|=> Boosting trees to classify.

I tried VGG-16 and ResNet-50 for extracting features, and finally I used ResNet-50, cause it's really really faster when classification. I took the last layer features (i.e. after average pooling), and flatten, which gives 2048 features.

Then I connected the features to a boosting tree model, for 10-class classification.

# Why I didn't use VGG-16
VGG-16 has 3-layer full connected network by the end, so it's not really safe to use the last layer features. I use the features after its last block conv layer, which is 7 x 7 x 512 features. There may be much more possibilities to explore these intermediate featres, while due to my computation limit, I didn't explore too much.

# Time
I used AWS g2.2xlarge to extract the features.

For VGG-16, it took about 0.08s per image. And For ResNet-50,  it tooks about 0.09s per image.

To train on the extracted features, VGG features has 25088 dimensions (sparse), while ResNet has only 2048 features (after average pooling).

I used [Graphlab Create](https://turi.com/) to train boosting tree models locally (on my Surface Book), where on VGG features, it took ~88s to train a 3-depth tree, while on ResNet features it took only ~1.1s per tree. Note Graphlab Create is a commercial software, but you can register for academic use of GraphLab Create for free.

# Tips for feature extraction
You'd better extract the feature once, rather than keep it not trainable in the layers, if you are not trying to keep the feature extraction layer in the middle. The reason is quiet simple, just because for this scale network, it really takes long time for forward prop, you should not let your network do it every time.

Well, with Keras, it's really easy to keep it in your network, but in this case, you should not do that.

# Tools
The package resnet50 is a simple refactor version from Keras [deep-learning-models](https://github.com/fchollet/deep-learning-models/), just remove some data downloads modules. If you want to use it, you should install Keras (1.0.7) from GitHub, not from PyPi.

Graphlab Create uses Xgboost for its boosting tree backend base, so you can also use Xgboost to get same performance. I don't recommend you to use scikit-learn in this case, although I'm really a big fun, it will take really much more time.

# License
MIT

repository: duducheng/Kaggle

gha_language: Jupyter Notebook

repo_name: duducheng/Kaggle


text:
#### olico-match module

cd into the `olico-match` directory and execute all the npm scripts from there

There are minimal unit and e2e test to build upon. To run e2e is required to have access to a mongodb instance locally or remotely. There many ways to do that, from docker to hosted service or even a local instance.

There some configuration to run with MongoDB Cloud if you have access there. More info about that could be found at `test/e2e/mongolab.js` and `test/e2e/index.js` for now.

to run unit
```
npm run test
```

to run local e2e you need a mongod binary on your path. There are two sessions needed, one for the database server and one to run the tests

on first terminal
```
npm run build
npm run clean
npm run mongoup
```

and on the second terminal

```
npm run test:e2e
```

to run remote e2e with mongolab you will need to have setup access and have the required details to export as environment variables before start the test

```
export MONGOLAB_CLUSTER_HASH="cluster0-abcde"
export MONGOLAB_PASSWD="XXXXXXXXXXXXXXsk"
export MONGOLAB_TEST="y"
export MONGOLAB_USER="readwriteusername"

npm run test:e2e
```

For now just creates an olico match document with fake children \_ids.

This is linux specific and probably will not run on other environments as is.

repository: crowdhackathon-agrifood/olico

repo_name: crowdhackathon-agrifood/olico


text:
# PN1010

<PageHeader />

## Description

If a dictionary's justification is changed jQL still tries to use the index when it shouldn't.

## Previous Release Behavior
```SELECT filename WITH indexed_dict >= "val1 AND <= "val2"``` would use the index created on indexed_dict even if the dictionary's justification was changed post index creation.

## Current Release Behavior

Indexes are only used if the original sort justification matches the dictionary (except in some cases "=" is allowed).

Back to [5.7.10 Release Notes](./../README.md)

<PageFooter />

repository: patpog/docs

repo_name: patpog/docs


text:
# Contribute to `scaleway-cli`

`scaleway-cli` is Apache 2.0 licensed and accepts contributions via GitHub.
This document will cover how to contribute to the project and report issues.

## Topics

- [Reporting Security Issues](#reporting-security-issues)
- [Reporting Issues](#reporting-issues)
- [Suggesting feature](#suggesting-feature)
- [Contributing Code](#contributing-code)
- [Community Guidelines](#community-guidelines)

## Reporting security issues

Please refer to our [security policy](../SECURITY.md).

## Reporting issues

A great way to contribute to the project is to send a detailed report when you encounter a bug.
We always appreciate a well-written, thorough bug report, and will thank you for it!
Before opening a new issue, we appreciate you reviewing open issues to see if there are any similar requests.
If there is a match, thumbs up the issue with a 👍 and leave a comment if you have additional information.

When reporting an issue, please include information displayed by the `scw version` command.

## Suggesting a feature

When requesting a feature, some of the questions we want to answer are:

- What value does this feature bring to end users?
- How urgent is the need (nice to have feature or need to have)?
- Does this align with the goals of `scaleway-cli`?

## Contributing code

Before contributing to the code, make sure you have read about the [continuous code deployment](docs/CONTINUOUS_CODE_DEPLOYMENT.md) process we are using on this repo.

### Submit code

To submit code:

- Create a fork of the project
- Create a topic branch from where you want to base your work (usually master)
- Add tests to cover contributed code
- Push your commit(s) to your topic branch on your fork
- Open a pull request against `scaleway-cli` `master` branch that follows [PR guidelines](#pull-request-guidelines)

The [maintainers](MAINTAINERS.md) of `scaleway-cli` use a "Let's Get This Merged" (LGTM) message in the pull request to note that the commits are ready to merge.
After one or more maintainer states LGTM, we will merge.
If you have questions or comments on your code, feel free to correct these in your branch through new commits.

### Pull Request Guidelines

The goal of the following guidelines is to have Pull Requests (PRs) that are fairly easy to review and comprehend, and code that is easy to maintain in the future.

- **Pull Request title should respect [conventional commits](https://www.conventionalcommits.org/en/v1.0.0) specifications** and be clear on what is being changed.
  The scope is the namespace on which the changes are made or `core` for changes which concern the whole CLI. Examples:
    - A fix for `scw init` will be titled `fix(init): ...`
    - A fix for the argument parser will be titled `fix(core): ...`
    - A new instance feature (in `scw instance ...`) will be title `feat(instance): ...`
- **Keep it readable for human reviewers** and prefer a subset of functionality (code) with tests and documentation over delivering them separately
- **Don't forget commenting code** to help reviewers understand and to keep [our Go Report Card](https://goreportcard.com/report/github.com/scaleway/scaleway-sdk-go) at A+
- **Notify Work In Progress PRs** by prefixing the title with `[WIP]`
- **Please, keep us updated.**
  We will try our best to merge your PR, but please notice that PRs may be closed after 30 days of inactivity.

Your pull request should be rebased against the `master` branch.

Keep in mind only the **pull request title** will be used as commit message as we stash all commits on merge.

## Community guidelines

See [CODE_OF_CONDUCT.md](CODE_OF_CONDUCT.md).

Thank you for reading through all of this, if you have any question feel free to [reach us](README.md#reach-us)!

## Developer documentation

### When to use dash vs underscore

We SHOULD use dash `"-"` for:
- command namespaces, resource, verb
- argument names
- key names in the human formatted results
- UUID

We SHOULD use underscore `"_"` for:
- response value results, except UUID
- argument values

Example:
```bash
> scw my-namespace my-resource get id=xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
id               xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
some-key         some_value
other-key        other_value
```

### Commands validation

Some validation is done internally on Scaleway's side: see [scaleway-sdk-go/docs/CONTINUOUS_CODE_DEPLOYMENT.md](https://github.com/scaleway/scaleway-sdk-go/blob/master/docs/CONTINUOUS_CODE_DEPLOYMENT.md)
This is true for:
- command namespaces, resource, verb

The rest is manually checked for now.

repository: scaleway/scaleway-cli

repo_name: scaleway/scaleway-cli


text:
### [CVE-2016-6225](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2016-6225)
![](https://img.shields.io/static/v1?label=Product&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Version&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Vulnerability&message=n%2Fa&color=brighgreen)

### Description

xbcrypt in Percona XtraBackup before 2.3.6 and 2.4.x before 2.4.5 does not properly set the initialization vector (IV) for encryption, which makes it easier for context-dependent attackers to obtain sensitive information from encrypted backup files via a Chosen-Plaintext attack. NOTE: this vulnerability exists because of an incomplete fix for CVE-2013-6394.

### POC

#### Reference
- https://www.percona.com/blog/2017/01/12/cve-2016-6225-percona-xtrabackup-encryption-iv-not-set-properly/

#### Github
No PoCs found on GitHub currently.

repository: trickest/cve

repo_name: trickest/cve


text:
`project.json`:

```json
{
  "name": "mobile",
  //...
  "targets": {
    //...
    "build-android": {
      "executor": "@nx/react-native:build-android",
      "outputs": [
        "{projectRoot}/build/outputs/bundle",
        "{projectRoot}/build/outputs/apk"
      ],
      "options": {}
    }
  }
}
```

```bash
nx run mobile:build-android
```

## Examples

{% tabs %}
{% tab label="Build with custom tasks" %}
The `tasks` option accepts any custom gradle task, such as `assembleDebug`, `assembleRelease`, `bundleDebug`, `bundleRelease`, `installDebug`, `installRelease`.
For example, pass in `bundleRelease` or `bundleRelease` to tasks, it will create with `.aab` extension under bundle folder.
Pass in `assembleDebug` or `assembleRelease` to tasks, it will create a build with `.apk` extension under apk folder.
Pass in `installDebug` or `installRelease` to tasks, it will create a build with `.apk` extension and immediately install it on a running emulator or connected device.

```json
    "build-android": {
      "executor": "@nx/react-native:build-android",
      "outputs": [
        "{projectRoot}/build/outputs/bundle",
        "{projectRoot}/build/outputs/apk"
      ],
      "options": {
        "tasks": ["bundleRelease"]
      }
    }
```

{% /tab %}
{% tab label="Build for debug/release" %}

The `mode` option allows you determine whether to build for debug/release apk.

```json
    "build-android": {
      "executor": "@nx/react-native:build-android",
      "outputs": [
        "{projectRoot}/build/outputs/bundle",
        "{projectRoot}/build/outputs/apk"
      ],
      "options": {
        "mode": "debug"
      }
    }
```

{% /tab %}
{% tab label="Build for current device architecture" %}

The `activeArchOnly` option allows you to build native libraries only for the current device architecture for debug builds.

```json
    "build-android": {
      "executor": "@nx/react-native:build-android",
      "outputs": [
        "{projectRoot}/build/outputs/bundle",
        "{projectRoot}/build/outputs/apk"
      ],
      "options": {
        "activeArchOnly": true
      }
    }
```

{% /tab %}
{% /tabs %}

---

repository: nrwl/nx

gha_language: TypeScript

repo_name: nrwl/nx


text:
# Installation
> `npm install --save @types/fullpage.js`

# Summary
This package contains type definitions for fullpage.js (http://alvarotrigo.com/fullPage/).

# Details
Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/fullpage.js.

### Additional Details
 * Last updated: Tue, 16 Jun 2020 09:55:54 GMT
 * Dependencies: [@types/jquery](https://npmjs.com/package/@types/jquery)
 * Global values: none

# Credits
These definitions were written by [Andrew Roberts](http://www.atroberts.org), and [Jodi Warren](https://github.com/jodiwarren).

repository: virgildima/YMP

repo_name: virgildima/YMP


text:
# Navigation Router
[![Release](https://jitpack.io/v/foxaice/NavigationRouter.svg)](https://jitpack.io/#foxaice/NavigationRouter)

```Navigation Router``` was created for easy life with android fragments

## Integration
>Step 1. Add the JitPack repository to your build file
```groovy
	allprojects {
		repositories {
			...
			maven { url 'https://jitpack.io' }
		}
	}
```
>Step 2. Add the dependency
```groovy
	dependencies {
	        compile 'com.github.foxaice:NavigationRouter:v0.1.8-alpha'
	}
```
## How to Use
### Initialization
>```Navigation Router``` is initialized by **constructor**
```java
 public NavigationRouter(AppCompatActivity activity, int containerId)
```
If ```activity``` implements [```OnChangeScreenListener```] then the method  [```onScreenChanged(@Nullable Fragment fragment)```] will return the current fragment for any change in the state of the screens stack

```containerId``` - the container of the screens ([```FrameLayout```])

### Addable fragments
>To add a fragment to the top of the other, add marker-interface [```Addable```] for this fragment
And when you open the screen by
```java
NavigationRouter.openScreen(Fragment);
```
>```NavigationRouter``` uses within itself:
```java
 FragmentManager.beginTransaction().add(containerId,fragment,fragmentTag).commit();
```

### Replaceable fragments
>To add a fragment to replace all the content in the container, add marker-interface [```Replaceable```] for this fragment
And when you open the screen by
```java
NavigationRouter.openScreen(Fragment);
```
>```NavigationRouter``` uses within itself:
```java
 FragmentManager.beginTransaction().replace(containerId,fragment,fragmentTag).commit();
```

### Opening of Screens
>Opens the screen by fragment and added that fragment to the stack
```java
public void openScreen(Fragment fragment)
```
```fragment``` - the screen that you want to open

### Closing of Current Screen
>Removes current screen from the stack of screens
```java
public void closeCurrentScreen()
```

### Closing of Screens to a Specific Screen
>Removes all screens until the screen by the position inclusive or exclusive from the stack of screens
```java
public void closeToScreen(int position, boolean includePosition)
```
```position``` - the position of the screen
```includePosition``` - if **true** ```Navigation Router```removes all screens include the screen by the position, otherwise removes without it

### Closing of All Screens
>Removes all screen inclusive from the stack of screens
```java
 public void closeAllScreens()
```

### Getting the Current Screen
>Returns the current fragment of the fragments container
```java
public Fragment getCurrentScreen()
```

### Getting the Screen Quantity
>Returns current quantity of screens
```java
public int getScreenCount()
```

[//]: # ()

   [```Addable```]:<https://github.com/foxaice/NavigationRouter/blob/v0.1-alpha/navigation-router/src/main/java/com/sequenia/navigation_router/NavigationRouter.java#L17-L23>
   [```Replaceable```]:<https://github.com/foxaice/NavigationRouter/blob/v0.1-alpha/navigation-router/src/main/java/com/sequenia/navigation_router/NavigationRouter.java#L25-L31>
   [```NavigationRouterActivity```]:<https://github.com/foxaice/NavigationRouter/blob/v0.1-alpha/navigation-router/src/main/java/com/sequenia/navigation_router/NavigationRouterActivity.java>
   [```OnChangeScreenListener```]:<https://github.com/foxaice/NavigationRouter/blob/v0.1-alpha/navigation-router/src/main/java/com/sequenia/navigation_router/OnChangeScreenListener.java>
   [```onScreenChanged(@Nullable Fragment fragment)```]:<https://github.com/foxaice/NavigationRouter/blob/4b431287834f2e40a31c85fcdcc5997e29bddbfd/navigation-router/src/main/java/com/sequenia/navigation_router/OnChangeScreenListener.java#L10-L15>
   [```FrameLayout```]:<https://developer.android.com/reference/android/widget/FrameLayout.html>

repository: sequenia/NavigationRouter

repo_name: sequenia/NavigationRouter


text:
# Dynamically create a .NET app domain on Azure Web App

This simple sample demonstrates how to dynamically create a .NET app domain in an Azure Web App and run code in the newly created app domain.

To see how it works, deploy the app, and go to <your web root>/swagger.  There are two REST APIs you can try:
* Get - displays the list of current app domains
* Post - type in a string in the body, for example, "=mynewappdomain", set the content type to "application/x-www-form-urlencoded". This will create a new app domain, which you can verify by running the GET API again
* The code in the new app domain simply overwrites <your web root>/somehtml.html with a message "Hello <the name of the new app domain>".

repository: liupeirong/Azure

gha_language: C#

repo_name: liupeirong/Azure


text:
## Microsoft Azure Linux Agent Maintenance Guide

### Version rules

  * Production releases are public
  * Test releases are for internal use
  * Production versions use only [major].[minor].[revision]
  * Test versions use [major].[minor].[revision].[build]
  * Test a.b.c.0 is equivalent to Prod a.b.c
  * Publishing to Production requires incrementing the revision and dropping the build number
  * We do not use pre-release labels on any builds

repository: luthes/WALinuxAgent

repo_name: luthes/WALinuxAgent


text:
# GitUpdate
A one-click program to fetch from and push to all your Git repositories.

When branches are fetched, Git Update attempts to fast-forward your local branches to their specified remote branch. If any merge (automatic or manual) is required, it will not modify that branch. It will also attempt to fast-forward it to a version from a remote named `upstream`, if it exists. To prevent your current branch from being changed, check out a commit or a tag.

Branches are only pushed if they have a configured remote.

Note: This program assumes that all your Git repositories are in `{user.home}/git/`.

repository: JBYoshi/GitUpdate

repo_name: JBYoshi/GitUpdate