text:
# AREA 51 RAID SQUAD

### To start locally

1) Clone the repo
2) cd into the repo
3) ```npm install```
4) ```npm start```
5) Open your browser to http://localhost:3000

### To run in a docker container and tag

1) ```docker-compose up -d --build```
2) Open your browser to http://localhost:3001

### Parse.js

In terminal
    ``` node parse.js```

parsed both files into new files


text:
# PSO Operator

## Overview
PSO Operator is now  the preferred install method for PSO on OpenShift 3.11 and higher versions.
The PSO Operator packages and deploys the Pure Service Orchestrator (PSO) on OpenShift for dynamic provisioning of persistent volumes on FlashArrays and FlashBlades. The minimum supported version is OpenShift 3.11.
This Operator is created as a [Custom Resource Definition](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/#customresourcedefinitions) from the [pure-k8s-plugin Helm chart](https://github.com/purestorage/helm-charts#purestorage-helm-charts-and-helm-operator) using the [Operator-SDK](https://github.com/operator-framework/operator-sdk#overview).
This installation process does not require Helm installation.

## Prerequisites
* OpenShift (3.11+) or Kubernetes (1.11+) cluster installed and running
* Access to a user account that has cluster-admin privileges

## Installation

A single install script sets up the PSO-operator.

```install.sh --image=<image> --namespace=<namespace> --orchestrator=<ochestrator> -f <values.yaml>```

Parameter list:

1. ``image`` is the PSO Operator image. If unspecified ``image`` resolves to the released version at [quay.io/purestorage/pso-operator](https://quay.io/purestorage/pso-operator).
2. ``namespace`` is the namespace/project in which the PSO-operator and its entities will be installed. If unspecified, the operator creates and installs in  the ``pso-operator`` namespace.
**PSO Operator MUST be installed in a new project with no other pods. Otherwise an uninstall may delete pods that are not related to the PSO operator.**
3. ``orchestrator`` should be either ``k8s`` or ``openshift`` depending on which orchestrator is being used. If unspecified, ``openshift`` is assumed.
4. ``values.yaml`` is the customized helm-chart configuration parameters. This is a **required parameter** and must contain the list of all backend FlashArrays and FlashBlades. All parameters that need a non-default value must be specified in this file.
Refer to [Configuration for values.yaml.](../pure-k8s-plugin/README.md#configuration)

### Install script steps:
The install script will do the following:
1. Create New Project

The script creates a new project (if it does not already exist) with the given namespace. If no namespace parameter is specified, the ``pso-operator`` namespace is used.

**OpenShift Note**: In OpenShift 3.11, the default node-selector for a project does not allow PSO Operator to mount volumes on master and infra nodes.
If you want to mount volumes on master and infra nodes OR run pods in the default namespace using volumes mounted by PSO, then modify the install script as follows.

```
Existing line:     $KUBECTL adm new-project ${NAMESPACE}

Change to allow volume mounts on master and infra nodes:     $KUBECTL adm new-project ${NAMESPACE} --node-selector=""
```

2. Create a Custom Resource Definition (CRD) for the PSO Operator.

The script waits for the CRD to be published in the cluster. If after 10 seconds the API server has not setup the CRD, the script times out. To wait longer, pass the parameter
``--timeout=<timeout_in_sec>`` to the install script.

3. Create RBAC rules for the Operator.

The PSO Operator needs the following Cluster-level Roles and RoleBindings.

| Resource        | Permissions           | Notes  |
| ------------- |:-------------:| -----:|
| Namespace | Get | PSO Operator needs the ability to get created namespaces |
| Storageclass | Create/Delete | Create and cleanup storage classes to be used for Provisioning |
| ClusterRoleBinding | Create/Delete/Get | PSO Operator needs to create and cleanup a ClusterRoleBinding called ``pure-provisioner-rights`` to the ClusterRole ``system:persistent-volume-provisioner`` for provisioning PVs |

In addition, the operator needs access to multiple resources in the project/namespace that it is deployed in to function correctly. Hence it is recommended to install the PSO-operator in the non-default namespace.

4. Creates a deployment for the Operator.

Finally the script creates and deploys the operator using the customized parameters passed in the ``values.yaml`` file.

## Upgrading

### How to upgrade from helm install to PSO Operator
This upgrade will not impact the in-use volumes/filesystems from data path perspective. However, it will affect the in-flight volume/filesystem management operations. So, it is recommended to stop all the volume/filesystem management operations before doing this upgrade. Otherwise, these operations may need to be retried after the upgrade.
Remove the helm-chart using instructions in https://helm.sh/docs/using_helm/#uninstall-a-release
Once the helm chart has been uninstalled, follow the install instructions [above.](#installation)

### Apply changes in ``values.yaml``
The ``update.sh`` script is used to apply changes from ``values.yaml`` as follows.
```
./update.sh -f values.yaml
```

## Uninstall
To uninstall the PSO Operator, run
```
oc delete all --all -n <pso-operator-installed-namespace>
```
where ``pso-operator-installed-namespace`` is the project/namespace in which the PSO operator is installed. It is **strongly recommended** to install the PSO Operator in a new project and not add any other pods to this project/namespace. Any pods in this project will be cleaned up on an uninstall.

repository: dinathom/helm-charts

branch_name: refs/heads/master

extension: md

gha_language: Shell

license_type: permissive

repo_name: dinathom/helm-charts


text:
Solution

1 - If the pack is less than the minimum element in array return
the firts element of the array;

2 - If the pack is more than the minimum element in array, so we
need to divide the pack with the maximum element less the pack;

3 - The algorithm doing the step 2 until the waste of the divide
is less than 0;

4 - Afther step 3, the resuld should be reduce que result just
with element inside the array.

# Improvement

*** Get better peformance algoritm -> To do the step 3 inside the step 4 - can you refactore for me, pls?! 🤓 ***

# Run Application

`$ go run main.go`

# Test

For run all the unit tests cases in the challenge:

`$ go test`

# Documentation

https://documenter.getpostman.com/view/7723976/TzRXARwF#1cbe209f-be76-4543-b4ce-2cbccd5b9d4f

license: MIT

repository: mirlabraga/gymshark-challenge-golang

branch_name: refs/heads/main

repo_name: mirlabraga/gymshark-challenge-golang


text:
Madsonic Beta Ubuntu docker image
=================================

**Application**

[Madsonic](http://beta.madsonic.org/pages/index.jsp)

**Application description**

Madsonic is a web-based media streamer and jukebox Server.
Based on Java technology, Madsonic runs on most platforms,
including Windows, Mac, Linux, OSX, and Unix variants.

This version contains a patch for madsonic.sh, allowing you to use your own
Java keystore. The patch is applied during image building.

**Build notes**

- Latest beta release of Madsonic.
- [Create a Java keystore](LetsEncryptJKS.md) and put the JKS into your madsonic config folder.
- Extend ```start.sh``` to your needs. Set ```--use-ssl=false``` if you don't want to use my SSL/TLS extension.

**Usage**

```sh
docker run -d \
	-p 4040:4040 \
	-p 4443:4443 \
	--name=<container name> \
	-v <path for media files>:/media \
	-v <path for config files>:/config \
	ubuntu-madsonic-beta
```

Please replace all user variables in the above command defined by <> with the correct values.

repository: mplogas/ubuntu-madsonic-beta

gha_license_id: MIT

repo_name: mplogas/ubuntu-madsonic-beta


text:
# Angular-Training-apps
Basic application set for online training on Angular
#Installation#

Just download and run on local server and enjoy the code

#Why AngularJS?#

HTML is great for declaring static documents, but it falters when we try to use it
for declaring dynamic views in web-applications. AngularJS lets you extend HTML vocabulary
for your application. The resulting environment is extraordinarily expressive, readable, and quick to develop.

#Alternatives#

Other frameworks deal with HTML’s shortcomings by either abstracting away HTML,
CSS, and/or JavaScript or by providing an imperative way for manipulating the DOM.
Neither of these address the root problem that HTML was not designed for dynamic views.

#Extensibility#

AngularJS is a toolset for building the framework most suited to your application development.
It is fully extensible and works well with other libraries.
Every feature can be modified or replaced to suit your unique development workflow and feature needs. Read on to find out how.

repository: tkssharma/Angular-Training-apps

repo_name: tkssharma/Angular-Training-apps


text:
# OctoPnP TeamCity plugin

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

OctoPnP provides "Pack and Publish" functionality for Octopus-based deployments automation.

![Build runner configuration sample](./octo-pnp.png?raw=true)

## Build and test
 1. Open `src` project in IntelliJ Idea.
 2. Issue `mvn package` command from the root project to build the plugin.
 3. Resulting package `octo-pnp.zip` will be placed in `src\target` directory.
 4. To deploy the plugin to locally installed TeamCity run `.\deploy-plugin.cmd` script.

Initial implementation of OctoPnP was inspired by [Octopus-TeamCity](https://github.com/OctopusDeploy/Octopus-TeamCity) project.

repository: skbkontur/OctoPnP

repo_name: skbkontur/OctoPnP


text:
---
title: UFO to UAP
date: "2019-02-03"
description: "From 'flying objects' to 'aerial phenomena': the quest for aliens continues."
---

## Aliens and UFO Ridicule

The **UFO** terminology has been originally [created](../saucer-to-ufo/) as a more serious
way to describe *flying saucers*. Over the following 50 years, however, the new terminology
suffered the same fate and became often used by the genral public and the media to ridicule
the investigation of or even the belief in the extraterrestrial origin of the UFOs.

## Serious People Choose UAP

New terminology to the rescue: unidentified aerial phenomena
([UAP](https://www.scientificamerican.com/article/ufos-uaps-and-craps/)). The exact terminology
has not been settled yet, so **UAP** can be interpreted also as the more
general "unidentified anomalous phenomena". But this is now the preferred terminology when
serious people, from non-ironic government [programs](https://www.politico.com/magazine/story/2017/12/16/pentagon-ufo-search-harry-reid-216111), get involved.

![fighter in tactical uniform](./security.jpg)

After all, someone has to keep the Earth secure from alien invasions.

##### Image Credit

<small>[Protection force](https://unsplash.com/photos/uMFHjRDglGs) photo by [Fábio José Lima](https://unsplash.com/@fabiojpl).</small>

repository: biogit/gatsby-alien

gha_language: JavaScript

repo_name: biogit/gatsby-alien


text:
[![N|Python](https://www.python.org/static/community_logos/python-powered-w-100x40.png)](https://www.python.org)

[![CircleCI](https://circleci.com/gh/fusion-energy/cad_to_h5m/tree/main.svg?style=svg)](https://circleci.com/gh/fusion-energy/cad_to_h5m/tree/main) [![CI with docker build](https://github.com/fusion-energy/cad_to_h5m/actions/workflows/ci_with_docker_build.yml/badge.svg)](https://github.com/fusion-energy/cad_to_h5m/actions/workflows/ci_with_docker_build.yml)

[![PyPI](https://img.shields.io/pypi/v/cad-to-h5m?color=brightgreen&label=pypi&logo=grebrightgreenen&logoColor=green)](https://pypi.org/project/cad-to-h5m/)

<!-- can't report coverage as cubit init changes scope
[![codecov](https://codecov.io/gh/fusion-energy/cad_to_h5m/branch/main/graph/badge.svg)](https://codecov.io/gh/fusion-energy/cad_to_h5m) -->

[![docker-publish-release](https://github.com/fusion-energy/cad_to_h5m/actions/workflows/docker_publish.yml/badge.svg)](https://github.com/fusion-energy/cad_to_h5m/actions/workflows/docker_publish.yml)

This is a minimal Python package that provides both **command line** and
**API** interfaces for converting **multiple** CAD files (STP and SAT format)
into a DAGMC h5m file using the Cubit Python API.

This is useful for creating the DAGMC geometry for use in compatible neutronics
codes such as OpenMC, FLUKA and MCNP.

The geometry is tagged wih material names, optional imprinted and merging
during the process which can speed up particle transport.

<!--
# Command line usage

Perhaps the most common use of this program is to convert a STP file into
DAGMC geometry.
```bash
cad-to-h5m -i part1.stp -o dagmc.h5m -t mat:1 -c /opt/Coreform-Cubit-2021.5/bin/
```

- the ```-i``` or ```--input``` argument specifies the input CAD filename(s)
- the ```-o``` or ```--output``` argument specifies the output h5m filename
- the ```-t``` or ```--tags``` argument specifies the tags to apply to the CAD volumes.
- the ```-c``` or ```--cubit``` argument specifies the path to the Cubit python3 folder
- the ```-v``` or ```--verbose``` argument enables (true) or disables (false) the printing of additional details

Multiple STP or SAT files can also be combined and converted into a DAGMC
geometry. This example combines two STP files into a single geometry with
separate material tags for each STP file and saves the result as a h5m file.

```bash
cad-to-h5m -i part1.stp part2.stp -o dagmc.h5m -t mat:1 mat:2 -c /opt/Coreform-Cubit-2021.5/bin/
```

It is also possible to convert .sat files in the following way.

```bash
cad-to-h5m -i part1.sat -o dagmc.h5m -t mat:1 -c /opt/Coreform-Cubit-2021.5/bin/
``` -->

# Installation

The package is available via the PyPi package manager and the recommended
method of installing is via pip.
```bash
pip install cad_to_h5m
```

In addition [Cubit](https://coreform.com/products/coreform-cubit/) and the
[Svalinn Plugin](https://github.com/svalinn/Cubit-plugin) needs to be
installed to make full use of this package.

# Python API usage

Creating a h5m file from a single STP file called ```part1.stp``` and applying
a material tag to the volume.

```python
from cad_to_h5m import cad_to_h5m

cad_to_h5m(
    files_with_tags=[{'cad_filename':'part1.stp', 'material_tag':'m1'}],
    h5m_filename='dagmc.h5m',
    cubit_path='/opt/Coreform-Cubit-2021.5/bin/'
)
```

Creating a h5m file from two STP files called ```part1.stp``` and ```part2.stp```.
Both parts have distinct material tag applied to them and the result is output
as a h5m file with the filename dagmc.h5m.

```python
from cad_to_h5m import cad_to_h5m

cad_to_h5m(
    files_with_tags=[
        {'cad_filename':'part1.stp', 'material_tag':'m1'},
        {'cad_filename':'part2.stp', 'material_tag':'m2'}
    ],
    h5m_filename='dagmc.h5m',
    cubit_path='/opt/Coreform-Cubit-2021.5/bin/'
)
```

Creating a h5m file from a single SAT is a similar process. Note the .sat file
extension.

```python
from cad_to_h5m import cad_to_h5m

cad_to_h5m(
    files_with_tags=[{'cad_filename':'part1.sat', 'material_tag':'m1'}],
    h5m_filename='dagmc.h5m',
    cubit_path='/opt/Coreform-Cubit-2021.5/bin/'
)
```

Creating a tet mesh files compatible with the OpenMC / DAGMC Unstructured mesh
format is also possible. Another key called ```tet_mesh``` to the ```files_with_tags``` dictionary will trigger the meshing of that CAD file.
The value of the key will be passed to the Cubit mesh command as an instruction.
The following command will produce a ```unstructured_mesh_file.exo```
file that can then be used in DAGMC compatible neutronics codes. There are examples
[1](https://docs.openmc.org/en/latest/examples/unstructured-mesh-part-i.html)
[2](https://docs.openmc.org/en/latest/examples/unstructured-mesh-part-ii.html)
for the use of unstructured meshes in OpenMC.

```python
from cad_to_h5m import cad_to_h5m

cad_to_h5m(
    files_with_tags=[
        {
            'cad_filename':'part1.sat',
            'material_tag':'m1',
            'tet_mesh': 'size 0.5'
        }
    ],
    h5m_filename='dagmc.h5m',
    cubit_path='/opt/Coreform-Cubit-2021.5/bin/'
    exo_filename='unstructured_mesh_file.exo'
)
```

Use if ```exo``` files requires OpenMC to be compiled with LibMesh. OpenMC also
accepts DAGMC tet meshes made with MOAB which is another option. The following
example creates a ```cub``` file that contains a mesh. The MOAB tool
```mbconvert``` is then used to extract the tet mesh and save it as a ```h5m```
file which cna be used in OpenMC as shown in the OpenMC [examples](https://docs.openmc.org/en/stable/examples/unstructured-mesh-part-i.html)

```python
from cad_to_h5m import cad_to_h5m

cad_to_h5m(
    files_with_tags=[
        {
            'cad_filename':'part1.sat',
            'material_tag':'m1',
            'tet_mesh': 'size 0.5'
        }
    ],
    h5m_filename='dagmc.h5m',
    cubit_path='/opt/Coreform-Cubit-2021.5/bin/',
    cubit_filename='unstructured_mesh_file.cub'
)
```
The ```cub``` file produced contains a tet mesh as well as the faceted geometry.
The tet mesh can be extracted and converted to another ```h5m``` file for use in
OpenMC. MOAB is needed to convert the file and includes the command line tool
```mbconvert```, MOAB can be installed into a Conda environment with:

```
conda install -c conda-forge moab
```
Then ```mbconvert``` can be used to extract and convert the tet mesh from the
```cub``` file into a ```h5m``` file.

```bash
mbconvert unstructured_mesh_file.cub unstructured_mesh_file.h5m
```

Scaling geometry is also possible. This is useful as particle transport codes
often make use of cm as the default unit. CAD files typically appear in mm as
the default limit. Some CAD packages ignore units while others make use of them.
The h5m files are assumed to be in cm by particle transport codes so often it
is necessary to scale up or down the geometry. This can be done by adding
another key called ```scale``` and a value to the ```files_with_tags```
dictionary. This example multiplies the geometry by 10.

```python
from cad_to_h5m import cad_to_h5m

cad_to_h5m(
    files_with_tags=[
        {
            'cad_filename':'part1.sat',
            'material_tag':'m1',
            'scale': 10
        }
    ],
    h5m_filename='dagmc.h5m',
)
```

Assigning a material to the implicit complement is also possible. This can be useful on large complex geometries where boolean operations can result in robustness issues. This is implemented by assigning the desired material tag of the implicit complement to the optional ```implicit_complement_material_tag``` argument. Defaults to vacuum.

```python
from cad_to_h5m import cad_to_h5m

cad_to_h5m(
    files_with_tags=[
        {
            'cad_filename':'part1.sat',
            'material_tag':'m1',
        }
    ],
    h5m_filename='dagmc.h5m',
    implicit_complement_material_tag = 'm2'
)
```

gha_language: Python


text:
# {Name of View}

Instructions | Details
---|---
Description | Brief summary transformation
Usage | When and why to use this view
Modifications | List ways this view could be modified for custom use

```sql
-- CREATE VIEW view_name AS
SELECT *
FROM some_table t
JOIN some_other_table ot ON t.email=ot.email
```

## Example: {Name of example}

```sql
SELECT *
FROM view_name
WHERE email not ilike '%gmail%';
```


text:
# NFCCard_EMR_Implementation
Near Field Communication (NFC) Cards for Electronic Medical Records (EMR)

##NEAR FIELD COMMUNICATION
Near Field Communication (NFC) is a short-range wireless connectivity technology that enables exchange of data between devices and tags over a distance of up to about 10 centimeters.

Features of NFC
NFC can be used in both read and write mode, operating at 13.56 MHz with data transfer rates at 106, 212 or 424 Kbits/second. Communication between two
NFC-compatible devices occurs when they are brought within about 5 centi-meters of one another. A swipe or touch can establish an NFC connection. The underlying layers of
NFC technology follow universally implemented ISO, ECMA, and ETSI standards.

MIFARE NFC Card
In general, two types of RFID cards are used, active and passive cards. While active systems have an own source of energy, passive systems rely on the energy provided by the card readers.
One of the most common RFID Cards is the MIFARE Classic, produced by NXP Semiconductors. The MIFARE offers different types of cards, which are all passive and fully compliant with ISO/IEC 14443 Type A.
We used MIFARE Classic 1K for our experiments.


text:
# Veracode Upload and Scan Shell Script
This was originally written for CircleCI but can be used for any build system that can run a shell script in bash.

It can create a missing application profile, upload and scan, and break the build. If you do not want to create new apps then make sure to comment out or delete that section.

With many containerized or public build systems the developer cannot pre-install the Veracode Java API Wrapper, so the script does a quick wget to retrieve what is the current version as of now.

## Integration

The Veracode Upload & Scan script can be entered into the build system or stored as an artifact of the repository and called as a step in the build job section of the project's config.yml file. Note that the final variable is a build name or number which can be built from build server environment variables or specified manually. The Veracode API Id and Key should be created from a service account and stored as secret/protected environment variables.

Example: a new "run" command section is added as a new step in the build job section. There should be other "run" statements there to model this new one after. Note that

```
      - run:
          name: Veracode Scan Status
          command: ./veracode-scan.sh $VERACODE_API_ID $VERACODE_API_KEY "Verademo" "/home/circleci/repo/target/Verademo.war" build_name_number
```

## The Script

veracode-scan.sh

The script syntax is:

```veracode-scan.sh <API ID> <API KEY> <Application Name> <build name with full path> <scan / build name>```

There are a few variables that can be adjusted:

* PRESCAN_SLEEP_TIME -> total wait time for prescan completion
* SCAN_SLEEP_TIME -> total wait time for scan completion
* JAVA_WRAPPER_LOCATION -> location of the Java API wrapper
* OUTPUT_FILE_LOCATION -> directory of message output files. Make sure to change the hardcoded value.
* OUTPUT_FILE_NAME -> name of file to store command output in (default is AppName-ScanName.txt)

Note that the version of the Veracode Java API used is hardcoded in the script. As new versions come out it they are published to:
https://repo1.maven.org/maven2/com/veracode/vosp/api/wrappers/vosp-api-wrappers-java/
Simply change the version number in the script directory and file name to update.

**WARNING:** Make sure the API ID and Key are set up as protected environment variables so they will not leak to the public in your .yaml file or be displayed in build output.


text:
gcsa-locate
===========
This tool uses GCSA2 index to locate k-mers in the underlying graph.

Installation
------------
### Installing dependencies
- `g++` (>= 4.9)
- `zlib` (>=1.2.8) and `bz2` libraries:

      sudo apt-get install zlib1g-dev libbz2-dev

- Seqan2 (>=2.3.2): you can download seqan package from [here](http://packages.seqan.de).
  Then, unpack the library package to `PREFIX` (e.g. `/usr/local`). Make sure that the
  `seqan-2.pc` located in the `$PREFIX/lib/pkgconfig` directory contains correct value for
  `prefix`; e.g. in case that the library is installed in `/usr/local`, it should be:

      prefix=/usr/local

- SDSL library (>=2.1.0): to download and install SDSL library see its
  [GitHub page](https://github.com/simongog/sdsl-lite).
- [GCSA2 (>=1.0.0)](https://github.com/jltsiren/gcsa2): this library does not provide a
  proper installation script. After compiling the library, you can use
  [this script](https://gist.github.com/cartoonist/32fc8595d8e1a6255c44067d1eb0dfcc#gistcomment-2172472)
  to install the library to `PREFIX` (e.g. `/usr/local`):

      chmod u+x install.sh
      ./install.sh /usr/local

### Building `gcsa-locate`
In order to build the tool, simply run:

    ./autogen.sh  # if it is compiled from a git clone.
    ./configure
    make
    sudo make install

Usage
-----
Consult with the man page:

    man gcsa_locate

repository: cartoonist/gcsa-locate

repo_name: cartoonist/gcsa-locate


text:
# Taxonomie des pratiques de Mémo Akten

|       |       |  Acronymes     |  Définition     |       |
|  ---  |  ---  |  ---  |  ---  |  ---  |
|       |       |  I-Art      |  pratique dans laquelle l'œuvre est influencée de façon significative par une interaction avec l'audience.     |       |
|       |       |  Ele-Art      |  pratique qui implique l'utilisation de composante électronique et électrique d'ingénierie.     |       |
|       |       |  C-art    |  utilise en partie l'ordinateur pour fabriquer l'œuvre d'art \| Forne d'art dont les processus de production impliquent l'ordinateur     |       |
|       |       |  D-Art     |  pratique qui utilise la technologie de l'électronique numérique.     |       |
|       |       |  G-Art     |  pratique dans laquelle l'œuvre est en partie générée par un processus informatique dont l'artiste n'a aucun contrôle directe.     |       |
|       |       |  CI-Art     |  pratique dans laquelle l'œuvre générée par ordinateur est affecté de façon significative par le comportement de l'audience.       |       |

# Bullet

1. Ele-art involves electrical engineering and / or electronic technology.
2. C-art uses computers as part of the art- making process.
3. D-art uses digital electronic technology of some sort.
4. CA-art uses the computer as an aid (in principle, non-essential) in the art-making process.
5. G-art works are generated, at least in part, by some process that is not under the artist’s direct control.
6. CG-art is produced by leaving a computer program to run by itself, with minimal or zero interference from a human being. NB: We chose to reject the stricter definition of CG-art (art produced by a program left to run by itself, with zero interference from the human artist).
7. Evo-art is evolved by processes of random variation and selective reproduction that affect the art-generating program itself.
8. R-art is the construction of robots for artistic purposes, where robots are physical machines capable of autonomous move- ment and / or communication.
9. In I-art, the form / content of the artwork is significantly affected by the behaviour of the audience.
10. In CI-art, the form / content of some CG-artwork is significantly affected by the behaviour of the audience.
11. In VR-art, the observer is immersed in a computer-generated virtual world,experiencing it and responding to it as if it were real.

# Table

|   No    |  Acronym     | Definition      |   Artists    |    Notes     |
|  ---  |  ---  |  ---  |  ---  | --- |
|   1.    |  Ele-art       |  involves electrical engineering and / or electronic technology.     |       |        |
|   2.    |  C-art      |  C-art uses computers as part of the art- making process.     |       |        |
|   3.    |  D-art     | D-art  uses digital electronic technology of some sort.     |       |        |
|   4.    |  CA-art     |  CA-art uses the computer as an aid (in principle, non-essential) in the art-making process.      |       |        |
|  5.     |  G-art     |  works are generated, at least in part, by some process that is not under the artist’s direct control.      |       |        |
|  6.     |  CG-art    |   CG-art  is produced by leaving a computer program to run by itself, with minimal or zero interference from a human being. NB: We chose to reject the stricter definition of CG-art (art produced by a program left to run by itself, with zero interference from the human artist).     |       |        |
|   7.    |  Evo-art    |  Evo-art  is evolved by processes of random variation and selective reproduction that affect the art-generating program itself.      |       |        |
|   8.    |  R-art    | R-art  is the construction of robots for artistic purposes, where robots are physical machines capable of autonomous move- ment and / or communication.      |       |        |
|  9.     |  I-art    |  In I-art, the form / content of the artwork is significantly affected by the behaviour of the audience.      |       |        |
|   10.    |  CI-art     |  In CI-art, the form / content of some CG-artwork is significantly affected by the behaviour of the audience.     |    |    |
|   11.    |   VR-art    |  In VR-art, the observer is immersed in a computer-generated virtual world, experiencing it and responding to it as if it were real.     |       |        |

# Further question about judgemental concerns
|       |       |       |       |       |
|  ---  |  ---  |  ---  |  ---  |  ---  |
|       |       |   creativity    |       |       |
|       |       |   authorial    |       |       |
|       |       |   responsibility    |       |       |
|       |       |   agency    |       |       |
|       |       |   autonomy    |       |       |
|       |       |   authenticity    |       |       |
|       |       |   ontology    |       |       |

repository: guillaumedescoteauxisabelle/ma-biblio

repo_name: guillaumedescoteauxisabelle/ma-biblio


text:
# webhookr: Rails Webhooks Made Easy
[![Build Status](https://travis-ci.org/dark-panda/webhookr.png?branch=master)](https://travis-ci.org/dark-panda/webhookr)
[![Dependency Status](https://gemnasium.com/dark-panda/webhookr.png)](https://gemnasium.com/dark-panda/webhookr)
[![Code Climate](https://codeclimate.com/github/dark-panda/webhookr.png)](https://codeclimate.com/github/dark-panda/webhookr)
[![Coverage Status](https://coveralls.io/repos/dark-panda/webhookr/badge.png?branch=master)](https://coveralls.io/r/dark-panda/webhookr?branch=master)

## Introduction

### What is webhookr?

webhookr is a Rails Engine that easily and securely adds third-party
webhooks to your Rails app. It supports third-party sites with modular
plugins.

### What are 'webhooks'?

From 30,000 feet, webhooks allow disparate cloud services to coordinate and
asynchronously notify each other of events of interest. For example, a shopping app might
want to process a [customer credit card transaction](https://stripe.com/docs/webhooks),
and be notified of success or failure.

From 10,000 feet, webhooks allow external third parties the ability to
execute code within your application, using a well defined message exchange
protocol.

From 1,000 feet and below, webhooks are application routes and controller
endpoints, third-party API discovery, security decisions, and code that
executes within your application.

### Why use webhookr?

Webhooks are http callbacks from another service that are useful for
pushing information to your Rails application. The question is: How do I
easily and securely add them to my Rails application?

webhookr provides a single, secure route for all your webhooks, and uses
the observer pattern to integrate the webhook with your business logic.
Using webhookr you can be up and running with a third-party webhook in less
than an hour.

### How does webhookr work?

Webhookr provides a standard approach for third-party webhooks via plugins. The
author of a plugin implements code to standardize any webhook into an action and
data packet. Your task is to write glue code that is called whenever an action is
received, and to use the resulting data packet for your application logic. Here is
a subset of the MailChimp handler that might be written to deal with the 'unsubscribe'
action sent from MailChimp:

```ruby
class MailChimpHooks
  def on_unsubscribe(payload)
    User.unsubscribe_newletter(payload.data.email)
  end
end
```

## Usage & Setup

webhookr works with Rails 3.1 onwards. It generally requires a plugin to be
useful, such as the [MailChimp plugin](https://github.com/dark-panda/webhookr-mailchimp).

## Setup

Add webhookr to your Gemfile with:

```ruby
gem 'webhookr'
```

Run the bundle command to install it and then run the generator to
add the engine route to your config/routes.rb:

```console
rails g webhookr:add_route
```

or, add the routing information manually to config/routes.rb

```ruby
mount Webhookr::Engine => "/webhookr", :as => "webhookr"
```

The initialization file for webhookr is optional. To see what
options are available, you can run the generator and review the
sample config file:

```console
rails g webhookr:init *initializer_name*
```

Once you have added third-party plugins, you can use the provided
rake task to output your applications urls for each service:

```console
rake webhookr:services
```

## Webhookr Security

### Important security note

A timing attack vulnerability was discovered in versions of webhookr prior to 0.2.0.
It is recommended that you upgrade to as soon as possible to at least version 0.2.0.

Please see revision ccafc8248559a09e090cf824c8454c9824555a06 for details.

### General security issues with webhooks

A webhook is by design, a http post to your application that results in code execution.
Having a well defined approach to adding such functionality can help ensure you don't open security issues
within your application.

Many webhook providers do not provide built-in security for their
webhooks - they usually send the post over http, and they often have no authentication
or verification mechanism. If your webhook third-party service responds to hooks, it is
possible for an evil person to guess your webhook URL, and attempt to wreak havoc with your system.

### How using webhookr can increase security
webhookr provides a unique url for each service, via a security token that is used in the webhook path, to help make it hard to guess your webhook url.
For example, if you were using MailChimp, your webhook url might look like: '/webhookr/mailchimp/cdd2a24cfac821' and if you were using Mandrill, your
webhook might look like: '/webhookr/mandrill/de69557a4d95e7'. This will help prevent someone guessing your
webhook service url. If you are using https, the URL will be encrypted, keeping your security token a secret.

You can also enable http basic auth, if the third party service supports it.

If you are sending sensitive data via webhooks, it is recommended you use HTTPS.

### Supported Services

* MailChimp - [webhookr-mail_chimp](https://github.com/dark-panda/webhookr-mailchimp)
* Mandrill - [webhookr-mandrill](https://github.com/gerrypower/webhookr-mandrill)
* Stripe - [webhookr-stripe](https://github.com/gerrypower/webhookr-stripe)
* Recurly - [webhookr-recurly](https://github.com/tfe/webhookr-recurly)
* Github - coming soon

## Works with:

webhookr works with Rails 4.0 and 3.1+, and has been tested on the following Ruby
implementations:

* JRuby 1.7.4
* MRI 1.9.3
* MRI 2.0.0

### TODO
* Implement get/post strategies and responses so the controller can return variable text to the service.
This allows support for advanced Webhook responses for services that require it.
* Enhance testing of Rake tasks
* Clean up the stubs with FactoryGirl

### Versioning
This library aims to adhere to [Semantic Versioning 2.0.0](http://semver.org/). Violations of this scheme should be reported as
bugs. Specifically, if a minor or patch version is released that breaks backward compatibility, that
version should be immediately yanked and/or a new version should be immediately released that restores
compatibility. Breaking changes to the public API will only be introduced with new major versions. As a
result of this policy, once this gem reaches a 1.0 release, you can (and should) specify a dependency on
this gem using the [Pessimistic Version Constraint](http://docs.rubygems.org/read/chapter/16#page74) with
two digits of precision. For example:

    spec.add_dependency 'webhookr', '~> 1.0'

While this gem is currently a 0.x release, suggestion is to require the exact version that works for your code:

    spec.add_dependency 'webhookr', '0.0.2'

### License

webhookr is released under the [MIT license](http://www.opensource.org/licenses/MIT).

## Authors

* [Gerry Power](https://github.com/gerrypower)
* [J Smith](https://github.com/dark-panda)

repository: dark-panda/webhookr

gha_language: Ruby

repo_name: dark-panda/webhookr


text:
# my_tqdm
my_tqdm. It doesn't flood ipython notebooks with newlines. It is done in a one single file so it doesn't require any installation.

**"Installation"**:
```
!wget https://raw.githubusercontent.com/rashchedrin/my_tqdm/master/my_tqdm.py -nc -O my_tqdm.py
from my_tqdm import my_tqdm
```
**Usage**:
```
for _ in my_tqdm(range(50000000)):
    pass
```
Example output:
```
50000000 / 50000000. 1527040.411 ops/sec. Expected end: 2019-12-16 14:47:48.528161. Left: 0s. Spent: 32s..
```


text:
Errors
-----------------------

1. When you try to click the download button after something has been downloaded already (after you click "Undo"... you can check if this is always the case), you get the following error:
```
Warning: Error in normalizeChoicesArgs: Please specify a non-empty vector for `choices` (or, alternatively, for both `choiceNames` AND `choiceValues`).
observeEventHandler [C:\Users\Avery\Documents\R_Code\geocurate_repo\GEOcurate/app.R#371]
```
__SOLVED__
Kept the platforms module from showing if the platforms do not exist. "Undo" should work normally now.

2. After downloading GSE68849, if you click on the summary tab, it will throw the following error (perhaps it has something to do with the semicolons in the column names?):
```
Warning: Error in <Anonymous>: No handler registered for type .clientdata_output_agent:ch1_width
  [No stack trace available]
Error in (function (name, val, shinysession)  :
  No handler registered for type .clientdata_output_agent:ch1_width
```
__SOLVED__
Added make.names to the plotting code (Summary tab) to get rid of the illegal characters in the column names, but just for the back-end of the plots.

3. GSE10 Expression graphical summary: `Error: missing value where TRUE/FALSE needed`

    __SOLVED__
    Added `na.rm = TRUE` in the renderUI where it's figuring out the default width of the bars

4. `cannot remove prior installation of package 'mime'`

    __SOLVED__

     - Screenshot the place where the packages are being installed
     - End RStudio using Task Manager
     - Navigate to the place where the packages are being installed
     - Try to delete `mime` directory
     - If the directory says it's being used by another program,
     - Navigate to the innermost level of the directory
     - Attempt to delete the innermost file
     - The message will tell you which program is using the directory
     - Find that program in Task Manager
     - End the program
     - Open RStudio again
     - Reinstall the package

5. `Error in value[[3L]](cond) : there is no package called ‘markdown’`

    __SOLVED__
    Added `library(rmarkdown)` to app.R (https://community.rstudio.com/t/error-in-deploying/33173/14)

Fixes
----------------------
1. The app does not allow the user to choose which new column name to remove.

    __LEFT__ The "remove" button just takes off the last name that was specified, so if the user wants to delete a different one, they must start over.
2. The app allows the user to put multiple of the same column name.

    __SOLVED__ Added unique = TRUE to make.names in the renameCols function.
3. When substituting values, the options of which values to substitute do not update after the substitute operation has been evaluated.

    __SOLVED__ Updated the options after the "Substitute" button is pressed.
4. The feature data table does not have select inputs for any of the filters, even though those columns should be factors.

    __LEFT__
     - https://stackoverflow.com/questions/49699991/how-to-change-the-column-filter-control-in-r-shiny-datatables
     - https://rstudio.github.io/DT/
5. The app is taking too long to load because of the series list file.

    __SOLVED__ Used feather files instead of RDS files to store the data.
```
[1] "RDS time:"         "0.201472043991089"
[1] "Feather time:"      "0.0897789001464844"
 ```
6. The app is still taking too long to load because of the series list file.

    __SOLVED__ Prepared the feather files all beforehand (naming the columns correctly, including the correct columns) in another script, because making a dataframe in the list dropdown is very time-expensive.
```
[1] "Reading files 0.107712984085083"
[1] "Populating dropdown 0.00898313522338867"
```

gha_language: HTML


text:
---
title: "Music Suite: A Family of Musical Representations"
subtitle: FARM 2014 Demo Proposal
...

# Background

Musical representation is one of the most central problems in any branch of computer music: at the core of any computer music library or application is a set of data structures defining the possibilities and limitations of the system, and consequently of the music handled by it. In effect, this structure is not merely a *representation*, but the grammar of the musical *language* understood by the system and its users.

Despite, or perhaps because of its importance, musical representation is widely held to be complex and poorly understood. In part, this reflects on the nature of music theory, which is (understandably) more concerned with flexibility and appropriateness for specific musical problems than with the generality of the underlying theoretical model.

Computer music systems fall into two broad categories: score-based systems which operate on hierarchical structures similar to musical scores, and sound-based systems which operate on audio signals. More generally, we can talk about *discrete* and *continuos* representations of music. The distinction is not merely technical, but conceptual: a discrete representation is necessarily more structured than a single continuous signal.

<!--
On the other hand, discrete representation tends to give rise to continuous *souding results*. For example, an musical score consists of a discrete set of continuous events, which when player together give rise to a single continuous audio signal.
-->

Traditionally audio-based systems tend to use a very open approach with few assumptions on the music (or other forms of audio) being processed. Score-based systems, on the other hand, tend to be limited to a small musical vocabulary, often derived from Common Music Notation. This naturally makes it difficult to represent music from traditions other than Western classical music.

The use of a modern functional language such as Haskell suggests a more general approach, in which culture-specific musical concepts are treated parametrically. For example, the concept of *score* can be generalized to not only work on notes in the diatonic–chromatic pitch space, but in any pitch space, or even include non-pitched sounds.

# The Music Suite

The Music Suite attempts to be a general music representation system including both discrete and continuos representations. The design of the suite is informed by the following principles:

- It should describe musical *meaning*, which includes both its sounding *interpretation* and its visual *notation*.

- It should avoid imposing stylistic or theoretical assumptions on the music. In particular we want to treat the core musical aspects of *pitch*, *dynamics* and *articulation* polymorphically.

- It should allow different kinds of *part* and *time* structure. using composable types and operators. These types should a well defined *time semantics* allowing us to reason about time and structure in a generic fashion.

- It should include common music notation as a *special case*.

## Organization

The suite is conceived as a set of Haskell packages developed and released synchronously with each other. Each package focuses on a single musical *aspect* such as *time*, *pitch*, *dynamics* or *articulation*. The type of music represented in the suite is not fixed, but composed out of a set of generic type constructors and combinators.

Of all the aspects, time is treated somewhat specially. Indeed, many of the types and functions in the suite are not strictly limited to music, but could apply to any time-based medium including animation or real-time performance control.

Most musical aspects can be thought of as points in some affine space, with an associated vector space to represent distance between points. For example, pitches forms an affine space with intervals as the underlying vector space, while time points form an affine space with durations as vectors.

This is similar to the approach taken in Diagrams^[http://projects.haskell.org/diagrams], with some notable differences: while graphical representations tends to span a single multi-dimensional affine space such as `R2`, the musical types each span a particular one-dimensional affine space.

## Time types

The core of the library is a set of *time types*, which define musical time and values with a position in time. These types borrows many concepts from FRP, particularly Reactive^[http://www.haskell.org/haskellwiki/Reactive], which provides an established vocabulary for reasoning about discrete and continuos time structures.

The most basic time types are `Time` and `Duration` which represents points and distances in time, `Span` which represents an era between two time points. From these simple types and ordinary pairs and functions, a rich vocabulary of continuos and discrete time types can be constructed.

The Music Suite does not provide any real-time implementations of these structures: the approach is data-centric and intended to be used in non-realtime applications such as composition and analysis (see also Future Work).

## Musical aspects

Musical aspects such as pitch and dynamics is treated parametrically. While most time types are unary type constructors, musical aspects are represented by concrete types. To handle several musical aspects in a single structure a set of classes and type functions are provided for extracting and updating the appropriate type in a nested structure.

For example the `Music.Score.Pitch` module defines the following type functions:

    type family Pitch (s :: *) :: *
    type family SetPitch (b :: *) (s :: *) :: *

Then `lens` library is used for accessing pitches. Two classes are provided: `HasPitch`, for types with a single pitch, and `HasPitches` for types that provides an arbitrary number of pitches, defining a `Lens` and a `Traversal` respectively.

The overloaded lenses and traversals allow us to define operations such as dynamic fades, pitch transposition and so on over any kind of container that contains the musical aspect in questions, including single notes, voices or scores.

## Meta-information

Purely graphical information is treated *dynamically*, using existential wrappers for `Typeable` values. The approach is similar to Diagram's *styles*. Each time type (including behaviors, voices and scores) provide an instance of the following class:

    class HasMeta a where
        meta :: Lens' a Meta

`Meta` is conceptually a dictionary of dynamic values subject to time transformations, and can be wrapped and unwrapped as follows:

    type IsAttribute a =
        (Typeable a,
         Monoid a,
         Transformable a)
    toMeta :: IsAttribute a => a -> Meta
    fromMeta :: IsAttribute a => Meta -> Maybe a

The notion of meta-data is not limited to constant values: in fact most types of meta-data used in the Music Suite are stored as *time-varying* values. This makes it possible to track information that affects notation but not sound, such as key and time signatures. Backends can recognize meta-information as they see fit.

## Preludes

The libraries provide a large set of representations of common musical aspects such as pitch, dynamics, articulation and so on. The goal is to be *open* and *comprehensive* rather than *complete*. Representations can be combined in many ways to form a suitable representation for almost any kind of music. In a sense, the music suite describes an *family* of embedded domain-spefic languages.

The 'music-preludes' package defines a large set of ready-to-use musical representations which are compatible with standard formats such as MIDI and MusicXML, provided along with a large set of examples and regression tests.

# Status

Released under an "optimistic" versioning scheme, the suite is currently at version 1.7.0, with 2.0.0 set to be the first stable version. The library has undergone steady development since early 2013 and the aim is to release 2.0.0 in early 2015.

The Music Suite is distributed on Hackage and the source code is freely available on Github. It is installed using:

    cabal install music-preludes

For reference, documentation and examples, see:

    http://music-suite.github.io

For the source code, see:

    https://github.com/music-suite

Discussion and suggestions for improvements should take place on the dedicated mailing list:

<EMAIL_ADDRESS>
# Future work

There is still much room for improvement. While the suite currently offers a comprehensive set of musical *primitives*, it lacks many higher-level musical concepts such as scales, rhythms, motives or contraint-based rule systems such as those used in Western classical counterpoint or Indian classical ragas. The main challenge is to implement high-level concepts while still maintaining generality.

The suite requires knowledge of intermediate-to-advanced type system features, and ability to parse possibly intimidating error messages. A *simplified* version, while less general, could provide a valuable pedagogical alternative which could serve as an introduction to the suite, possibly as a standalone compiler or web application. As is often the case, there is a tension between generality and simplicity.

The current implementations of the data structures are general, but not very efficient. Much can be gained by adding minimal restrictions, or developing restricted variations of the core data structures.

The Music Suite shares many concepts with both FRP libraries and graphical libraries such as Diagrams. Although we already share a common core in standard type-classes, and the `vector-space` and `vector-space-points` libraries, there is the possibility of factoring out a larger common core. In particular, the `Behavior` and `Track` types in `music-score` corresponds to behaviors and events in classical FRP. The concepts of points, segments and transformations used in Diagrams also have direct correspondences in the Music Suite.

repository: hanshoglund/music-suite

gha_language: Haskell

repo_name: hanshoglund/music-suite


text:
# vlt.file.rename_mfiles_functions

```
  RENAME_MFILES_FUNCTIONS - Rename mfiles and function names

  vlt.file.rename_mfiles_functions(MFILEDIRS, EDITMFILEDIRS, ...)

  This function traverses the directory (and all subdirectories) MFILEDIRS and identifies all
  .m files. If any file name renaming parameters (see below) are specified, then the .m files
  are renamed, and any text within the files that refers to the filename is edited to match the new
  name. The function then traverses the directory EDITMFILEDIRS and any of its subdirectories, looking
  for text occurrences of the renamed functions, which are replaced with the new values.

  This file also accepts name/value pairs that specify file renaming parameters:
  Parameter (default)           | Description
  ---------------------------------------------------------------------------------
  dirstrings_to_exclude         | Directories whose name contains these strings will be ignored
      {'.git','archived_code'}  |

  See also: vlt.data.namevaluepair

```

repository: VH-Lab/vhlab-toolbox-matlab

gha_language: MATLAB

repo_name: VH-Lab/vhlab-toolbox-matlab


text:
# Rutracker proxy
[![forthebadge](http://forthebadge.com/images/badges/built-with-love.svg)](http://forthebadge.com)
[![forthebadge](http://forthebadge.com/images/badges/uses-js.svg)](http://forthebadge.com)

#### Proxies for traversal of annunciator locks [RuTracker.ORG](https://rutracker.org/)

#### All questions, suggestions and discussions are kept here
#### https://rutracker.org/forum/viewtopic.php?t=5403116

![](misc/main-window.png?raw=true)

#### Benefits:
- proxy through external proxy servers, only traffic on rutracker.org
- automatic proxy change on error
- work with external socksv5 and http proxies
- Cross-platform (Windows / OSX / Linux)
- Free and license MIT

#### Todo
- Add support for third-party ** https ** Annonceurs
- Support for external https proxy servers
- auto application update
- setup page, with choice of port and interface
- autoloading in tray
- proxying requests to the forum

repository: peterpt/rutracker-proxy

repo_name: peterpt/rutracker-proxy


text:
---
title:  "SymfonyWorld Online 2020"
date:   2020-10-30
categories: DEV
tags: php symfony
---

# SymfonyWorld Online 2020

* Symfony meets Cypress — E2E testing for symfony developers
* Streaming: an alternative to CRUD & batch processing
* [Elasticsearch with Symfony, from development to production](https://jolicode.github.io/elasticsearch-php-conf/slides/symfonyworld2020.html#/)
* [Modern Security with Symfony's Shiny new Security Component](https://speakerdeck.com/weaverryan/modern-security-with-symfonys-shiny-new-security-component)
* [What’s new in API Platform?](https://speakerdeck.com/dunglas/api-platform-2-dot-6-php-8-support-next-dot-js-and-nuxt-dot-js-app-generator-caddy-server-activitypub-and-much-more)
* Lock & Semaphore: The gatekeepers of your resources
* Keynote: What’s new in PHP 8.0?
* [Composer 2](https://www.naderman.de/slippy/slides/2020-12-04-SymfonyWorld-Online-2020-Composer-2.pdf)
* WebAuthn — Technology and integration in a Symfony project
* [Internationalize your Symfony application, the right way](https://speakerdeck.com/welcomattic/internationalize-your-symfony-application-the-right-way)
* How Math, Science, and Star Trek Explain the Value of Team Diversity
* Get Social! Implementing Social Login in your Symfony Project
* The absolute beginner’s guide to Domain Driven Design with Symfony
* [The absolute beginner’s guide to Domain Driven Design with Symfony - app](https://github.com/nealio82/absolute-beginners-guide-to-ddd-with-symfony)
* Keynote: For the Users — tech, ethics and you
* [Why 0.1 + 0.2 != 0.3, or the mysterious world of floating-point numbers.](https://speakerdeck.com/bitone/why-0-dot-1-plus-0-dot-2-equals-0-dot-3-or-the-mysterious-world-of-floating-point-numbers)

[SymfonyWorld Online 2020 Replay](https://live.symfony.com/account/replay/videos/2020-world)

gha_language: SCSS


text:
Description
===========

Installs php-7.0 apache2-fpm

Requirements
============

## Platform:

* Ubuntu/Debian

Attributes
==========

## Apache 2

```bash
default['apache2']['hostname'] = 'your-domain-name.com'
default['apache2']['htpasswd'] = false
```

## Unattended-upgrade

```bash
default['unattended-upgrades']['apticron_email'] =<EMAIL_ADDRESS>```

Usage
=====

Put `recipe[php7.0-apache2-fpm]` in a run list, or `include_recipe 'php7.0-apache2-fpm'` to ensure that sandbox is installed on your systems.

Testing
-------
Default .kitchen.yml test the cookbook in docker containers.

To test locally:

```bash
kitchen list
kitchen converge php70-apache2-fpm-ubuntu-xenial
kitchen verify php70-apache2-fpm-ubuntu-xenial
```

To test the cookbook on AWS instances use:

Configure the access to your AWS account using the AWS CLI:
```bash
aws configure --profile=AWS_CLI_PROFILE
```

copy the .kitchen-aws.yml to .kitchen-aws.local.yml and configure to suite your AWS account.

```bash
AWS_PROFILE=AWS_CLI_PROFILE KITCHEN_YAML=.kitchen-aws.local.yml bundle exec kitchen list

AWS_PROFILE=AWS_CLI_PROFILE KITCHEN_YAML=.kitchen-aws.local.yml bundle exec kitchen verify php70-apache2-fpm-ubuntu-xenial-aws
AWS_PROFILE=AWS_CLI_PROFILE KITCHEN_YAML=.kitchen-aws.local.yml bundle exec kitchen verify php70-apache2-fpm-ubuntu-trusty-aws
AWS_PROFILE=AWS_CLI_PROFILE KITCHEN_YAML=.kitchen-aws.local.yml bundle exec kitchen verify php70-apache2-fpm-ubuntu-precise-aws
```

To test all at once:

```bash
AWS_PROFILE=AWS_CLI_PROFILE KITCHEN_YAML=.kitchen-aws.local.yml bundle exec kitchen verify -c 5
```

Refer to the [kitchen-ec2](https://github.com/test-kitchen/kitchen-ec2) documentation

Changes
=======

* v1.0.0: Initial commit

Contributing
------------
1. Fork the repository on Github
2. Create a named feature branch (like `add_component_x`)
3. Write your change
4. Write tests for your change (if applicable)
5. Run the tests, ensuring they all pass
6. Increase the version number of the cookbook in the metadata.rb and update this README.md with the version change.
7. Submit a Pull Request using Github

License and Authors
-------------------
Authors:

* Oswald De Riemaecker<EMAIL_ADDRESS>
```text
Copyright 2015, Continuous S.A.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
```


text:
# REKKA

[DEPRECATED]

This is my experimental project about 4~5 years ago, it is similar to [Ejecta](https://github.com/phoboslab/Ejecta) or cocoonjs, but its main goal is to speed up the RPG Maker MV games.

I like RMMV very much, I also like mobile games. But, especially at that time, slightly complicated RMMV games did not run smoothly on mobile phones. For example, when I ran Moghunter's [Master Demo MV](https://atelierrgss.wordpress.com/download-page-mv-01/) on Xiaomi MI2S or MI3, I got <10 FPS on the map, even 1~3 FPS(MI3) in battle.

So I made this. It can run the RMMV games completely and correctly (neither Ejecta or cocoonjs). It have a significant performance improvement in windows, but the improvement is limited on Android. No testing on iOS, but I think it will be worse (SpiderMonky is very slow on iOS).

So it has no value to use. If I remake this today, I will use the full-platform vulkan + v8 solution (v8 is runable on iOS now), I believe I can get great performance improvement as I expect.

## Prebuilt Demo

This demo has integrated Moghunter's [Master Demo MV](https://atelierrgss.wordpress.com/download-page-mv-01/) (an old version)

Downloads:
[Windows](https://github.com/re-esper/rekka/releases/download/0.1/rekka-demo-windows.zip)
[Android](https://github.com/re-esper/rekka/releases/download/0.1/rekka-demo-android.apk)

Screenshots:

Note: The FPS show in screenshots ran on my i7-7700k and its Integrated gpu HD630.

## Libraries

Rekka mainly utilizes the following open-source libraries:
- [SDL](https://github.com/SDL-mirror/SDL)
- [SDL-gpu](https://github.com/grimfang4/sdl-gpu)
- [SpiderMonkey](https://developer.mozilla.org/en-US/docs/Mozilla/Projects/SpiderMonkey)

repository: re-esper/rekka

repo_name: re-esper/rekka


text:
## How Can I Contribute?

### Reporting Bugs

This section guides you through submitting a bug report for Liquid-dl. Following these guidelines helps maintainers and the community understand your report :pencil:, reproduce the behavior :computer: :computer:, and find related reports :mag_right:.

Before creating bug reports, please check [this list](#before-submitting-a-bug-report) as you might find out that you don't need to create one. When you are creating a bug report, please [include as many details as possible](#how-do-i-submit-a-good-bug-report). Fill out [the required template](ISSUE_TEMPLATE.md), the information it asks for helps us resolve issues faster.

> **Note:** If you find a **Closed** issue that seems like it is the same thing that you're experiencing, open a new issue and include a link to the original issue in the body of your new one.

#### Before Submitting A Bug Report

* **Perform a [cursory search](https://github.com/search?utf8=%E2%9C%93&q=is%3Aissue+in%3Aliquid_dl+repo%3Akthulu120%2Fliquid_dl&type=Issues)** to see if the problem has already been reported(simply type some keywords of the issue after the repo search string). If it has **and the issue is still open**, add a comment to the existing issue instead of opening a new one.

#### How Do I Submit A (Good) Bug Report?

Bugs are tracked as [GitHub issues](https://guides.github.com/features/issues/). After you've determined your bug create an issue and provide the following information by filling in [the template](ISSUE_TEMPLATE.md).

Explain the problem and include additional details to help maintainers reproduce the problem:

* **Use a clear and descriptive title** for the issue to identify the problem.
* **Describe the exact steps which reproduce the problem, don't just say what you did, but explain how you did it**. For example, if you moved the cursor to the end of a line, explain if you used the mouse, or a keyboard shortcut or an Liquid-dl command, and if so which one?
* **Provide specific examples to demonstrate the steps**. Include links to files or GitHub projects, or copy/pasteable snippets, which you use in those examples. If you're providing snippets in the issue, use [Markdown code blocks](https://help.github.com/articles/markdown-basics/#multiple-lines).
* **Describe the behavior you observed after following the steps** and point out what exactly is the problem with that behavior.
* **Explain which behavior you expected to see instead and why.**
* **Include screenshots and animated GIFs**
* **If you're reporting that Liquid-dl crashed**, include a crash report with a stack trace from the operating system. On macOS, the crash report will be available in `Console.app` under "Diagnostic and usage information" > "User diagnostic reports". Include the crash report in the issue in a [code block](https://help.github.com/articles/markdown-basics/#multiple-lines), a [file attachment](https://help.github.com/articles/file-attachments-on-issues-and-pull-requests/), or put it in a [gist](https://gist.github.com/) and provide link to that gist.

Provide more context by answering these questions:

* **Can you reproduce the problem?**
* **Did the problem start happening recently** (e.g. after updating to a new version of Liquid-dl) or was this always a problem?
* If the problem started happening recently, **can you reproduce the problem in an older version of Liquid-dl?** What's the most recent version in which the problem doesn't happen? You can download older versions of Liquid-dl from [the releases page](https://github.com/Kthulu120/liquid_dl/releases).
* **Can you reliably reproduce the issue?** If not, provide details about how often the problem happens and under which conditions it normally happens.
* If the problem is related to working with files (e.g. opening and editing files), **does the problem happen for all files and projects or only some?** Does the problem happen only when working with local or remote files (e.g. on network drives), with files of a specific type (e.g. only JavaScript or Python files), with large files or files with very long lines, or with files in a specific encoding? Is there anything else special about the files you are using?

Include details about your configuration and environment:

* **Which version of Liquid-dl are you using?**
* **What's the name and version of the OS you're using**?
* **Are you running Liquid-dl in a virtual machine?** If so, which VM software are you using and which operating systems and versions are used for the host and the guest?

### Suggesting Enhancements

This section guides you through submitting an enhancement suggestion for Liquid-dl, including completely new features and minor improvements to existing functionality. Following these guidelines helps maintainers and the community understand your suggestion :pencil: and find related suggestions :mag_right:.

#### How Do I Submit A (Good) Enhancement Suggestion?

Enhancement suggestions are tracked as [GitHub issues](https://guides.github.com/features/issues/). After you've determined your enhancement suggestion is related to, create an issue on that repository and provide the following information:

* **Use a clear and descriptive title** for the issue to identify the suggestion.
* **Provide a step-by-step description of the suggested enhancement** in as many details as possible.
* **Provide specific examples to demonstrate the steps**. Include copy/pasteable snippets which you use in those examples, as [Markdown code blocks](https://help.github.com/articles/markdown-basics/#multiple-lines).
* **Describe the current behavior** and **explain which behavior you expected to see instead** and why.
* **Include screenshots and animated GIFs** which help you demonstrate the steps or point out the part of Liquid-dl which the suggestion is related to. You can use [this tool](https://www.cockos.com/licecap/) to record GIFs on macOS and Windows, and [this tool](https://github.com/colinkeenan/silentcast) or [this tool](https://github.com/GNOME/byzanz) on Linux.
* **Explain why this enhancement would be useful** to most Liquid-dl users
* **Specify which version of Liquid-dl you're using.**
* **Specify the name and version of the OS you're using.**

### Your First Code Contribution

Unsure where to begin contributing to Liquid-dl? You can start by looking through these `good-first-issue` and `help-wanted` issues:

* [Beginner issues](https://github.com/search?utf8=%E2%9C%93&q=is%3Aopen+repo%3Akthulu120%2Fliquid_dl+label%3A%22good+first+issue%22&type=Issues) - issues which should only require a few lines of code, and a test or two.
* [Help wanted issues](https://github.com/search?utf8=%E2%9C%93&q=is%3Aopen+repo%3Akthulu120%2Fliquid_dl+label%3A%22help+wanted%22&type=Issues) - issues which should be a bit more involved than `beginner` issues.

Both issue lists are sorted by total number of comments. While not perfect, number of comments is a reasonable proxy for impact a given change will have.

#### Local development

Build the project as you normally would then simply dive into the code base. To build the front-end we use webpack so as you add/clean the existing codebase you can
simply run `./node_modules/.bin/webpack --config webpack.config.js --watch` and as you program the hot-reloader will automatically build.

### Pull Requests

* Fill in [the required template](PULL_REQUEST_TEMPLATE.md)
* Do not include issue numbers in the PR title
* Include screenshots and animated GIFs in your pull request whenever possible.
* Follow the [JavaScript](#javascript-styleguide) and [CoffeeScript](#coffeescript-styleguide) styleguides.
* End all files with a newline
* Avoid platform dependent code
* Place requires in the following order:
    * Built in Node Modules (such as `path`)
    * Local Modules (using relative paths)
* Place class properties in the following order:
    * Class methods and properties (methods starting with a `@` in CoffeeScript or `static` in JavaScript)
    * Instance methods and properties

## Styleguides

### Git Commit Messages

* Use the present tense ("Add feature" not "Added feature")
* Use the imperative mood ("Move cursor to..." not "Moves cursor to...")
* Limit the first line to 72 characters or less
* Reference issues and pull requests liberally after the first line
* When only changing documentation, include `[ci skip]` in the commit title
* Consider starting the commit message with an applicable emoji:
    * :art: `:art:` when improving the format/structure of the code
    * :racehorse: `:racehorse:` when improving performance
    * :non-potable_water: `:non-potable_water:` when plugging memory leaks
    * :memo: `:memo:` when writing docs
    * :penguin: `:penguin:` when fixing something on Linux
    * :apple: `:apple:` when fixing something on macOS
    * :checkered_flag: `:checkered_flag:` when fixing something on Windows
    * :bug: `:bug:` when fixing a bug
    * :fire: `:fire:` when removing code or files
    * :green_heart: `:green_heart:` when fixing the CI build
    * :white_check_mark: `:white_check_mark:` when adding tests
    * :lock: `:lock:` when dealing with security
    * :arrow_up: `:arrow_up:` when upgrading dependencies
    * :arrow_down: `:arrow_down:` when downgrading dependencies
    * :shirt: `:shirt:` when removing linter warnings

##### Most of this is copied from the Atom contributing guide, so hats off to them.


text:
### [CVE-2016-1835](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2016-1835)
![](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

Use-after-free vulnerability in the xmlSAX2AttributeNs function in libxml2 before 2.9.4, as used in Apple iOS before 9.3.2 and OS X before 10.11.5, allows remote attackers to cause a denial of service via a crafted XML document.

### POC

#### Reference
- http://www.oracle.com/technetwork/topics/security/linuxbulletinjul2016-3090544.html
- http://www.oracle.com/technetwork/topics/security/ovmbulletinjul2016-3090546.html

#### Github
- https://github.com/ARPSyndicate/cvemon
- https://github.com/asur4s/blog
- https://github.com/asur4s/fuzzing
- https://github.com/chiehw/fuzzing

repository: trickest/cve

repo_name: trickest/cve


text:
### virDisco2
A refined approach for generating decoy reads together with a strategy of resampling from the original findings is proposed in order to estimate diagnostic measures more accurately and to assess the robustness of results. The first step of the new approach is to estimate the statistical distributions from the original mapping file. Next, these distributions are used to simulate two new paired-end read-files (step 2) which are again mapped versus the virus reference genomes (step 3). From the new mapping results, mapping and error rates are calculated (step 4) which can help to assess the robustness of primary results.

### Installation
If you want to install R-packages from GitHub, at first you need to install the R-package **devtools** from CRAN:

```r
install.packages("devtools")
library(devtools)
```
After this, you can install packages from GitHub by using the R-function ```install_github``` and specifying the author and package name. For example, if you want to install the R-package **virDisco2**, just type the following:

```r
install_github("Moritz-Kohls/virDisco2")
```


text:
# phplist-docker
Phplist mailing system in Docker to be used with Openshift

Use the following environment variables to configure phplist

DB_HOST

DB_NAME

DB_USER

DB_PASS

SMTP_HOST

SMTP_PORT

SMTP_USER

SMTP_PASS

Configure timezone with env variable TZ, e.g
TZ="Europe/Helsinki"

repository: AleksTeresh/phplist-docker

repo_name: AleksTeresh/phplist-docker


text:
# git-trunk #

Your ultimate Trunk Based Development (TBD) CLI utility.

Actually, I don't know about you, but we use it here at [Salsita](https://www.salsitasoft.com/).

## Instalation (script) ##
Run
```
wget --no-check-certificate -q -O - https://github.com/salsita/gitflow2/raw/develop/bash/install.sh | sudo bash
```
This will create a few files and a directory in your `cwd` so we recommend
doing it in `/tmp` or similar.

## Installation (manual) ##

1.
2. Set up a Go [workspace](https://golang.org/doc/code.html#Workspaces).
3. Run `go get github.com/tchap/git-trunk`. This will get the sources and install the executable into the workspace.
   Add `$GOPATH/bin` into `PATH` to be able to run the executable directly from the command line.
4. Run `go build` in `bin/hooks/commit-msg`, then use it as a Git [hook](http://git-scm.com/book/en/Customizing-Git-Git-Hooks) in your repo.
5. Copy files from `bash/` directory into your `${PATH}`.

## System Requirements ##

* `git>=2.0.0` in your `PATH`

## License ##

`MIT`, see the `LICENSE` file.

repository: pombredanne/salsaflow

repo_name: pombredanne/salsaflow


text:
DeepPhos
=========
DeepPhos: prediction of protein phosphorylation sites with deep learning
Developer: FenglinLuo  from Health Informatics Lab, School of Information Science and Technology, University of Science and Technology of China

Using pip and virtualenv
=========
virtualenv -p python3 env
source env/bin/activate
pip3 install requirement.txt
python3 predict.py
deactivate

Requirement
=========
    keras==2.0.0
    numpy>=1.8.0
    backend==tensorflow

Related data information need to first load
=========
test data.csv

The input file is an csv file, which includes ptm proteinName, postion, sequences and labels

Predict for your test data
=========
If you want to use the model to predict your test data, you must prepared the test data as an csv file, the firest column is
proteinName,the seconde col: postion, the third col: sequences

The you can run the predict.py

The results is an txt file,like:
     "Q99440"	"3"	"0.12992426753"
    "Q99440"	"13"	"0.0967529118061"
    "Q99440"	"19"	"0.101900868118"
    "Q99440"	"33"	"0.786891698837"
    "Q99440"	"42"	"0.830417096615"
    "Q99440"	"60"	"0.0784499421716"

You can change the corresponding parameters in  main function prdict.py to choose to use the model to predict for general or kinase
prediction

Train with your own data
=====
If you want to train your own network,your input file is an csv fie, while contains 4 columns:
label, proteinName, postion, sequence
label is 1 or 0 represents phoshphorylation and non-phoshphorylation site
You can change the corresponding parameters in  main function train.py to choose to use the model to predict for general or kinase
prediction

Contact
=========
Please feel free to contact us if you need any help<EMAIL_ADDRESS>
Process to run it via Virtualenv
=========
virtualenv -p python3 env

source env/bin/activate

pip3 install -r requirements.txt

pip3 install sklearn

python3 predict.py

deactivate

repository: behrouzsh/deepPhosAPI

repo_name: behrouzsh/deepPhosAPI


text:
#Management Plan

We plan to be in a constant flow of communication in order to make sure that every aspect of the project is being accounted for.
Noah will work mostly on the back-end algorithms as well as helping with the property file configuration.
Yasser will be in charge of configuration of the data as well as the pokerModel engine set up.
Arjun will be in charge of the visualization and GUI as well as helping out with the pokerModel interactions.
Christian will be in charge of checking for edge cases with exceptions in addition to helping out with implementation assignments.

##Timeline
#### Sprint 1 (Test)
- Set up the primary general classes to be used in the MVC layout (Noah)
- Have one functioning casino game (Yasser)
- Have testing structure for the one casino game in order to base future testing on (Christian)
- Focus on implementing a basic view (Arjun)

#### Sprint 2 (Basic)
- Complete the remaining casino games (Noah and Yasser)
- Add element of user interactivity with the game (theme, language, error-support) (Arjun and Christian)

#### Sprint 3 (Complete)
- Integrate the casino games into a seamless experience (Noah and Christian)
- Create more user interactivity (Arjun and Yasser)

repository: yasserelmzoudi/Poker-Suite

repo_name: yasserelmzoudi/Poker-Suite


text:
---
title: Point of Contact
layout: post
date: 2016-01-01 22:48
image: /assets/images/markdown.jpg
headerImage: false
tag:
- Single point of failure
- Knowledge sharing
- Context switching
- Empowerment
category: blog
author: Yogendra Valani
description: Do you have knowledge silos on your team, are you developers interrupted from their work... find out why assigning a POC may help you.
# jemoji: ''
---

## Knowledge Silos
During my time working at Gorkana, I worked on several teams and they all shared a common problem. Many senior developers spent a lot of time
troubleshooting applications for which they had most domain knowledge. This was fine in the short run as problems got solved very quickly,
but when they were on their annual holidays or left the company, this put a strain on the rest of the team to fix issues. We would lose momentum
on our current task and be stressed trying to fix bugs in application we had no previous exposure to. It wasn't much fun for the senior devs either, as they spent most of their time bug fixing.

## Point Of Contact
At 7digital a member of each team is assigned as a Point of Contact (POC). This responsibility is rotated either daily, weekly or by the task being worked on. It is POC's responsibility to answer any queries and solve issues (or at least decide to ask others in the team).

## What are the benefits:

+ __Reduces context switching__ - It has been said that when a pair of developers are interrupted 15 minutes it can take an hour to get back on track. Having a POC means only one person is disturbed and other team members can focus on their tasks.

+ __Knowledge sharing__ - it helps reduce knowledge silos within the team.

+ __Equal responsibility__ - if you are a junior or senior developer, have been working at the company for years or a new starter. You are responsible for the team's software.

+ __Empowerment__ - being approached and asked questions does give you the feeling of importance within the team and company.

## Do's and Don't

* Do make it easy for anyone outside the team to identify who POC is on your team. At 7digital teams have either sign on their Kanban board or a sign hanging above the POC's desk.

* Do ask for help when you don't know the answer to a question.

 If you don't know something, just be honest and say you don't know. Ask other team members, while this may mean disturbing other developers on the team, it ensures knowledge is shared.

* Don't just redirect someone to someone else. Take them to the team member and make sure the query has been answered. Who knows you may get the same question again.

* Do respect POC, having a POC requires team discipline. If you do start having a POC, people will be used to asking the same person questions. If a question comes to you and you are not POC, redirect them to the POC. Even if you know the answer to the question, redirect them. This ensures knowledge is shared, and in future you do not get disturbed.

Follow @DrValani

extension: markdown


text:
# LocoMobileExport
An exporter script for Localise.biz projects for iOS and Android projects

## How to use it?

1. Put ```loco_exporter.sh``` in your project folder.
2. Run script with the desired options

### Android example
Script placed in the app module, not the root folder.
```
# This imports the Swedish strings that are shared or android specific as app default language
shloco_exporter.sh android --key <loco-api-key> --map "values-sv=values" --tag "shared,android" --output "src/se/res"
# This imports the Swedish plural strings that are shared or android specific as app default language
sh loco_exporter.sh android --key <loco-api-key> --map "values-sv=values" --tag "plurals" --plurals true --output "src/se/res"
# This imports the English, Swedish and Norwegian (multilangual project) strings that are shared or android specific as app default language. English as default.
sh loco_exporter.sh android --key <loco-api-key> --map "values-en=values"  --map "values-sv=values-sv" --map "values-no=values-no" --tag "shared, android" --plurals true --output "src/se/res"
```

### iOS example
```
# This imports the Swedish strings that are shared or ios specific, --output (in this case viktklubbapp) is path to directory containing *.lproj relative to where import script is
sh loco_import.sh ios --key <loco-api-key> --map "sv=sv" --tag "shared,ios" --output "viktklubbapp"
# This imports the Swedish plural strings, --output (in this case viktklubbapp) is path to directory containing *.lproj relative to where import script is
sh loco_import.sh ios --key <loco-api-key> --map "sv=sv" --tag "plurals" --plurals true  --output "viktklubbapp"
# This imports the Swedish and Norwegian strings that are shared or ios specific, --output (in this case viktklubbapp) is path to directory containing *.lproj relative to where import script is
sh loco_import.sh ios --key <loco-api-key> --map "sv=sv" --map "no=nb" --tag "shared,ios" --output "viktklubbapp"
```

[Clipy](https://clipy-app.com/) is a great help for having a quick access to code snippets like this one.

## Options

Option | Explanation
------- | -------
{Platform} | `ios` or `android`
--key | API Key from localise.biz
--output | Path to the folder containing localization file. Relative to the script placement.
--map (iOS) | `en_US` on localise.biz exports, `en.lproj` in the xcode project, use `--map 'en_US=en'`, can map as many as you want to meet your project setup.
--map (Android) | use `--map 'values-sv=values'`, can map as many as you want to meet your project setup. If you support multiple languages use like `--map 'values-sv=values-sv' --map 'values-no=values-no'`. Right side is your project value folder. If you do  `--map 'values-sv=values'` you'll be getting Swedish as a default language.
--tags (optional) | Coma separated Loco tags
--plurals (optional) | `true` if resources should be exported as plural resource file

repository: jkwiecien/LocoMobileExport

repo_name: jkwiecien/LocoMobileExport


text:
---
layout: post
title: "OMTN3,OsNAC60"
description: ""
category: genes
tags: [drought resistance, transcription factor, defense, defense response, blast, magnaporthe oryzae, cell death, immunity]
---

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

* **Publication**
    + [Conserved miR164-targeted NAC genes negatively regulate drought resistance in rice](http://www.ncbi.nlm.nih.gov/pubmed?term=Conserved miR164-targeted NAC genes negatively regulate drought resistance in rice%5BTitle%5D), 2014, J Exp Bot.
    + [Osa-miR164a targets OsNAC60 and negatively regulates rice immunity against the blast fungus Magnaporthe oryzae.](http://www.ncbi.nlm.nih.gov/pubmed?term=Osa-miR164a targets OsNAC60 and negatively regulates rice immunity against the blast fungus Magnaporthe oryzae.%5BTitle%5D), 2018, Plant J.

* **Genbank accession number**

* **Key message**
    + Overexpression of OMTN2, OMTN3, OMTN4, and OMTN6 in rice led to negative effects on drought resistance at the reproductive stage.
    + OsNAC60 encodes a transcription factor, over-expression of which enhanced defense responses, such as increased programmed cell death, greater ion leakage, more ROS accumulation and callose deposition, and up-regulation of defense-related genes
    + Osa-miR164a targets OsNAC60 and negatively regulates rice immunity against the blast fungus Magnaporthe oryzae.

* **Connection**

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


text:
The beginnings of a Rust kubernetes client

It's still very experimental and rough aruond the edges.
It has basic support for many common operations, but is far from complete.
An documentation is still very lacking.

If there is a specific API you need feel free to open an issue and I might try to bump it up in priority.
Alternatively, consider submitting a PR.

## Usage

For now, using it feels about like this:

```rust
use kubeclient::prelude::*;

let kube = Kubernetes::load_conf("admin.conf")?;

if kube.healthy()? {
  if !kube.secrets().exists("my-secret")? {
    let output = kube.secrets().get("my-secret")?
    // ...
  }

  for node in kube.nodes().list()? {
    println!("Found node: {}", node.metadata.name);
  }
}
```


text:
> Expands placeholders in a string template based on named or positional arguments. It's also possible to use complex templates including lists and conditionals.

## Installation

```
$ npm install --save @brdu/expand-template
```

## Usage

**Simple templates** accept both named and positional arguments, as well as nested named arguments.

The placeholder format for this template is `%(key)`. Simple templates are also used within conditional templates and list templates.

```
const expand = require('@brdu/expand-template')

let template = 'Hello %(name). How are you doing today?'
let args = { name: 'Buffolander' }
console.info(expand({ template, args }))
// 'Hello Buffolander. How are you doing today?'

template = 'Hello %(1) and %(0). How are you doing?'
args = ['Buffolander', 'Kelly']
console.info(expand({ template, args }))
// 'Hello Kelly and Buffolander. How are you doing?'

template = '...schedule an appointment with Dr. %(md.last_name)'
args = {
  patient: 'any',
  md: {
    first_name: 'John',
    last_name: 'Smith',
  },
}
console.info(expand({ template, args }))
// '...schedule an appointment with Dr. Smith'
```

### Conditional templates

Conditional templates use one or more keys to validate wether to expand variables within that section or to remove the section altogether.

The placeholder format for this template is `[?(keyA, keyB) <simpleTemplate>]`.

```
template = 'Hello world! [?(weather, city) It\'s a %(weather) day in %(city).]'
args = { weather: 'sunny' }
console.info(expand({ template, args }))
// 'Hello world!' // city missing in args; conditional section removed

args = { ...args, city: 'Miami' }
console.info(expand({ template, args }))
// 'Hello world! It\'s a sunny day in Miami.'
```

### List templates

Finally, list templates take an array as input for repeating text sections. The placeholder format for this template is `[[%(key) <simpleTemplate>]]`. On this template `index` is a reserved key, used to print out the position in the array.

```
template = 'Hello there, please [[%(directory) press %(index) for %(department)]].'
args = {
  company: 'Acme',
  directory: [{
    department: 'Sales',
  }, {
    department: 'Support',
  }],
}
console.info(expand({ template, args }))
// 'Hello there, please press 0 for Sales, press 1 for Support.'
```

repository: buffolander/brdu-expand-template

repo_name: buffolander/brdu-expand-template


text:
# Containerised Dockerfile Linter

A containerised instance of [`replicatedhq/dockerfilelint`](https://github.com/replicatedhq/dockerfilelint) version 1.4.0, which is a Dockerfile linter. You can see it in action within this project's CI pipeline.

## Usage

Simply run `dockerfilelint Dockerfile` in the same directory as your Dockerfile

In our pipeline the linter is used as shown below.

```
# Lint our Dockerfile
lint_dockerfile:
  image: theyorkshiredev/dockerfile-linter:latest
  stage: test
  script:
    - dockerfilelint Dockerfile
```

## Build & Release Status

### Build

[![Build Status](https://gitlab.com/TheYorkshireDev/dockerfile-linter/badges/master/build.svg)](https://gitlab.com/TheYorkshireDev/dockerfile-linter/pipelines) [![GitHub tag](https://img.shields.io/github/tag/theyorkshiredev/dockerfile-linter.svg)](https://github.com/theyorkshiredev/dockerfile-linter/releases) [![license](https://img.shields.io/github/license/theyorkshiredev/dockerfile-linter.svg)](https://github.com/theyorkshiredev/dockerfile-linter/blob/master/LICENCE)

### Docker Image

[![Docker Build Status](https://img.shields.io/docker/build/theyorkshiredev/dockerfile-linter.svg)](https://hub.docker.com/r/theyorkshiredev/dockerfile-linter/) [![Docker Automated build](https://img.shields.io/docker/automated/theyorkshiredev/dockerfile-linter.svg)](https://hub.docker.com/r/theyorkshiredev/dockerfile-linter/) [![Docker Pulls](https://img.shields.io/docker/pulls/theyorkshiredev/dockerfile-linter.svg)](https://hub.docker.com/r/theyorkshiredev/dockerfile-linter/) [![Docker Stars](https://img.shields.io/docker/stars/theyorkshiredev/dockerfile-linter.svg)](https://hub.docker.com/r/theyorkshiredev/dockerfile-linter/)

## Contribute

**Please Note:** The development of this project is done within a GitLab repository and uses the integrated GitLab CI. If you wish to contribute in anyway feel free to send pull requests and submit issues on GitLab. This GitHub repository is a mirror of the master branch within GitLab and is intended for users unfamiliar with GitLab.

* [Development Repository](https://gitlab.com/TheYorkshireDev/dockerfile-linter)
* [Report Issues on GitLab](https://gitlab.com/TheYorkshireDev/dockerfile-linter/issues)
* [Repository CI & CD](https://gitlab.com/TheYorkshireDev/dockerfile-linter/pipelines)

repository: TheYorkshireDev/dockerfile-linter

repo_name: TheYorkshireDev/dockerfile-linter


text:
## Gesture Recognition - CNN2D + LSTM Modelling Technique

### Cross Validation Results

repository: anugrahasinha/neuralnetwork

repo_name: anugrahasinha/neuralnetwork


text:
# WOPI Server

A Vendor-neutral Web-application Open Platform Interface (WOPI) gateway for EFSS systems,
to integrate several Office Online platforms including Microsoft Office Online and Collabora Online.

Author: Giuseppe Lo Presti (@glpatcern)

Contributions: Michael DSilva (@madsi1m), Lovisa Lugnegaard (@LovisaLugnegard), Samuel Alfageme (@SamuAlfageme), Ishank Arora (@ishank011)

Initial revision: December 2016

First production version for CERNBox: September 2017

Integration in the CS3 Organisation: April 2020

This project has been presented at the [ownCloud Conference 2017](https://occon17.owncloud.org).
Slides available at [slideshare.net](https://www.slideshare.net/giuseppelopresti/collaborative-editing-and-more-in-cernbox).

## Unit testing

The `/test` folder contains some unit tests for the supported storage interfaces.
No tests are provided (yet) for the core WOPI server, though the test suite aims at covering all
storage access patterns used by the WOPI server.

By default, the local storage is tested. To run the tests, use the standard python unittest arguments:

1. Go to the test folder `cd test`
2. Run all tests: `python3 test_storageiface.py [-v]`
3. Run only one test: `python3 test_storageiface.py [-v] TestStorage.<the test you would like to run>`

### Test against a Reva endpoint:

1. Clone reva (https://github.com/cs3org/reva)
2. Run Reva according to <https://reva.link/docs/tutorials/share-tutorial/> (ie up until step 4 in the instructions).
3. Go to the test folder `cd test`
4. Run the tests: `WOPI_STORAGE=cs3 python3 test_storageiface.py`

### Test against an Eos endpoint:

1. Make sure your Eos instance is configured to accept connections from WOPI as a privileged gateway
2. Go to the test folder `cd test`
3. Configure `wopiserver-test.conf` according to your Eos setup. The provided defaults are valid at CERN.
4. Run the tests: `WOPI_STORAGE=xroot python3 test_storageiface.py`

## Test the `open` workflow with Reva

1. Run Reva as detailed above
2. Login with `reva login`
3. Extract (from the logs) your `x-access-token`
4. Upload an ODF or .md file with the reva CLI (or copy it to Reva's storage, e.g. in `/var/tmp/reva/data/einstein`)
5. From the wopiserver container, execute `wopiopen.py -v READ_WRITE /<your_file.odt> <your_x-access-token>`
6. If the above call is successful, you are given the URL of the application provider, with appropriate parameters (including a WOPI access token) to open your file: open it in a browser to start your edit session via WOPI

For testing collaborative scenarios, repeat the above for each user participating in the collaborative session. Reusing the `x-access-token` is OK, however it is generally not OK to open multiple times the same application provider URL, and different WOPI access tokens are needed instead.

## Run the WOPI server locally for development purposes

1. Install all requirements listed in `requirements.txt`
2. Add log file directory: `sudo mkdir /var/log/wopi/ && sudo chmod a+rwx /var/log/wopi`
3. Create the folder for the wopi config: `sudo mkdir /etc/wopi/ && sudo chmod a+rwx /etc/wopi`
4. Create the files `iopsecret` and `wopiscret` in the folder `/etc/wopi/`, create random strings for the secrets
5. Create a local config file `/etc/wopi/wopiserver.conf` with the needed parameters: start from `docker/etc/wopiserver.conf`, and make sure that at least an application provider URL is configured (e.g. `codeurl` for Collabora)
6. From the WOPI server folder run: `python3 src/wopiserver.py`

repository: SamuAlfageme/wopiserver

repo_name: SamuAlfageme/wopiserver


text:
FogbugzJS
=========

A Javascript wrapper for Fogbugz's XML API

This is a npm package for nodejs written in coffeescript that calls the [FogBugz Api](http://help.fogcreek.com/8202/xml-api)
and returns results in JSON.

###Testing
If you want to test any of the written functions, edit `lib/test/settings.js` with the provided credentials to a Fogbugz site,
edit `test.coffee` with the whatever functions you want to edit,
compile it using `coffee --compile --output lib/test test/`, run `npm install` on the directory (if you haven't already)
and then run `node lib/test/test.js`.

I will be adding a Jasmine/Mocha test suite in the future.

###How to Use
See `test/test.coffee` for an example of how to point the module to a Fogbugz site and to call functions

repository: MasonSchneider/FogbugzJS

repo_name: MasonSchneider/FogbugzJS


text:
# Fastly BigQuery Import
A set of functions, schemas and related information for taking Fastly logs stored on Google Cloud Storage and importing them into Google BigQuery

## Schema
The schema was obtained by importing the initial data into BigQuery using Google Dataprep and exporting the inferred schema:
```
bq show --format=prettyjson elife-fastly:production.generic_cdn | jq '.schema.fields'> schema.js
```
The schema format corresponds to the log format as set in builder terraform scripts here:
https://github.com/elifesciences/builder/blob/master/src/buildercore/terraform.py


text:
# Hierarchy

**ApiOptions**

# Properties

## `<Optional>` provider

**● provider**: *`ProviderInterface`*

*Defined in [types.ts:29](https://github.com/polkadot-js/api/blob/3c8b3d3/packages/api/src/types.ts#L29)*

*__description__*: Transport Provider from rpc-provider. If not specified, it will default to connecting to a WsProvider connecting localhost with the default port, i.e. `ws://<IP_ADDRESS>:9944`

___

## `<Optional>` types

**● types**: * `undefined` | `object`
*

*Defined in [types.ts:34](https://github.com/polkadot-js/api/blob/3c8b3d3/packages/api/src/types.ts#L34)*

*__description__*: Additional types used by runtime modules. This is nessusary if the runtime modules uses types not available in the base Substrate runtime.

___

repository: NiluK/api

repo_name: NiluK/api


text:
### [CVE-2022-26982](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2022-26982)
![](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

** DISPUTED ** SimpleMachinesForum 2.1.1 and earlier allows remote authenticated administrators to execute arbitrary code by inserting a vulnerable php code because the themes can be modified by an administrator. NOTE: the vendor's position is that administrators are intended to have the ability to modify themes, and can thus choose any PHP code that they wish to have executed on the server.

### POC

#### Reference
- http://packetstormsecurity.com/files/171486/SimpleMachinesForum-2.1.1-Remote-Code-Execution.html

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