text:
# MexPub Demo
# Demo Web Application Metadata extraction from German scientific papers

# Please follow the steps for Docker container creation.

1. Install Docker in local machine (Preferably with default Linux container.)

2. Copy the final model file (model_final.pth) inside the /app/models/final folder.

3. In the folder path of the Dockerfile, run docker build to create the docker image of the project with a desired image name. Find below an example to create a docker image of our application with the image name as 'my-mexpub-app' (all in small letters). The dot at the end of the command represents that the Dockerfile can be found in the current directory.

docker build -t my-mexpub-app .

4. Run the newly creted (latest) image as a container with a suitable name. The below example uses container name as 'mexPubContainer' and used the latest application image. Also the Docker cotainer 5000 port is mapped to local machines 5000 port. Which means all the traffics coming to the local networks 5000 port will be redirected to container's 5000 port.

docker run -it -p 5000:5000 --name mexPubContainer my-mexpub-app:latest

5. Hit http://localhost:5000 in the browser to access the appliction.


text:
# F2CNN
Speech feature extraction using Gammatone FilterBank and CNN.\
The project uses TIMIT database and VTR Formants database as resources for the CNN.\

## Usage
**Use the ```configure.py``` script with python3, or run ```python3 f2cnn.py --configure/-c``` to initialize a few parameters for the program.**\
Run it every time one of the project parameters need to change (Sampling rates, cutoff frequencies, numbers of channels, number of classes...).\
Use the f2cnn.py **Python3** script as en entrance like in the examples below, or use the functions in the scripts/ directories in your own.\

## Available commands:\
```python3 f2cnn.py -h/--help``` \
-> gives some help and tips after any argument.

#### Data processing scripts
``` python3 f2cnn.py prepare all ``` \
-> prepares all the data for CNN usage (may take a few minutes and requires a lot of disk space (~50GB if full Timit/vtr database).\

``` python3 f2cnn.py prepare organize``` \
-> prepares Project Structure with Timit and VTR databases organized as mentionne din the "REQUIRED STRUCTURE" section down below.\

``` python3 f2cnn.py prepare filter ``` \
-> prepares Filtered outputs from the gammatone filterbank\
Saves all the outputs as '.GFB.npy' files.
``` python3 f2cnn.py prepare envelope```\
_Optional command:_ ```--cutoff FREQ ``` for a low pass filtering on the envelopes with a cutoff of FREQ Hz  \
-> prepares extracted envelope numpy array files using a low pass filter at 50Hz\
Saves all outputs as '.ENV1.npy' files. The 1 means that the method used is the first one, should there be more in the future.

``` python3 f2cnn.py prepare label ``` \
-> prepares CNN output labels from the previous files, using VTR .FB files, .PHN files and filenames.\
Saves it as a trainingData/label_data.csv file.\
``` python3 f2cnn.py prepare input```\
_Optional command:_ ```--cutoff FREQ ``` specifies the cutoff frequency for the output file(should be the same as the envelopes)\
-> prepares CNN input data matrices from latest extracted envelopes, and saves the whole as a NxDOTS_PER_INPUTx_NB_CHANNELS ndarray trainingData/input_data.npy.\
If CUTOFF is used, will save the file as trainingData/input_data_LPFX.npy with X the frequency.\
Also makes a backup as trainingData/last_input_data.npy, just in case.

#### Data plotting scripts
```python3 f2cnn.py plot gtg --file/-f *PathToAWAVFileFile*```\
-> Plots a spectrogram like representation of GammaTone FilterBank output.
#### CNN related scripts
```python3 f2cnn.py cnn train```\
 _Optional commands:_
```--input *PathToInputDataFile*``` allows the use of a specific input data file \
```--label *PathToLabelCSVFile*``` allows the use of a specific label data file\
-> Trains a CNN using the given input data file, or by default trainingData/input_data.npy, also uses the default labe_data.csv file. \
```python3 f2cnn.py cnn eval --file *PathToAWAVFile*``` \
-> Uses the last_trained_model keras model to predict Rising or Falling for F2 on all frames of the given .WAV file, plotting results in graphs/FallingOrRising directory. \
```python3 f2cnn.py cnn evalrand``` \
_Optional command:_ ```--count N``` only uses N randomly selected files
-> Same as the above, but evaluates randomly all the VTR related TIMIT .WAV files.\
```python3 f2cnn.py cnn evalnoise```\
_Optional command:_ ```--noise SNRdB``` specifies a Signal to Noise Ratio in dB for the new WAV file, that is saved inside 'OutputWavFiles/addedNoise'.\

_Optional commands for the last 3 functions:_ \
```--model *PathToAKerasModel*``` allows the use of a specific keras model(default:'last_trained_model')\
```--cutoff FREQ``` allows the use of a FREQ Hz cutoff Low Pass Filter on envelope extraction

## Required structure
There is a certain way the project directories should be organized before running ```prepare organize``` or ```prepare all```:\
project_root/\
-scripts/   -> This file's directory\
**-resources/**\
--f2cnn/    -> The output directory (should be created automatically)\
---TRAIN/\
---TEST/\
**--TIMIT/**    -> TIMIT database as is, **including TEST and TRAIN directories**\
**--VTR/**      -> VTR FORMANTS files as is, **including TEST and TRAIN subdirectories**\
So make sure to put the TIMIT(the one including TEST and TRAIN directories) and VTR directories in the resources directory.
## Dependencies
Compatibility with Windows is not garanteed.\
This project requires the installation of:
- numpy - 1.14.5
- matplotlib - 2.2.2
- keras - 2.2.0
- scipy - 1.1.0
- sphfile - 1.0.0

Also, some packages are needed for the training:
There are two cases:
##### 1. You will use your CPU
* tensorflow with pip
##### 2. You will use a GPU (preferably from NVIDIA)
* tensorflow-cuda (or tensorflow-gpu in PIP) - 1.9.0
* cuda  -   9.2.148-1  | installed with the nvidia cuda toolkit 9.2

If you have any issues or suggestions, you can send an email at<EMAIL_ADDRESS>.

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
## Day 10 - HackingWithSwift - 100DaysOfSwiftUI Challenge

> Any fool can write code that a computer can understand, but good programmers write code that humans can understand. - Martin Fowler

### Classes

Today I learnt about:

- Creating your own classes
- Class inheritence
- Overriding methods
- Final classes
- Copying objects
- Deinitializers
- Mutability

The summary of the entire day was:

- Classes and structs are similar, in that they can both let you create your own types with properties and methods.
- One class can inherit from another, and it gains all the properties and methods of the parent class. It’s common to talk about class hierarchies – one class based on another, which itself is based on another.
- You can mark a class with the ```final``` keyword, which stops other classes from inheriting from it.
- Method overriding lets a child class replace a method in its parent class with a new implementation.
- When two variables point at the same class instance, they both point at the same piece of memory – changing one changes the other.
- Classes can have a deinitializer, which is code that gets run when an instance of the class is destroyed.
- Classes don’t enforce constants as strongly as structs – if a property is declared as a variable, it can be changed regardless of how the class instance was created.

**That's All for the Day 10 of 100DaysOfSwiftUI!**

license: MIT

gha_license_id: MIT


text:
# Migrating to v1.0.0

## refs

Each component exposes refs to form control DOM elements of the component.

For components that wrap a single element (`<Input />`, `<Select />`, `<Textarea />` etc.) the `ref` is named "`element`".

```jsx
// Component with single control
queryInputElement = searchInput.element.focus();
```

For components that wrap multiple form elements (`<CheckboxGroup />`, `<RadioGroup />`) the ref is named `elements`, this is an object where each form control is keyed by the `value` for that element.

**Breaking change:** These elements were previously stored as seperate refs on the component, named "`element-`" and then the name of the key for that element, e.g. `element-foo`.

```jsx
// Components with multiple controls

// Old
termsCheckboxElement = annoyingCheckboxes.element-agree-to-terms;

// New
termsCheckboxElement = annoyingCheckboxes.elements['agree-to-terms'];
```

## Checkbox component

**Breaking change:** The expected props for this component have been changed for consistency with the other components.

```jsx
// Old
Checkbox.propTypes = {
    ...commonProps,
    label: PropTypes.string,    // label for the checkbox
    rowLabel: PropTypes.string, // label for the row
    value: PropTypes.bool       // checkbox checked
};

// New:
Checkbox.propTypes = {
    ...commonProps,
    label: PropTypes.string,      // label for the row
    valueLabel: PropTypes.string, // label for the checkbox
    value: PropTypes.bool         // checkbox checked
};
```

## Input and Textarea components

It is now possible to modify when the `<Input />` and `<Textarea />` components notify changes in their value.

You can also specify a delay to wait before the change in value is triggered. This is useful to prevent validation running on every keystroke.

By default, we update with both `change` and `blur` events, but wait for a half-second after the last keystroke before triggering a change event.

Props:

```
  updateOnBlur   // default: true
  updateOnChange // default: true

  blurDebounceInterval   // default: 0
  changeDebounceInterval // default: 500
```

repository: twisty/formsy-react-components

gha_language: TypeScript

repo_name: twisty/formsy-react-components


text:
# Installing hoppie-sasl
## Installation from source
The repository for hoppie-sasl contains the code used, but does not contain the libraries required for running it with x-plane. As a result, some simple installation is required:

* Grab the latest SASL v3 from http://1-sim.com/files/SASL-v3.zip
* Extract this to ``X-Plane/Resources/plugins/hoppie-sasl/``, ensuring you have the path ``X-Plane/Resources/plugins/hoppie-sasl/64/win.xpl``
* Download the hoppie-sasl repository as a zip, and extract it to ``X-Plane/Resources/plugins/hoppie-sasl/data/modules/``, ensuring you have the path ``X-Plane/Resources/plugins/hoppie-sasl/data/modules/main.lua``

Code instructions, needs library instructions to be added

repository: magknight/hoppie-sasl

gha_language: Lua

repo_name: magknight/hoppie-sasl


text:
# Panax arboreus L.f. SPECIES

#### Status
SYNONYM

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

#### Published in
Fl. ins. austr. 75. 1786 "<I>arboreum</I>" (non L. 1774)

#### Original name
null

### Remarks
null

repository: mdoering/backbone

path: /life/Plantae/Magnoliophyta/Magnoliopsida/Apiales/Araliaceae/Neopanax/Neopanax arboreus/ Syn. Panax arboreus/README.md

repo_name: mdoering/backbone


text:
==================

## Section 5 - Authorization with Spring Expressions

- **Video 1** - `Authorization With Expressions - by URL`
- **Video 2** - `Authorization With Expressions - in Page`
- **Video 3** - `Authorization With Expressions - on Method`

## Section References
- [List of Common Expressions](http://static.springsource.org/spring-security/site/docs/3.1.x/reference/el-access.html#el-common-built-in)
- [Web Security Expressions](http://static.springsource.org/spring-security/site/docs/3.1.x/reference/el-access.html#el-access-web)
- [Method Security Expressions](http://static.springsource.org/spring-security/site/docs/3.1.x/reference/el-access.html#d0e5600)

## Additional Notes
- the [last project of this Section](https://github.com/eugenp/course/tree/master/section5/s5_vid3_done) is **the completed version** of the [Project for Video 3](https://github.com/eugenp/course/tree/master/section5/s5_vid3)

repository: PacktPublishing/Spring-Security

gha_language: JavaScript

repo_name: PacktPublishing/Spring-Security


text:
# Hadoop_map_reduce_Equijoin

Implemented a hadoop map-reduce program with 4 slaves for Equijoin Operation

Tips:
1. Create jar file of the .java file.

Command to execute:
sudo -u <username> <path_of_hadoop> jar <name_of_jar> <class_with_main_function> <HDFSinputFile> <HDFSoutputFile>

Mapper Class:

1. Trim the line (remove all extra spaces)
2. Take the JoinColumn of the line and pass the value which refers to that key to the reducer

Reducer:

1. Make 2 Lists, one for each table, and for each key sperate the values into appropriate lists.
2. Check whether there's only 1 record in R list or just 1 in S list. This means it cant be joined. If not , goto step 3.
3. For each value in "R" List, print the corresponding "S" value to the context.

Driver:

1. Set the mapper and reducer class.
2. Set the appropriate output key and value class types
3. Set the jar by class name.
4. Set the input and output format classes.
5. Give the I/P and O/P path as args.
6. Wait for job completition


text:
# SBD: Simultaneous Block Diagonalization of noncommuting matrices

This repository is part of the paper: Y. Zhang, V. Latora, and A. E. Motter, _Unified treatment of synchronization patterns in generalized networks with higher-order, multilayer, and temporal interactions_, [Commun. Phys. 4, 195 (2021)](https://doi.org/10.1038/s42005-021-00695-0).

SBD is a simple and efficient algorithm for finding a (often finest) simultaneous block diagonalization of multiple matrices.
The algorithm works by finding the eigendecomposition of a _single_ matrix, which is a random linear combination of all the matrices to be simultaneously block diagonalized.
The current algorithm is inspired by the results presented in K. Murota et al. Jpn. J. Ind. Appl. Math 27, 125–160 (2010).
For an efficient algorithm that also guarantees the optimal SBD, see [here](https://github.com/y-z-zhang/net-sync-sym).

The repository includes:

1. `sbd.py`

  _Python implementation of the SBD algorithm._

2. `sbd.m`

  _MATLAB implementation of the SBD algorithm._

3. `random_examples.m`

  _Simple example demonstrating the use of the SBD algorithm to random matrices with predefined common block structure._

For an example application of the SBD code, see [this](https://github.com/asalova/hypergraph-cluster-sync) nice Python package developed by A. Salova, which provides a unified treatment of cluster synchronization on hypergraphs.

repository: FigTop/SBD

repo_name: FigTop/SBD


text:
# Elasticsearch Cheatsheet

- [Using cURL](#using-curl)
  - [Cluster Health](#health-with-curl)
  - [View Indices](#view-indices)
  - [Create Index](#create-index)
  - [Ingest](#ingest-data)
  - [Search](#search)
    - [Using the Search API](#using-the-search-api)
  - [Reindex](#reindex-using-curl)
  - [Update Replica Shards](#update-replicas-curl)
  - [Delete](#delete)
  - [Snapshots](#snapshots-with-curl)
  - [Restore Snapshots](#restore-snapshots-with-curl)
  - [Tasks API](#tasks)
- [using Python](python-elasticsearch.md#python-library)
  - [Ingest](python-elasticsearch.md#ingest-using-python)

## Using Curl

### Health with Curl

View the cluster health on a cluster level:

```
$ curl -s -XGET "http://<IP_ADDRESS>:9200/_cluster/health?pretty"
```

View the cluster health on a index level:

```
$ curl -XGET "http://<IP_ADDRESS>:9200/_cluster/health?level=indices&pretty"
```

Check all indices in yellow status:

```
$ curl -s -XGET 'http://<IP_ADDRESS>:9200/_cat/indices?v&health=yellow'
```

View recovery process:

```
curl -s -XGET 'http://<IP_ADDRESS>:9200/_cat/recovery?detailed&h=index,stage,time,bytes_percent'
```

### View Indices

View all your indices:

```
$ curl -s -XGET 'http://<IP_ADDRESS>:9200/_cat/indices?v'
```

View all indices from 2019.05:

```
$ curl -s -XGET 'http://<IP_ADDRESS>:9200/_cat/indices/*2019.05*?v'
```

View all your indices, sort by size:

```
$ curl -s -XGET 'http://<IP_ADDRESS>:9200/_cat/indices?v&s=pri.store.size'
```

View all indices, but return only the index.name value:

```
$ curl -s -XGET 'http://<IP_ADDRESS>:9200/_cat/indices?v&h=index'
```

### Create Index

Create a Index:

```
$ curl -XPOST -H "Content-Type: application/json" "http://localhost:9200/my-test-index
```

Create a Index with 5 Primary Shards, 1 Replica Shard and Refresh Interval of 30 seconds:

```
$ curl -XPUT -H "Content-Type: application/json" \
  http://localhost:9200/my-foobar-index \
  -d '{"index": {"number_of_shards":"5","number_of_replicas": 1, "refresh_interval": "30s"}}'
```

If you want to manually refresh your index to see the data:

```
$ curl -XPOST -H "Content-Type: application/json" "http://localhost:9200/my-foobar-index/_refresh"
```

### Update Index Settings

Documentation:
- https://www.elastic.co/guide/en/elasticsearch/reference/current/indices-update-settings.html

View the index settings:

```
$ curl -XGET -H "Content-Type: application/json" "http://<IP_ADDRESS>:9200/my-foobar-index/_settings?pretty"
```

Update the settings, disable refresh for example:

```
$ curl -XPUT -H "Content-Type: application/json" "http://<IP_ADDRESS>:9200/my-foobar-index/_settings" -d '{"index": {"refresh_interval": "-1"}}'
```

### Ingest Data

### Search

**Searcing with query parameters:**

Name = Kevin

```
curl -XGET 'http://localhost:9200/myfirstindex/_search?q=name:kevin&pretty'
```

Age < 30

```
curl -XGET 'http://localhost:9200/myfirstindex/_search?q=age:<30&pretty'
```

Name = Michelle AND age < 30

```
curl -XGET 'http://localhost:9200/myfirstindex/_search?q=name:michelle%20AND%20age:<30&pretty'
```

#### Using the Search API

Search for the latest ingested document

```
curl -H 'content-type: application/json' -XPOST http://localhost:9200/myfirstindex/_search?pretty -d '{"size": 1, "sort": { "@timestamp": "desc"}, "query": {"match_all": {} }}'
 ```

### Reindex using Curl

Reindex source index to target index:

```
$ curl -XPOST -H 'Content-Type: application/json' 'http://<IP_ADDRESS>:9200/_reindex' -d '
  {
    "source": {
      "index": ["my-metrics-2019.01.03"]
    },
    "dest": {
      "index": "archived-metrics-2019.01.03",
    }
}'
```

Reindex multiple source indices to one target index:

```
$ curl -XPOST -H 'Content-Type: application/json' 'http://<IP_ADDRESS>:9200/_reindex' -d '
  {
    "source": {
      "index": ["my-metrics-2019.01.03", "my-metrics-2019.01.04"]
    },
    "dest": {
      "index": "archived-metrics-2019.01",
    }
}'
```

Reindex only missing documents from source to target index. You will receive conflicts for existing documents, but the proceed value will ignore the conflicts.

```
$ curl -XPOST -H 'Content-Type: application/json' 'http://<IP_ADDRESS>:9200/_reindex' -d '
  {
    "conflicts": "proceed",
    "source": {
      "index": ["my-metrics-2019.01.03"]
    },
    "dest": {
      "index": "archived-metrics-2019.01.03",
      "op_type": "create"
    }
}'
```

Reindex filtered data to a target index, by using a query:

```
$ curl -XPOST -H 'Content-Type: application/json' 'http://<IP_ADDRESS>:9200/_reindex' -d '
  {
    "source": {
      "index": "my-metrics-2019.01.03",
      "type": "log",
      "query": {
        "term": {
          "status": "ERROR"
        }
      }
    },
    "dest": {
      "index": "archived-error-metrics-2019.01.03"
    }
}'
```

Reindex the last 500 documents based on timestamp to a target index:

```
$ curl -XPOST -H 'Content-Type: application/json' 'http://<IP_ADDRESS>:9200/_reindex' -d '
  {
    "size": 500,
    "source": {
      "index": "my-metrics-2019.01.03",
      "sort": {
        "timestamp": "desc"
      }
    },
    "dest": {
      "index": "archived-last500-metrics-2019.01.03",
      "op_type": "create"
    }
}'
```

Reindex only specific fields to a target index:

```
$ curl -XPOST -H 'Content-Type: application/json' 'http://<IP_ADDRESS>:9200/_reindex' -d '
  {
    "source": {
      "index": "my-metrics-2019.01.03",
      "_source": [
        "response_code",
        "request_method",
        "referral"
      ]
    },
    "dest": {
      "index": "archived-subset-metrics-2019.01.03"
    }
}'
```

### Update Replicas Curl

Increase/Decrease the number of Replica Shards using the Settings API:

```
curl -XPUT -H 'Content-Type: application/json' 'http://<IP_ADDRESS>:9200/my-index-2018.12.31/_settings' \
  -d '{"index": {"number_of_replicas": 1, "refresh_interval": "30s"}}'
```

### Delete

References:

- [Delete API](https://www.elastic.co/guide/en/elasticsearch/reference/current/docs-delete.html)
- [Delete by Query](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/docs-delete-by-query.html)

### Delete Index:

```
$ curl -XDELETE http://<IP_ADDRESS>:9200/my-index-2018.12.31
```

### Delete Documents on Query:

We would like to delete all documents that has `"os_name": "Windows 10"`

```
curl -XPOST 'http://elasticsearch:9200/weblogs/_delete_by_query?pretty' -d '
{
  "query": {
    "match": {
      "os_name": "Windows 10"
    }
  }
}'
```

If routing is provided, then the routing is copied to the scroll query, limiting the process to the shards that match that routing value:

```
$ curl -XPOST 'http://elasticsearch:9200/people/_delete_by_query?routing=1
{
  "query": {
    "range" : {
        "age" : {
           "gte" : 10
        }
    }
  }
}
```

By default _delete_by_query uses scroll batches of 1000. You can change the batch size with the scroll_size URL parameter:

```
$ curl -XPOST 'http://elasticsearch:9200/weblogs/_delete_by_query?scroll_size=5000
{
  "query": {
    "term": {
      "category": "docker"
    }
  }
}
```

### Snapshots with Curl

View snapshot repositories:

```
curl -s -XGET 'http://<IP_ADDRESS>:9200/_snapshot?format=json'
{"cs-automated":{"type":"s3"},"es-index-backups":{"type":"s3"...
```

View snapshots under repository (table view):

```
curl -s -XGET 'http://<IP_ADDRESS>:9200/_cat/snapshots/index-backups?v'
# id, status, start_epoch, start_time, end_epoch, end_time, duration, indices, successful_shards, failed_shards, total_shards
snapshot_2019.05.23 SUCCESS
..
```

View snapshots under repository (json view):

```
curl -s -XGET 'http://<IP_ADDRESS>:9200/_cat/snapshots/es-index-backups?format=json'
[{"id":"snapshot_2019.05.23","status":"SUCCESS"....
```

Create a snapshot with all indices and wait for completion:

```
curl -XPUT -H 'Content-Type: application/json' 'http://<IP_ADDRESS>:9200/_snapshot/index-backups/my-es-snapshot-latest?wait_for_completion=true'
```

View snapshot status:

```
curl -s -XGET 'http://<IP_ADDRESS>:9200/_cat/tasks?detailed'
# cluster:admin/snapshot/create ..
```

View snapshot info:

```
curl -s 'http://<IP_ADDRESS>:9200/_snapshot/es-index-backups/my-es-snapshot-latest' | jq .
```

### Restore Snapshots with Curl

Restore with original names:

```
curl -XPOST -H 'Content-Type: application/json' 'http://<IP_ADDRESS>:9200/_snapshot/es-index-backups/test-snapshot-latest/_restore' -d '
{
  "indices": [
    "kibana_sample_data_ecommerce", "kibana_sample_data_logs"
  ],
  "ignore_unavailable": false,
  "include_global_state": false
}'
```
```
curl 'http://<IP_ADDRESS>:9200/_cat/indices/kibana_sample*?v'
health status index
green  open   kibana_sample_data_logs
green  open   kibana_sample_data_ecommerce
```

Restore and rename:

```
curl -XPOST -H 'Content-Type: application/json' 'http://<IP_ADDRESS>:9200/_snapshot/es-index-backups/test-snapshot-latest/_restore' -d '
{
  "indices": [
    "kibana_sample_data_ecommerce", "kibana_sample_data_logs"
  ],
  "ignore_unavailable": false,
  "include_global_state": false,
  "rename_pattern": "(.+)",
  "rename_replacement": "restored_index_$1"
}'
```
```
curl 'http://<IP_ADDRESS>:9200/_cat/indices/*restored*?v'
health status index
green  open   restored_index_kibana_sample_data_ecommerce
green  open   restored_index_kibana_sample_data_logs
```

Restore and rename with a different name pattern:

```
curl -XPOST -H 'Content-Type: application/json' 'http://<IP_ADDRESS>:9200/_snapshot/es-index-backups/test-snapshot-latest/_restore' -d '
{
  "indices": [
    "kibana_sample_data_ecommerce", "kibana_sample_data_logs"
  ],
  "ignore_unavailable": false,
  "include_global_state": false,
  "rename_pattern":
  "kibana_sample_data_(.+)",
  "rename_replacement": "restored_index_$1"
}'
```
```
curl 'http://<IP_ADDRESS>:9200/_cat/indices/*restored*?v'
health status index
green  open   restored_index_ecommerce
green  open   restored_index_logs
```

### Tasks

View tasks in table format:

```
$ curl -s -XGET 'http://<IP_ADDRESS>:9200/_cat/tasks?v&detailed'
action                         task_id                          parent_task_id                   type      start_time    timestamp running_time ip            node    description
cluster:monitor/nodes/stats    DzSOmlH3RRaLGA33QJl3Bg:137161492 -                                transport<PHONE_NUMBER>463 23:36:20  1.1s         x.x.x.x DzSOmlH
cluster:monitor/nodes/stats[n] C50akcLqScuJDwLx2nk9UA:95915234  DzSOmlH3RRaLGA33QJl3Bg:137161492 netty<PHONE_NUMBER>464 23:36:20  1.1s         x.x.x.x  C50akcL
indices:data/write/bulk        yZXq8fZWRjiurCvtO7tSpQ:92155276  -                                transport<PHONE_NUMBER>565 23:36:21  23ms         x.x.x.x yZXq8fZ requests[83], indices[logstash-logs-2019.08]
```

View tasks in json format:

```
$ curl -s -XGET 'http://<IP_ADDRESS>:9200/_tasks?detailed&format=json'
{"nodes":{"xx":{"name":"xx","roles":["data","ingest"],"tasks":{"xx:xx":{"node":"xx","id":xx,"type":"transport","action":"cluster:monitor/nodes/stats"
```

View tasks in json format and pretty print:

```
$ curl -s -XGET 'http://<IP_ADDRESS>:9200/_tasks?detailed&pretty&format=json'
{
  "nodes" : {
    "xx" : {
      "name" : "xx",
      "roles" : [ "data", "ingest" ],

```

View all tasks relating to snapshots being created:

```
$ curl -s -XGET 'http://<IP_ADDRESS>:9200/_tasks?detailed=true&pretty&actions=cluster:admin/snapshot/create'
```

View all tasks relating to write actions:

```
$ curl -s -XGET "http://<IP_ADDRESS>:9200/_tasks?detailed=true&pretty&actions=indices:*/write*"
{
  "nodes" : {
    "DzSOmlH3RRaLGA33QJl3Bg" : {
      "name" : "xx",
      "roles" : [ "data", "ingest" ],
      "tasks" : {
        "nodeX:idY" : {
          "node" : "nodeX",
          "id" : idY,
          "type" : "netty",
          "action" : "indices:data/write/bulk[s]",
          "status" : {
            "phase" : "waiting_on_primary"
          },
          "description" : "requests[5], index[logstash-logs-2019.08]",
          "start_time_in_millis" :<PHONE_NUMBER>806,
          "running_time_in_nanos" : 65730,
          "cancellable" : false,
          "parent_task_id" : "nodeA:idZ",
          "headers" : { }
        }
      }
    },
```

Create a Task:

```
$ curl -XPOST -H 'Content-Type: application/json' 'http://<IP_ADDRESS>:9200/_reindex?wait_for_completion=false' -d '{"source": {"index": "metricbeat-2019.*"}, "dest": {"index": "metricbeat-2019"}}'
{"task":"-thJvCFgQlusd2vVFZGOfg:26962"}
```

View Task Status by TaskId:

```
$ curl http://localhost:9200/_tasks/-thJvCFgQlusd2vVFZGOfg:26962?pretty
{
  "completed" : true,
  "task" : {
    "node" : "-thJvCFgQlusd2vVFZGOfg",
    "id" : 26962,
    "type" : "transport",
    "action" : "indices:data/write/reindex",
...
  }
}
```

Some of the other actions:

```
"action" : "cluster:monitor/tasks/lists
"action" : "cluster:monitor/tasks/lists
"action" : "cluster:monitor/nodes/stats"
"action" : "cluster:admin/snapshot/create"
"action" : "internal:cluster/snapshot/update_snapshot_status"
"action" : "indices:data/read/search
 - "description": (context of query)
"action" : "indices:data/read/msearch"
"action" : "indices:data/write/bulk
```

### External Resources
- http://elasticsearch-cheatsheet.jolicode.com/

repository: ruanbekker/cheatsheets

gha_language: Python

repo_name: ruanbekker/cheatsheets


text:
Decisions made:
1. Due to no longer using a third API, we have decided to use the database to conduct our calculations
2. The MySQL database with full calculation functionality is nearly complete, and is currently ready for implementation into the main project
- Giovanni will be in charge of database development, and Rahul and Jan will now be responsible for connecting it to the server-side code
3. Test coverage is still being developed and the % coverage is still not ideal. Alin and Nik will be taking up this task to raise the code coverage

Discussion:
1. Database
- MySQL triggers are being used for calculations, we have decided to make the triggers non-filtering (i.e. assume perfect input parameters from the server side)
- Establish only a few tables for the server communication, the rest being record keeping and calculation
- Extensive testing done on the database triggers will have to be done, as now all our calculations and record keeping will rely on them
- Future implementation of more features (solar panels, tree planting, etc.) will require a more complex schema and further design on the database design, which Gio will be developing for the following weeks
2. Testing
- Alin has chosen to take up the task of most of the testing, along with some help from Nik
- Jacoco will be used for much of our server testing
- This will be set as a priority for us, as falling behind on testing could potentially result in us developing on bugged code
3. GUI design
- We have decided to add statistics features to the application, which show your personal statistics on opening the app
- Atanas is the main GUI developer along with help from Zhao (to connect the client to the server)
- Jan will supplement the client side development along with connection to the server
4. Linking GUI
- Only still partially developed, but just enough so that other dependent tasks can continue tasks
- Jan will continue to work on this, with the Database now making the calculations this adds one more that information needs to go through to get to the GUI
5. Misc.
- Much work will need to be done this week in preparation for the demo coming up. All the features must be extensively tested both manually and through Jacoco and Alin's other specialist debugging and testing tools

repository: aaron-c-zhao/GoGreen

repo_name: aaron-c-zhao/GoGreen


text:
# TL;DR

Add a user to a VM with MFA configured

## Overview

See https://github.com/uc-cdis/cdis-wiki/blob/master/ops/onCall/Library/SshStuff.md for how to configure a VM ssh with MFA.

The setup is we have a public VM with ssh access, and we want to add users to the VM with ssh authorized keys and MFA setup.

## Use

### gen3 usermfa add userFolder/ mfaHostLabel

The input is a user folder:
```
userFolder/
    info.json
    authorized_keys
```

The `mfaHostLabel` argument is either the IP address or hostname
at which the user accesses the VM.

Ex:
```
gen3 usermfa frickjack/ host.name
```

Note that the `authorized_keys` file only accepts `openssh` format public keys: https://tutorialinux.com/convert-ssh2-openssh/

### gen3 usermfa qr label secret

Wrapper around qr-encode - outputs

```
gen3 usermfa 'frickjack@vmname' 'secret secret bla bla' > frickjackMfaQr.png
```

### gen3 usermfa testsuite

Run a test suite - not yet integrated with `gen3 test suite` -
creates (and deletes on success) a unix user and requires sudo

```
gen3 usermfa testsuite
```

repository: uc-cdis/cloud-automation

gha_language: Shell

repo_name: uc-cdis/cloud-automation


text:
[TOC]

# Overview

- A subset of artificial intelligence
- often uses statistical techniques to give computers the ability to
  *learn* (i.e., progressively improve performance on a specific task)
  with data, without being explicitly programmed.
    + data-driven predictions or decisions
- The term was coined in 1959 by Arthur Samuel
    + Evolved from the study of pattern recognition and computational
      learning theory in artificial intelligence

# State of the Art

- https://paperswithcode.com/

# Courses

- http://cs231n.stanford.edu/
    + https://cs231n.github.io/

# Tasks

- **Supervised Learning**: the computer is presented with example inputs
  and their desired outputs
    + **Semi-supervised learning**: the computer is given only an
      incomplete training signal: a training set with some of the target
      outputs missing
    + **Active learning**: the computer can only obtain training labels
      for a limited set of instances
    + **Reinforcement learning**: training data (in form of rewards and
      punishments) is given only as feedback to the program's actions in
      a dynamic environment, such as driving a vehicle or playing a game
      against an opponent
- **Unsupervised learning**: no labels are given to the learning
  algorithm, leaving it on its own to find structure in its input.
    + can be a goal in itself (discovering hidden patterns in data)
    + means towards an end (feature learning)
    + use cases
        * recommendations

# Applications

- **Classification**
    + inputs are divided into two or more classes (multiclass
      classification, and the learner must produce a model that assigns
      unseen inputs to one or more (multi-label classification) of
      these classes.
    + typically in a supervised manner
    + e.g. spam filtering
- **Regression**
    + produce a function that describes relationships between inputs and
      outputs (variable relationship)
        * prediction and forecasting
    + a supervised problem
    + the outputs are continuous rather than discrete
- **Clustering**
    + a set of inputs is to be divided into groups
    + unlike in classification, the groups are not known beforehand =>
      unsupervised task
        * different groups of customers
    + explores the datasets
- **Density estimation**
    + finds the distribution of inputs in some space
    + Gaussian Discriminant Analysis (GDA): Quadratic Discriminant
      Analysis (QDA), Linear Discriminant Analysis (LDA)
- **Dimensionality reduction**
    + simplifies inputs by mapping them into a lower-dimensional space
    + Principal Component Analysis (PCA)

# Feature

## Introduction

- A feature is an individual measurable property or characteristic of a
  phenomenon being observed.
- Choosing informative, discriminating and independent features is a
  crucial step for effective algorithms in pattern recognition,
  classification and regression.
- Features are usually numeric, but structural features such as strings,
  and graphs are used in syntactic pattern recognition.
- The concept of feature is related to that of independent variable used
  in statistical techniques such as linear regression.

## Examples

- In character recognition, features may include histograms counting the
  number of black pixels along horizontal and vertical directions,
  number of internal holes, stroke detection and many others.
- In speech recognition, features fro recognizing phonemes can include
  noise ratios, length of sounds, relative power, filter matches and
  many others.
- In spam detection algorithms, features may include the presence or
  absence of certain email headers, the email structure, the language,
  the frequency of specific terms, the grammatical correctness of the
  text.
- In computer vision, there are a large number of possible features,
  such as edges and objects.

## Classification

- A set of numeric features can be conveniently described by a feature
  vector.
- Algorithms for classification from a feature vector include nearest
  neighbor classification, neural networks, and statistical techniques
  such as Bayesian approaches.

## Feature vector

- A feature vector is an n-dimensional vector of numerical features that
  represent some object.
- Many algorithms in machine learning require a numerical representation
  of objects, since such representations facilitate processing and
  statistical analysis.
- When representing images, the feature values might correspond to the
  pixels of an image, while when representing texts the features might
  be the frequencies of occurrence of textual terms.
- Feature vectors are often combined with weights using a dot product in
  order to construct a linear predictor function that is used to
  determine a score for making a prediction.
- The vector space associated with these vectors is often called the
  feature space.
    + In order to reduce the dimensions of the feature space, a number
      of dimension reduction techniques can be employed.
- Higher-level features are obtained from already available features and
  added to the feature vector.
    + For example, for the study of diseases the feature 'Age' is useful
      and is defined as Age='Year of death' minus 'Year of birth'.
    + This process is referred to as feature construction.

## Selection and extraction

- The initial set of raw features can be redundant and too large to be
  managed.
- Therefore, a preliminary step in many applications consist of
  selecting a subset of features, or constructing a new and reduced set
  of features to facilitate learning, and to improve generalization and
  interpretability.
- Extracting or selecting features require automated techniques with the
  intuition and knowledge of the domain expert.
    + Automating this process is feature learning, where a machine not
      only uses features for learning, but learn the features itself.

# Approaches

## Decision tree learning

Something

## Association rule learning

Something

## Artificial neural networks

It is inspired by the biological neural networks in animal brains.
- Multiple layers of units/nodes/artificial neurons: each neuron
  contains a number/value
- The connections between units are weights that will be multiplied with
  the value in that neurons.

### Calculus

- Derivatives of common activation functions
    + https://theclevermachine.wordpress.com/2014/09/08/derivation-derivatives-for-common-neural-network-activation-functions/

### Convolutional Neural Networks (CNNs)

CNN is a neural network with two characteristics:
1. Shared-weights architecture
2. Translation invariance: using convolution operation

It is inspired by biological processes, the animal visual cortex.
- It is usually used in computer vision.

### Recurrent Neural Networks (RNNs)

RNN is a neural network that can model the temporal dynamic behaviors.
- Nodes in a layer can have connections back to the nodes in the same
  layer (mixed forward connections and feedback connections)
- It is usually used in speech/handwritten recognition.

### Deep learning

Many layers of units (artificial neurons) in a neural network between
input and output layers.
- e.g., CNNs, RNNs

## Inductive logic programming

Something

## Support Vector Machines (SVMs)

Something

## Clustering

- Algorithms
    + K-means: small and mix-sized data sets
    + Hierarchical clustering with Bisecting K-means: large data sets

## Bayesian networks

Something

## Reinforcement learning

Something

## Representation learning

Something

## Similarity and metric learning

Something

## Sparse dictionary learning

Something

## Genetic Algorithms

Something

## Rule-based Machine Learning

Something

### Learning Classifier Systems

Something

# Machine Learning Process

## Preprocessing

### Introduction

* extract, transform, and load data to staging area
* review data for missing data and invalid values
    - set to default values or ignore those records
* normalizing and scaling numeric data
    - changing the range of values in a feature or attribute
* standardize categorical values
    - ISO standard, etc.

### Feature scaling

- https://en.wikipedia.org/wiki/Feature_scaling
- Normalization, Standardization

## Model Building

### Introduction

* selecting algorithms
* apply machine learning algorithms to training data
    - fitting a model to the data
* some algorithms require tuning hyperparameters
    - how many levels to have in a decision tree
    - need to experiment to find optimal hyperparameters
    - when we set a parameter to the machine learning algorithm,
      we call those parameters hyperparameters.
    - when the machine learning algorithm learns the value of
      the parameter from training data, then we call those
      simply parameters

## Validation

### Introduction

* assess the quality of models built in step 2
* applying models to additional test sets
* measuring quality of models (metrics)
    - accuracy
    - precision (positive predictive value)
    - and sensitivity (recall)

# Regularization

## Introduction

- https://en.wikipedia.org/wiki/Regularization_(mathematics)
- Regularization is a process of introducing additional information in
  order to solve an ill-posed problem or to prevent over-fitting.
    + Add a brake to the fitting model

# Convergence tolerance

- http://www.nbertagnolli.com/jekyll/update/2015/10/03/ConvTol.html
- There are three different methods of declaring a convergence:
    + *absolute tolerance*, relative tolerance and running for a
      specified number of iterations. In the absolute tolerance mode
      algorithm stops when an absolute difference in any of the
      variables is lower than the threshold.
    + *relative tolerance* In this method I compute the difference
      between the new approximation and the old one for each of the
      variables and divide it by the previous(old) value of the variable
      (in case it is not equal to 0).
    + *number of iterations* Here we let the algorithm run for the
      specified number of steps no matter what absolute or relative
      error was obtained before that and return the approximation on the
      last step as the result of the computation.

# Datasets

## Classification

- Two classes
    + https://www.csie.ntu.edu.tw/~cjlin/libsvmtools/datasets/binary.html

# References

[kkt-conditions]: https://en.wikipedia.org/wiki/Karush%E2%80%93Kuhn%E2%80%93Tucker_conditions
[convex-set]: https://en.wikipedia.org/wiki/Convex_set
[vc-dimension]: https://en.wikipedia.org/wiki/VC_dimension
[vc-theory]: https://en.wikipedia.org/wiki/Vapnik%E2%80%93Chervonenkis_theory
[control-theory]: https://www.reddit.com/r/MachineLearning/comments/at5iau/d_does_learning_control_theory_helps_to/
[gradient-descent]: https://en.wikipedia.org/wiki/Gradient_descent


text:
# Myriotrema whalleyanum Homchant. & Coppins SPECIES

#### Status
ACCEPTED

#### According to
Index Fungorum

#### Published in
Lichenologist 34(2): 119 (2002)

#### Original name
Myriotrema whalleyanum Homchant. & Coppins

### Remarks
null


text:
---
layout: post
title: How to Define your Purpose
category: blog
keywords: blog writing author shikhashikz writing writinglife writingcommunity dailyblogpost dailyblogpostchallenge definepurpose personalmissionstatement
image: assets/images/DefinePurpose.jpg

---
Continuing with my learning from **Jay Shetty’s Book, Think like a Monk** and this time the topic revolves around Purpose and Vision.

Quoting the text from his book:
Passion+ Expertise+ Usefulness=Dharma

*If we’re only excited when people say nice things about our work, it’s a sign that we’re not passionate about the work itself. And if we indulge our interests and skills, but nobody responds to them, then our passion is without purpose. If either piece is missing, we’re not living our dharma.*

I tried to connect my question with Jay’s statement. If I only get excited about my work, when I am showered with praises, then therein my passion does not lie. And if my passion is not able to solve any business problem or help the readers, then it does not bring value. Few initial thoughts came to my mind, which helped me develop my mission and vision:

💖No age is the best age to start something. The time and age are right when you feel so. At the age of 61, my mother knows how to attend Zoom calls without my help. My five-year-old son and seven-year-old daughter cruise through Microsoft Team effortlessly. The age factor does not come into play when you (really) want to learn something

💖Your biggest devil is your “MIND”. What if my efforts do not yield results? What if I fail? What if I am not successful commercially and many more deprecating self-talk which our mind forces us to get drowned in and then give up

To reach to the conclusion of Jay’s equation which I have quoted above, Time and Dedication are very important. So when I created a Punchline for myself: *Read, Write and Market,* I knew that on paper it looks like three simple words, but I need to have a strong commitment with myself, to bring reality to these three big goals. It did give shape to my purpose statement:

✨***To Read, Write, Market, my creation so that it helps readers believe that with a step by step approach, this is attainable and in the end it helps me establish my brand.*** ✨

Your purpose will leave you fulfilling and the time which you have invested in achieving it, will not leave you exhausted. You can trust me on that👍

I would also like to share **[Marie Forleo's talk with Seth Godin](https://www.marieforleo.com/2016/10/seth-godin/)** which left me with goosebumps and tears. Seth Godin is one of the person who is my inspiration to "Show up every day for what I believe in"

Another food for thought is, google on Emma Slade's awakening.


text:
![logo](https://raw.githubusercontent.com/papercups-io/papercups_flutter/main/images/logo.svg)

[![pub package](https://img.shields.io/pub/v/papercups_flutter.svg?label=papercups_flutter&color=blue)](https://pub.dev/packages/papercups_flutter) [![style: effective dart](https://img.shields.io/badge/style-effective_dart-40c4ff.svg)](https://pub.dev/packages/effective_dart) ![License](https://img.shields.io/github/license/papercups-io/papercups_flutter?color=black) ![GitHub issues](https://img.shields.io/github/issues/papercups-io/papercups_flutter?color=green&label=Issues)

[![likes](https://badges.bar/papercups_flutter/likes)](https://pub.dev/packages/papercups_flutter/score) [![popularity](https://badges.bar/papercups_flutter/popularity)](https://pub.dev/packages/papercups_flutter) [![pub points](https://badges.bar/papercups_flutter/pub%20points)](https://pub.dev/packages/papercups_flutter/score)

![Demo Chat](https://raw.githubusercontent.com/papercups-io/papercups_flutter/main/images/chatImages.png)

[![button](https://raw.githubusercontent.com/papercups-io/papercups_flutter/main/images/demoButton.svg)](https://papercups-demo.eduardom.dev/)      [![button](https://raw.githubusercontent.com/papercups-io/papercups_flutter/main/images/getPapercups.svg)](https://papercups.io/)

## Installing
To get started simply add `papercups_flutter:` and the latest version to your pubspec.yaml.
Then run `flutter pub get`

🎉 Done, It's that simple.
## Using the widget
Integration with your app requires just a few lines of code, add the following widget wherever you want your papercups chat window to be:
```Dart
import 'package:papercups_flutter/papercups_flutter.dart';

PaperCupsWidget(
    props: Props(
    accountId: "xxxxxxxx-xxxxxxx-xxxx-xxxxxx", //Your account id goes here.
    ),
),

```
That should get you up and running in just a few seconds ⚡.

## Configuration

### Available PaperCupsWidget arguments
| Parameter | Type | Value | Default |
| :--- | :--- | :----- | :------ |
| **`props`** | `Props` | **Required**, here is where all of the config for the chat is contained.| N/A |
| **`dateLocale`** | `String` |Locale for the date, use the locales from the `intl` package.| `"en-US"` |
| **`timeagoLocale`** | `dynamic` | Check https://github.com/andresaraujo/timeago.dart/tree/master/timeago/lib/src/messages for the available classes.| N/A |
| **`sendingText`** | `String` | Text to show while message is sending.| `Sending...` |
| **`sentText`** | `String` | Text to show when the messgae is sent.| `Sent` |
| **`floatingSendMessage`** | `bool` | Wether to have the message box floating.| `false` |

### Available Props paramaters
| Prop | Type | Value | Default |
| :--- | :--- | :----- | :------ |
| **`accountId`** | `string` | **Required**, your Papercups account token | N/A |
| **`title`** | `string` | The title in the header of your chat widget | Welcome! |
| **`subtitle`** | `string` | The subtitle in the header of your chat widget | How can we help you? |
| **`newMessagePlaceholder`** | `string` | The placeholder text in the new message input | Start typing... |
| **`primaryColor`** | `Color` | The theme color of your chat widget | `Theme.of(context).primaryColor` without alpha |
| **`primaryGradient`** | `Gradient` | Gradient to specify, should be used instead of primaryColor, DO NOT USE BOTH. | N/A |
| **`greeting`** | `string` | An optional initial message to greet your customers with | N/A |
| **`customer`** | `CustomerMetadata` | Identifying information for the customer, including `name`, `email`, `external_id`, and `metadata` (for any custom fields) | N/A |
| **`baseUrl`** | `string` | The base URL of your API if you're self-hosting Papercups. Ensure you do not include the protocol (https) of a trailing dash (/) | app.papercups.io |
| **`requireEmailUpfront`** | `boolean` | If you want to require unidentified customers to provide their email before they can message you | `false` |
| **`companyName`** | `String` | Company name to show on greeting | `"Bot"` |
| **`enterEmailPlaceholer`** | `String` | This is the placeholder text in the email input section | `"Enter your email"` |

### Available CustomerMetaData paramaters
| Parameters | Type | Value | Default |
| :--- | :--- | :----- | :------ |
| **`email`** | `string` | The customer's email| N/A |
| **`externalId`** | `string` | The customer's external ID | N/A |
| **`name`** | `string` | The customer's name | N/A |
| **`otherMetadata`** | `Map<String, String>` | Extra metadata to pass such as OS info. | N/A |

## Supporters
[![Stargazers repo roster for @papercups-io/papercups_flutter](https://reporoster.com/stars/papercups-io/papercups_flutter)](https://github.com/papercups-io/papercups_flutter/stargazers) [![Forkers repo roster for @papercups-io/papercups_flutter](https://reporoster.com/forks/papercups-io/papercups_flutter)](https://github.com/papercups-io/papercups_flutter/network/members)

branch_name: refs/heads/main


text:
## Iterating over them

You can iterate over a ResultSet with [ResultSetIterator](ResultSetIterator.java) or [RowIterator](RowIterator.java).
The former is the rawest way to convert a `ResultSet` because you'll be free to implement `convert(..)` : [ResultSetIterator](ResultSetIterator.java)
will "only" brings you the `Iterator` interface over a `ResultSet`.
So you may prefer to use [RowIterator](RowIterator.java) because it's still an `Iterator` but converts rows to [Row](Row.java)
 which is barely a `Map` of column names and their values, which is more "portable" and has no need of SQLException handling.
 The way columns are read from `ResultSet` comes from [ResultSetReader](../binder/binders.md#predefined-binders) given at construction time.

_Be aware that it is a memory overhead compared to [ResultSetIterator](ResultSetIterator.java)_

## Converting them to beans

The richest way to convert a `ResultSet` to beans is brought by [ResultSetConverter](ResultSetConverter.java) which will create a bean graph.
You may be interested in [ResultSetRowConverter](ResultSetRowConverter.java) for a simpler usage : convert each row of a `ResultSet` to a bean.

repository: FirasAEN/stalactite

filename: ResultSet handling.md

repo_name: FirasAEN/stalactite


text:
# Logging into Zoom

You can only join the sessions if you log in into Zoom
`nus-sg.zoom.us` using your NUS account.

To do so, you have to first log out of Zoom if you have already logged in using your non-NUS Zoom account.

There are two options:

## Option 1
- go to https://nus-sg.zoom.us/ directly and click "Sign In";
- Follow the given instructions by entering your NUSNET ID and password.

## Option 2
If you get to Zoom through another link, you might be presented with
the following screen.

![zoom sign-in](figures/zoom-signin.png)

Do not enter your NUS email address and password on this
screen.  Instead, click on "Sign in with SSO".  You will be
presented with this screen:

![zoom sso](figures/zoom-sso.png)

Enter `nus-sg` into the field "Company Domain" and click continue.

You will be prompted to enter your NUSNET ID and password.  Follow
the instruction on the screen.

## Using Zoom Desktop Client

Some students have reported issues when trying to join a breakout
room when using Web version of Zoom (i.e., connecting through a Web
browser).

Please join the workshop by using the Zoom application instead of
through a Web browser.

## Links to Join Zoom

The Zoom session information will be/have been sent to you privately.  Check
your email for information.


text:
[![GoDoc][1]][2] [![Go Report Card][3]][4] [![Keybase Chat][5]][6] [![Cloud Build][7]][8]

[1]: https://godoc.org/github.com/tensortask/gotfpb?status.svg
[2]: https://godoc.org/github.com/tensortask/gotfpb
[3]: https://goreportcard.com/badge/github.com/tensortask/gotfpb
[4]: https://goreportcard.com/report/github.com/tensortask/gotfpb
[5]: https://img.shields.io/badge/keybase%20chat-tensortask.public-blue.svg
[6]: https://keybase.io/team/tensortask.public
[7]: https://storage.googleapis.com/tensortask-static/build/gotfpb.svg
[8]: https://github.com/sbsends/cloud-build-badge

# 📜 GoTFPB: Curated Golang TensorFlow Protocol Buffers
GoTFPB provides compiled golang code for tensorflow protocol buffers. Instead of compiling the protocol buffers locally, you can simply import the golang code like any other golang package.

Note: The build is failing because no unit tests have been written yet.

## Package Layout

Each package has two sub-directories. The gen directory contains the generated Golang source code. The protos directory contains the protocol buffer definitions (proto3).

* **core**: fundamental protocol buffers used at the core of TensorFlow.
  * **framework**: basic absolutely vital tensors used in TensorFlow (graph, tensor, etcetera).

## Imports

* **core**:
  * **framework**: `github.com/tensortask/gotfpb/core/framework`

## Compilation

Local compilation is not required, but if you wish to recompile the protos we reccommend using the [supplied docker image](https://github.com/tensortask/go-proto-compiler).

Build the docker image by running the following commands:

```bash
git clone https://github.com/tensortask/go-proto-compiler
cd go-proto-compiler
docker build . -t go_proto_compiler
```

Compile the protos:
```bash
# first move to the gotfpb dir
cd $GOPATH/src/github.com/tensortask/gotfpb

# unix-based platforms
bash compile.sh

# or run the docker command (non-unix)
docker run -v $GOPATH/src/github.com/tensortask/gotfpb:/go/src/github.com/tensortask/gotfpb go_proto_compiler /bin/bash -c "export GO111MODULE=on; cd src/github.com/tensortask/gotfpb; go generate ./..."
```

repository: tensortask/gotfpb

repo_name: tensortask/gotfpb


text:
# Surveillance System
I am studying Scala Functional Programming and my goal now is to create let say a system to monitor elderly in a nursing home.
The system consists of Raspberry Pi Zero W hardware equipped with a camera and a central monitoring system. Currently, I vision the system as publisher/subscriber system, where Zero W devices post images. The system should raise the alarm where an elderly has not seen for a particular time after entering a room.
The Zero W will have Python/Flask software and periodically send images to the central monitoring system.
The central observing system will be built with Scala and process the images using an object recognition module to identify people.

## Use Case
<img src="https://github.com/rbontekoe/surveillance/blob/master/Surveillance%20System.png" />

## Version
v0.1

repository: rbontekoe/surveillance

repo_name: rbontekoe/surveillance


text:
**⚠ This library is no longer maintained by myself, a newer fork is available here:** [https://github.com/AceKiron/fingerprint-gml](https://github.com/AceKiron/fingerprint-gml)

# Fingerprint GML

A simple script for fingerprinting a user in Game Maker Studio.
My use case is to fuzzily identify different devices / users coming from the same IP address when they connect to my server.

Inspired by: [https://github.com/Valve/fingerprintjs2](https://github.com/Valve/fingerprintjs2).

Marketplace Link: [https://marketplace.yoyogames.com/assets/6613/fingerprint](https://marketplace.yoyogames.com/assets/6613/fingerprint)

## How it works

The fingerprint is calculated by writing the following to a buffer and retrieving an MD5 hash.

- Operating System
- Browser
- Display Width / Height
- Are Shaders Supported?
- Timezone
- Gamepad Count (+ count of connected gamepads)

On Windows-only, the following environment variables are used:
- Username
- Computer Name
- Number of Processors
- CPU Architecture, identifier, level and revision

## Quick start

- Import the fingerprint_md5.gml script into your project.
- Call "fingerprint_md5()" to get a fingerprint of the user.

## Requirements

* Game Maker Studio 2 (Untested in GMS1)

## Contributing

If you have ideas on how to improve the fingerprinting, either with a better hash function or by utilizing more feature detection functions in Game Maker Studio, please post an issue or submit a pull request!

Ideally this script would have better fingerprinting by being able to utilize RAM information, GPU information and CPU information such as core count / GHZ / cache sizes. Unfortunately, I haven't found any such scripts / functions in the Game Maker Studio 2 documentation.

repository: silbinarywolf/fingerprint-gml

gha_language: Game Maker Language

repo_name: silbinarywolf/fingerprint-gml


text:
# Caesar Cipher

A basic Caesar Cipher class in PHP for fun and learning.

[![Build Status](https://travis-ci.org/kkiernan/caesar-cipher-php.svg?branch=master)](https://travis-ci.org/kkiernan/caesar-cipher-php)
[![Style Status](https://styleci.io/repos/50455710/shield)](https://styleci.io/repos/50455710)

<!-- START doctoc generated TOC please keep comment here to allow auto update -->
<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->

- [Installation](#installation)
- [Instantiation](#instantiation)
- [Available Methods](#available-methods)
  - [Encrypt](#encrypt)
  - [Decrypt](#decrypt)
  - [Crack](#crack)
- [Security](#security)

<!-- END doctoc generated TOC please keep comment here to allow auto update -->

## Installation

Install the package using Composer.

```
composer require kkiernan/caesar-cipher
```

## Instantiation

Create a new `CaesarCipher` instance. Make sure to import the class or use the fully qualified class name.

```php
$cipher = new KKiernan\CaesarCipher();
```

## Available Methods

### Encrypt

To encrypt a message, pass the `CaesarCipher` instance some plaintext and a key. In a Caesar Cipher, the key is just the number of places to shift each letter in the plaintext.

```php
$ciphertext = $cipher->encrypt('This is a plain text message that will be encrypted!', 8);
```

### Decrypt

To decrypt a ciphertext, use the `decrypt` method on the `CaesarCipher` instance. Pass in the ciphertext and the key that was used to encrypt the message.

```php
$plaintext = $cipher->decrypt($ciphertext, 8);
```

### Crack

You can attempt to crack an encrypted message by using the `crack` method, which will return a best guess for the key's value. Use the key to retrieve the plaintext.

```php
$key = $cipher->crack('Max wtrl tkx zxmmbgz lahkm tztbg.');

$plaintext = $this->decrypt($ciphertext, $key);
```

## Security

This was written for fun and learning very basic encryption techniques (like substitution in this case). Obviously Caesar Cipher is not a secure encryption algorithm (only 25 possible keys), so don't use this for anything sensitive. It's really a toy meant for fun.


text:
chartbeat-php
=============
PHP library to interact with Chartbeat API.

See great [API docs](http://chartbeat.com/docs/api/) and [API explorer](http://chartbeat.com/docs/api/explore/) from [Chartbeat website](http://chartbeat.com) for more info.

This library requires PHP >5.3 and cURL extension for PHP to work. Tested with PHP 5.3.15 and 5.4.6

Please give feedback, report bugs, fork and contribute.

## Installation

Add chartbeat-php to your composer.json:

```php
{
	"require" : {
		"chartbeat/chartbeat-php" : "1.*"
	}
}
```

Simple test script:

```php
require_once ('vendor/autoload.php'); // composer autoloader
$apiKey = '<your api key>';
$host = '<your host>';
$cb = new Chartbeat\Chartbeat($host, $apiKey);

// get monthly max people on site
echo 'Monthly max people on the site: ' . $cb->getMonthlyMaxPeople();
```

You can also do any kind of API query using get() method. First parameter is data endpoint (eg. 'historical/traffic/series'), seconds one contains parameters.

In here, we get top referer of page which has most visitors right now:

```php
$cbData = $cb->get('live/toppages/v3/', array('limit' => 1)); // get all top pages, we want only 1
$topPage = current($cbData->pages); // get first page of the result
var_dump(current($topPage->stats->toprefs)); // output first top referer of page

// outputs:
object(stdClass)#9 (2) {
  ["visitors"]=>
  int(10)
  ["domain"]=>
  string(10) "google.com"
}
```

## Error handling

Every error throws exception Chartbeat\Exception.

```php
try {
	// set invalid key and try to get data
	$cb->setApiKey('invalidapikey');
	$cb->getMonthlyMaxPeople();
} catch (Chartbeat\Exception $ex)
{
	echo "Caught exception: " . $ex->getMessage();
	// will output "Caught exception: Chartbeat API error. Message: No Access, Code: 403"
}
```

## Testing

You can test this library by running example.php with:

    ./example.php <your host> <your API key>

This will output monthly max people your site

repository: VadikV/chartbeat-php

repo_name: VadikV/chartbeat-php


text:
# stayinside

![Banner](/docs/images/banner.png)

**stayinside** allows you to learn something new every time you open your new tab page! It reccomends to you something new every day on your New Tab page for you to try, and you can click on the button to see more details on Reddit and YouTube, which is where the ideas and inspiration for learning something new is sourced. You can log in, create an account, and add your friends to compete with them and see how is completing their goals every single day, which is displayed by the calendar on the right.

Fight the COVID-19 pandemic by staying inside and doing your part in social distancing!

## Inspiration

You know those beautiful motivational quotes New Tab extensions that you can get with a great wallpaper, and tells you a motivational quote of the day? (And even makes some money from you by begging for your Patreon support to remove ads?) Yeah, those. Those are useless. Who cares about motivational quotes? Let's learn something *cool* and *useful* instead, which you can with our extension because you'll compete with your friends to stay ahead of the curve and do the things that will give you not only brownie points in front of your friends (because who cares about *those*), but also *in front of your **crush** as well*. Now that's the real deal.

## Usage

Download the latest release candidate, which at the time of writing is [0.1-beta](https://www.github.com/gideontong/stayinside/releases) from the releases tab, and load the zipped package into your web browser of choice.

You will also need to set up a server, which can be found in the `/server` directory of the repository. It requires Node.js to run and you can run it using `npm run dev`.

## Future Plans

We plan to integrate Google Calendar in the future so you can view your calendar at a glance as well every time you open the tab.

## About

**stayinside** was created at LA Hacks 2020 by Gideon Tong, Kendall Nakai, and William Tran.

repository: gideontong/stayinside

repo_name: gideontong/stayinside


text:
# README Generator
  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

  ## Table of Contents

  * [Description](#description)
  * [Installation Instructions](#installation)
  * [Usage Information](#usage)
  * [Contribution Guidelines](#contribution)
  * [Test Instructions](#test)
  * [License](#license)
  * [Questions](#questions)

  ## Description

  This small application will allow you to create a README by following prompts in the termimnal. It will help save time writing a good README file.

  ## Installation

  To install, make sure you clone the repo, then type "npm install" in order to download the necessary node modules. This will allow you to use the inquirer module.

  ## Usage

  To use the README Generator, first follow the installation instructions as detailed above. Then open the folder containing the index.js in the terminal and type "node index.js" in order to run the application. Then follow the prompts on screen as detailed in the video below. If you choose not to have a section, just hit enter and it will not include that section for you. You must include your github username and email though. In the end it creates a file called README.md and will overwrite any README.md that already exists in the folder.

  ## Contribution

  To contribute to the application, please create your own repo and request permission to contribute to the project. You are required to go through a review in order to upload anything to github.

  ## Test

  Please type node test.js

  ## License
  This project is licensed with MIT license
  https://choosealicense.com/licenses/mit

  ## Questions

  Please contact me at:

  [GitHub](https://www.github.com/chrisrisseler)

<EMAIL_ADDRESS>
  ## Video of the use can be found here:
  [Google Dive Link](https://drive.google.com/file/d/18lcO6XUnhT2wLsaHNVrDYCF4BAPfTU8y/view)

repository: chrisrisseler/readme-generator

repo_name: chrisrisseler/readme-generator


text:
# EpicBitmapRenderer

[ ![Download](https://api.bintray.com/packages/isaacrf/maven/EpicBitmapRenderer/images/download.svg) ](https://bintray.com/isaacrf/maven/epicbitmaprenderer/_latestVersion)
[![Maven Central](https://maven-badges.herokuapp.com/maven-central/com.isaacrf.epicbitmaprenderer/epicbitmaprenderer/badge.svg)](https://maven-badges.herokuapp.com/maven-central/com.isaacrf.epicbitmaprenderer/epicbitmaprenderer)

Decode and render Bitmaps the epic and easy way, creating faster Android apps without extra effort.

![EpicBitmapRenderer Icon](http://isaacrf.com/libs/epicbitmaprenderer/images/EpicBitmapRenderer-Icon.png)

## Epic Bitmap Renderer, the outOfMemoryError slayer
Have you ever had to face image decoding in an Android app? If you have, you have most definitely also faced the problem of having to repeat many tedious and time consuming tasks, each and every single time you have had to do so in a different app.

Following Google conventions on displaying bitmaps efficiently
(see [Google guide][gbmpdisplayguidelink] for more info), this Android Bitmap decoder library puts an end to these problems, automatizing most of these tedious tasks, and even others you didn't know you had to do!

Epic Bitmap Renderer offers Android developers the following features:

* **Exposes static asynchronous** (and synchronous too, just in case you need it) **methods** to decode Bitmap objects from different sources **outside the UI thread**, ensuring that your app runs smoothly.
* **Image auto and manual downsampling.** This library keeps memory usage of your app low by loading images in just the scale and size you need, only specifying Image holder's size (Or a manual downsample rate). If the device is still unable to load image due to low memory available, render methods will automatically recalculate image downsample for it to successfully fit in the device's memory, **avoiding that annoying OutOfMemoryError.**
* **Image auto caching.** Rendering methods automatically save rendered Bitmaps in memory and disk caches using dual cache EpicBitmapCache. If an image is previously rendered, next time it will be extracted from cache if available, and it will be used instead of re-rendering Bitmap from source again. This entire process is automatic (as render methods handle cache themselves) and saves a lot of memory consumption from heavy processes like rendering images from disk or the Internet.

## How to use Epic Bitmap Renderer in your app
You can access general [javadoc][jdoclink] to see project structure and documentation, or access directly to [EpicBitmapRenderer class javadoc][jdoclink2] to see all image decoding methods available, and how to call them.

The Android Studio Project contains a "samples" app module with a single Main Activity, that can be installed on an Android device or virtual machine to test library functions. It contains all the code required for importing, initializing and calling the library in your own app, as well as examples of library decoding method calls.

![Samples app screen capture](http://isaacrf.com/libs/epicbitmaprenderer/images/SamplesApp.png)

### 1.- Importing library
First of all, you need to import EpicBitmapRenderer library into your proyect. It is available on Bintray JCenter and Maven Central repositories. There are several ways to do this depending on your IDE and your project configuration.

Gradle:
```groovy
compile 'com.isaacrf.epicbitmaprenderer:epicbitmaprenderer:1.0'
```

Maven:
```xml
<dependency>
  <groupId>com.isaacrf.epicbitmaprenderer</groupId>
  <artifactId>epicbitmaprenderer</artifactId>
  <version>1.0</version>
  <type>pom</type>
</dependency>
```

Ivy:
```xml
<dependency org='com.isaacrf.epicbitmaprenderer' name='epicbitmaprenderer' rev='1.0'>
  <artifact name='$AID' ext='pom'></artifact>
</dependency>
```

You can also manually download the library .aar file (.jar + Android dependencies) and javadocs from [EpicBitmapRenderer JCenter repository][jcenterlink], add files to your project libs folder, and import the library using your IDE or Gradle, adding the following to your module's build.gradle script:

```groovy
repositories {
    flatDir {
        dirs 'libs'
    }
}

dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    testCompile 'junit:junit:4.12'
    //Add .aar file to libs/ and use folder as repository
    compile(name:'epicbitmaprenderer-1.0', ext:'aar')
}
```

### 2.- Initializing the library
Once EpicBitmapRenderer is succesfully imported into your project, you will have access to the EpicBitmapRenderer class and its static methods to decode and render Bitmaps in your app.

EpicBitmapLibrary uses a dual memory and disk cache to improve image decoding and rendering processes. Memory cache is automatically initialized when the library is loaded. However, disk cache requires a context to know what your app's own cache folder is and create it, so it needs to be manually initialized. **(I'm still looking for ways to avoid this step and automatize the process, see "Known issues / todo features list" in the "Contributing" section for more info).**

So the first step is initializing disk cache, calling this method in your code (You may only call this method ONCE in the entire app life cycle). If disk cache is not initialized, **the library will continue to function properly and will keep storing decoded images in memory cache.**

```java
/* Pass context as parameter. You can use "this" inside
an Activity, or "ActivityName.this" in other levels
 */
EpicBitmapRenderer.initDiskCache(this);
```

To decode Bitmaps from files or URLs, your app may need to request special permissions.

### 3.- Decoding Bitmaps
EpicBitmapRenderer is a static class containing only static methods, so you don't need to instantiate it to use the library. Here is an example, extracted from samples app, of calling a method to decode a Bitmap from a resource of your app, and then showing it on an ImageView, or handling the decoding error, if one occurs.

```java
/*Sample 1: Decode Bitmap from Resource app icon, downsample if needed
to fit in 200x200 ImageView,  (Async)
 */
EpicBitmapRenderer.decodeBitmapFromResource(getResources(), R.mipmap.ic_launcher, 200, 200,
        new OnBitmapRendered() {
            @Override
            public void onBitmapRendered(Bitmap bitmap) {
                //Display rendered Bitmap when successfully decoded
                ((ImageView) findViewById(R.id.imgSampleDecodeResource)).setImageBitmap(bitmap);
            }
        },
        new OnBitmapRenderFailed() {
            @Override
            public void onBitmapRenderFailed(Exception e) {
                //Take actions if Bitmap fails to render
                Toast.makeText(MainActivity.this,
                        "Failed to load Bitmap from Resource: " + e.getMessage(),
                        Toast.LENGTH_SHORT).show();
            }
        });
```

And that's it! EpicBitmapRenderer decodes the Bitmap asynchronously in a worker thread, stores it in memory and disk cache, and, if successful, returns decoded Bitmap at the end of the process on the onBitmapRendered(Bitmap) callback. Further calls to render methods pointing to the same resource, will obtain the decoded Bitmap from memory or disk cache if available, instead of rendering the resource again, thus saving memory usage.

Almost every decoding method has an alternate, overloaded synchronous method (same arguments without callbacks) in case you need them, but it's not recommended as they run on the UI thread and can freeze the app. Here is the same example as before, but calling the synchronous method:

```java
Bitmap decodedBitmap = EpicBitmapRenderer.decodeBitmapFromResource(getResources(),
        R.mipmap.ic_launcher, 200, 200);
((ImageView) findViewById(R.id.imgSampleDecodeResource)).setImageBitmap(decodedBitmap);
```

## Contributing
You can help improve EpicBitmapRenderer in many ways, some of which are:

* Adding new image decoding methods, from different kinds of sources, to different image formats.
* Improving cache and other core elements' functionality.
* Reporting and/or fixing bugs, issues, etc.

Just fork the project, modify what you want, and make a pull request to master Branch. Please, follow library structure and coding style when contributing, and make sure that your code compiles.

If you add a new decoding method, please add an example of usage in samples app module as well, and update the documentation to match any changes you make.

### 1.- Project Structure
![Project Structure from Android Studio](http://isaacrf.com/libs/epicbitmaprenderer/images/ProjectStructure.png)

EpicBitmapRenderer is an Android Studio project divided in 2 main modules:

* epicbitmaprenderer
* samples

#### 1.1.- epicbitmaprenderer module
epicbitmaprenderer is an Android Library module containing all the library code. This module is divided into the following packages:

* **core:** This package stores all the core code of the library divided into 2 classes, EpicBitmapRenderer, containing all Bitmap decoding and rendering methods, and EpicBitmapCache, a dual cache class to handle automatic image caching on memory and disk.
* **asynctasks:** Different asynctasks used by core package, mainly by EpicBitmapRenderer to decode Bitmaps asynchronously.
* **listeners:** Interfaces for callback definitions. Used to expose a template to override callbacks and handle decoding results.
* **utils:** Helper classes used for different tasks, such as handling disk cache and performing IO reading/writing operations.

#### 1.2.- samples module
samples is an Android app module containing a single Main Activity with different Bitmap decoding examples. This app can be deployed on an Android device or virtual machine to test library functionalities.

When adding new decoding methods from new sources or to new formats, this activity must be updated with examples of method usage.

### 2.- Known issues / todo features list
- [ ] Find a way to initialize disk cache automatically on EpicBitmapCache (needs application context), without asking the user to call a method (initDiskCache) passing Context as parameter. Context is just used to retrieve app's cache dir
- [ ] Allow to clear cache or force rendering from source skipping cache check task
- [ ] Allow to enable / disable automatic image caching

[jcenterlink]: https://bintray.com/isaacrf/maven/EpicBitmapRenderer/1.0
[jdoclink]: http://epicbitmaprenderer.isaacrf.com/javadoc/
[jdoclink2]: http://epicbitmaprenderer.isaacrf.com/javadoc/com/isaacrf/epicbitmaprenderer/core/EpicBitmapRenderer.html
[gbmpdisplayguidelink]: https://developer.android.com/training/displaying-bitmaps/index.html?hl=es

repository: IsaacRF/EpicBitmapRenderer

gha_language: Java

repo_name: IsaacRF/EpicBitmapRenderer


text:
[![Codacy Badge](https://api.codacy.com/project/badge/Grade/f387b1d7c5534099a139ce707fe6de8e)](https://www.codacy.com/app/wenyan4work/SimToolbox?utm_source=github.com&utm_medium=referral&utm_content=wenyan4work/SimToolbox&utm_campaign=Badge_Grade)

# SimToolBox
A toolbox for object-tracking simulation.
This toolbox contains a collection of useful tools for different tasks involved in a particle-tracking type simulation.

At the base level the code relies on `FDPS` and `Trilinos`.
The folder `FDPS` contains the headers to the [Framework for Developing Particle Simulator](`https://github.com/FDPS/FDPS`).
The folder `Trilinos` contains an interface to [the huge C++ project](https://trilinos.github.io/) for distributed linear algebra and some other useful stuff.

The folder `Collision` contains the routines for LCP based collision resolution algorithms, supporting both OpenMP and MPI through `Trilinos`.

The folder `Sylinder` contains a parallel `SylinderSystem` class for simulating rigid spherocylinders with overdamped dynamics. A geometric constraint optimization method is implemented to resolve collisions. Parallel IO is also supported for each geometric primitive through the XML-based vtk routines. This code is used in my publications:

1. Yan, Wen, Huan Zhang, and Michael J. Shelley. 2019. “Computing Collision Stress in Assemblies of Active Spherocylinders: Applications of a Fast and Generic Geometric Method.” The Journal of Chemical Physics 150(6): 064109.

The folder `Util` contains some utilities to facilitate the application, including an interface to linear algebra `Eigen`, a parallel RNG interface to `TRNG`, a command line parser `cmdparser` (https://github.com/FlorianRappl/CmdParser), a timer.

New functions will be continuously added to this toolbox to facilitate quick development of HPC simulation code.
Run the script `Gendoc.sh` to generate html document with doxygen in `doc/html/index.html`.
Read `StepByStep.md` for instructions.


text:
# Usage

## `task`

The main interface to your tasks is the `task` command, which supports various subcommands.
You can find a quick list of all subcommands with `task help`.

Note that the `task` interface does not match that of TaskWarrior.

### Configuration

The `task` command will work out-of-the-box with no configuration file, using default values.

Configuration is read from `taskchampion.yaml` in your config directory.
On Linux systems, that directory is `~/.config`.
On OS X, it's `~/Library/Preferences`.
On Windows, it's `AppData/Roaming` in your home directory.
The path can be overridden by setting `$TASKCHAMPION_CONFIG`.

Individual configuration parameters can be overridden by environemnt variables, converted to upper-case and prefixed with `TASKCHAMPION_`, e.g., `TASKCHAMPION_DATA_DIR`.
Nested configuration parameters cannot be overridden by environment variables.

The following configuration parameters are available:

* `data_dir` - path to a directory containing the replica's task data (which will be created if necessary).
  Default: `taskchampion` in the local data directory
* `server_origin` - Origin of the taskchampion sync server, e.g., `https://taskchampion.example.com`
* `server_client_id` -  Client ID to identify this replica to the sync server (a UUID)

## `taskchampion-sync-server`

Run `taskchampion-sync-server` to start the sync server.
Use `--port` to specify the port it should listen on, and `--data-dir` to specify the directory which it should store its data.
It only serves HTTP; the expectation is that a frontend proxy will be used for HTTPS support.

## Debugging

Both `task` and `taskchampio-sync-server` use [env-logger](https://docs.rs/env_logger) and can be configured to log at various levels with the `RUST_LOG` environment variable.
For example:
```shell
$ RUST_LOG=taskchampion=trace task add foo
```

repository: srfraser/taskchampion

repo_name: srfraser/taskchampion


text:
Test 3-03 - Search Project Members (DB Mode)
=======

# Purpose:

To verify that a non system admin user can search members of a project when users are managed locally by Harbor (DB mode).

# References:
User guide

# Environment:
* This test requires that a Harbor instance is running and available.
* Harbor is set to authenticate against a local database. ( auth_mode is set to **db_auth** .) The user data is stored in a local database.
* A linux host with Docker CLI installed (Docker client).
* At least five(5) non-admin users are in Harbor.

# Test Steps:

**NOTE:**
* In below test, user A, B are non system admin users. User A, B and project X should be replaced by longer and meaningful names.
* MUST use two kinds of browsers at the same time to ensure independent sessions. For example, use Chrome and Firefox, or Chrome and Safari.
* DO NOT use the same browser to log in two users at the same time in different windows(tabs).

1. Log in to UI as user A (non-admin).
2. Create a new project X.
3. Add user B as a project admin role of project X.
4. Add 3 more members to project X with various roles, such as developer, guest.
5. Keeps user A's UI session logging on, in a different browser log in as user B.
6. In user B's UI, search members of project X using different criteria (keywords).
7. In user A's UI, change user B's role to developer of project X.
8. In user B's UI, search members of project X using different criteria.
9. In user A's UI, change user B's role to guest of project X.
10. In user B's UI, search members of project X using different criteria.

# Expected Outcome:
* Step 6,8,10, user B should see results based on search keywords.

# Possible Problems:
None

repository: goharbor/harbor

gha_language: Go

repo_name: goharbor/harbor


text:
# progressBar

Progress bar for Bash

## Installation

From terminal type:

```bash
./install
```

Then type your root password.

## Use

From terminal type:

```bash
progressbar
```

![execution](https://raw.githubusercontent.com/ivangonzalezg/barraDeProgreso/master/progressbar_default.gif)

Duration time and default message: 1s, "All done."

To configure these parameters can only be done as follows

```bash
progressbar [Duration] "[Message]"
```

### Example

```bash
progressbar 3 "Listo, proceso terminado."
```

![execution](https://raw.githubusercontent.com/ivangonzalezg/barraDeProgreso/master/progressbar_custom.gif)

repository: ivangonzalezg/progressBar

repo_name: ivangonzalezg/progressBar


text:
---
title: PlayFab CloudScript using Azure Functions Quickstart Guide
author: williacj
description: PlayFab CloudScript using Azure Functions Quickstart Guide
ms.author: cjwill
ms.date: 11/25/2019
ms.topic: article
ms.prod: playfab
keywords: playfab, automation, cloudscript, azure functions
ms.localizationpriority: medium
---
> [!NOTE]
> This feature is in private preview and intended for use by customers participating in the preview program.  We anticipate ongoing changes to it as we continue gathering feedback and optimizing for customer use.
>
# Getting Started

> [!IMPORTANT]
> This feature is currently in **Private Preview**.
>
> It is provided to give you an early look at an upcoming feature, and to allow you to provide feedback while it is still in development. We will be making it broadly available to developers as soon as we can.

There are two ways to get started with C# CloudScript using Azure Functions.  The easiest and quickest way is to use Azure Functions right out of the box.  To get started with Azure Functions with either Visual Studio Code or Visual Studio visit their [getting started guide](https://docs.microsoft.com/azure/azure-functions/) and return here once you are completely setup.

>**NOTE:**
>In this guide, we will focus only on using Visual Studio Code. You can use any  [language that is supported in Azure Functions](https://docs.microsoft.com/azure/azure-functions/supported-languages).  At this time, the samples we provide with PlayFab integration uses the C# language.

What is the difference between the two?  The main difference is that our Visual Studio Code Extension provide some easy ways to registers and unregister functions with your PlayFab title. However, you do not need the extension to do this as there is a user interface for it in [Game Manager](https://developer.playfab.com/login).  We will cover more about this below.

### Prerequisites

There are a couple of steps needed to get started with PlayFab C# CloudScript.

* You must have an [Azure account](https://azure.microsoft.com/free/) already setup.  Signing up for an Azure Account is free.
* You must have an [Azure Subscription setup](https://docs.microsoft.com/azure/billing/billing-create-subscription), Subscriptions can be cancelled at any time. Visit [Cancel Azure Subscription](https://docs.microsoft.com/azure/billing/billing-how-to-cancel-azure-subscription) for more info.
* **Note:** To minimize latency of your CloudScript using Azure Functions place them in either US-West or US-West 2 Azure regions.
* You must have a [PlayFab account](https://developer.playfab.com/signup).
* While we do support all languages that Azure Functions support, our documentation samples are in C#.
* PlayFab Azure Functions use V2 of Azure Functions, so please be sure to use the V2 runtime.

### Enable the Feature

To begin using this feature you need to enable it.  Visit Automation -> CloudScript tab -> Functions (Preview).

* Click the Enable button to turn on the various pieces of Game Manager that will allow you to register functions, hook them up to rules, tasks etc.

![Enable PlayFab C# CloudScript](media/enable_azure_functions.jpg)

### Create an Azure Function

1. Following the Visual Studio Code getting started guide create a basic "HelloWorld" example function.  You can see how to do this by following the [Create your first function using Visual Studio Code guide](https://docs.microsoft.com/azure/azure-functions/functions-create-first-function-vs-code).  For a code example using PlayFab variables see the section below **(PlayFab Function Context, Variables and using the Server SDKs)**.
2. Once your function has been created and deployed, click the Register Function button in the top right hand corner of the Functions (Preview) page.
![Register CloudScript Function](media/register_cs_function.jpg)
3. Put the name and Function URL.  The URL can be found in the output of your deployment.
![Deployment Output](media/azure_func_deployment.jpg)

> **TIP**: To learn more about deploying azure functions, see [Deploy Azure Functions from Visual Studio Code]](https://code.visualstudio.com/tutorials/functions-extension/deploy-app).

### Using and Calling CloudScript using Azure Functions from your PlayFab Title

In order to use the function you just created from the PlayFab SDK, you will need to download one of our BetaSDKs. These are gated SDKs, and access instructions are in the email sent to developers as part of the beta admission process. Once you have access to the [Beta SDKs](https://github.com/PlayFab?utf8=%E2%9C%93&q=beta&type=&language=) you can download the one specifically for the environment you are making your game in.

> **NOTE:** The examples code within the this guide will be written in Unity C# & Azure Function C# code.

Now that your function is registered, and you have the Beta SDK installed, you can now call that function from within your client.

```C#
//This snippet assumes that your game client is already logged into PlayFab.

using PlayFab;

private void CallCSharpExecuteFunction(){

    PlayFabCloudScriptAPI.ExecuteFunction(new ExecuteFunctionRequest(){
        EntityKey = new CloudScriptModels.EntityKey(){
            Id = [AuthenticationContext.Entity.Id], //Get this from when you logged in,
            Type = [Authenticationcontext.Entity.Type] //Get this from when you logged in
        },
        FunctionName = "HelloWorld", //This should be the name of your Azure Function that you created.
        FunctionParameter = new Dictionary<string,object>(){
            {"inputValue": "Test"}
        }, //This is the data that you would want to pass into your function.
        GeneratePlayStreamEvent:false, //Set this to true if you would like this call to show up in PlayStream
    }, (ExecuteFunctionResult result)=>{
        if(result.FunctionResultTooLarge){
            Debug.Log("This can happen if you exceed the limit that can be returned from an Azure Function, See PlayFab Limits Page for details.")
            return;
        }
        Debug.Log($"The {result.FunctionName} function took {result.ExecutionTimeMilliseconds} to complete");
        Debug.Log($"Result: {result.FunctionResult.toString()}");
    },(PlayFabError error)=>{
        Debug.Log($"Opps Something went wrong: {error.GenerateErrorReport()}");
    });

}

```

### PlayFab Function Context, Variables and using the Server SDKs

One advantage of using CloudScript using Azure Functions is that some data will be automatically passed to the Azure Function, passing you context on the invocation of the Cloudscript and in what context the Function was called (For example, PlayStream Action or directly from the client). This includes information like the entity profile that was the CloudScripts was invoked on behalf of and potentially the PlayStream events used to invoke the CloudScript.

There are a couple of steps that you need to do if you are coding Functions without our Visual Studio Code Extension.

1. You will need to install the PlayFab SDK via Package Manager. To do this open Terminal or CMD Console in Visual Studio Code and type: `dotnet add package PlayFabAllSDK`
2. We have created some helpers that will ship with the cSharpSDK,  they are in beta.  If you have access to the beta repository, then you can get the cloudscript project.  If not, you can copy the file *PlayFabFunctionContexts.cs* from the [pf-af-samples](https://github.com/PlayFab/pf-af-samples) repository.
3. You need to edit your .csproj file and include `<DefineConstants>NETCOREAPP2_0</DefineConstants>` in your default PropertyGroup.
![Define Constants](media/define_constants.jpg)

A hello world example is always nice,  see the below HelloWorld Sample that you can use as your first Azure Function.

```C#
using System.Net.Http;
using System.Threading.Tasks;
using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Extensions.Http;
using Microsoft.Extensions.Logging;
using PlayFab;
using PlayFab.Plugins.CloudScript;

namespace PlayFabCS2AFTests.HelloWorld
{
    public static class HelloWorld
    {
        [FunctionName("HelloWorld")]
        public static async Task<dynamic> Run(
            [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequestMessage req,
            ILogger log)
        {
            /* Create the function execution's context through the request */
            var context = await FunctionContext<dynamic>.Create(req);
            var args = context.FunctionArgument;

            var message = $"Hello {context.CurrentPlayerId}!";
            log.LogInformation(message);

            dynamic inputValue = null;
            if (args != null && args["inputValue"] != null)
            {
                inputValue = args["inputValue"];
            }

            log.LogDebug($"HelloWorld: {new { input = inputValue} }");

            return new { messageValue = message };
        }
    }
}

```

As you can see in the above, the CurrentPlayerId of the caller is available like in our traditional CloudScript implementation.  Parameters you have passed in the FunctionParameters field will be available in the *args*.

> **NOTE:** You will need to call this HelloWorld Azure Function via ExecuteFunction from an SDK.

> **NOTE:** In the PlayStream event, sent back from the CloudScript function, the Player Profile is returned.  If the returned Player Profile is over 2048 bytes then the profile will be truncated with a property set indicating it has been truncated.  If this occurs you will need to use the profile APIs (either server, client or entity APIs) to retrieve the full profile.

### Azure Function Rules

Azure Functions can also be called by creating rules and scheduled tasks.  This works in the same way as our standard CloudScript.  To create a rule, go to Automation->Rules  or Automation->Scheduled Tasks.

* Click **New Rule**
* Enter a name for your rule
* Select the event type that this rule will trigger on
* Add an action
* From the action dropdown select **Execute Azure Function**

A list of available Azure Functions that you've registered will be available in the drop-down list.

![Configure Rule for Azure Functions](media/azure_function_rules.jpg)

### Debugging your Azure Function

With Azure Functions, you can now test and debug your CloudScript code locally.  Here is a great guide on how to [test and debug your Functions](https://docs.microsoft.com/azure/azure-functions/functions-develop-local) locally.

Here are some highlights from the above document.

* Make sure that your Azure Functions Core Tools are installed.
* Configure your [Local Settings File](https://docs.microsoft.com/azure/azure-functions/functions-develop-vs-code?tabs=nodejs#local-settings-file)
* Set a break point in your code
* Select **F5** to start debugging


text:
# [Scoop](https://scoop.sh/) Directory

[![update-index](https://github.com/rasa/scoop-directory/actions/workflows/update-index.yml/badge.svg)](https://github.com/rasa/scoop-directory/actions/workflows/update-index.yml) <!--
--> [![Build Status](https://ci.appveyor.com/api/projects/status/github/rasa/scoop-directory?svg=true)](https://ci.appveyor.com/project/rasa/scoop-directory "Build Status") <!--
--> [![Chat on Gitter](https://badges.gitter.im/lukesampson/scoop.svg)](https://gitter.im/lukesampson/scoop) <!--
--> [![Software License](https://img.shields.io/badge/license-MIT-brightgreen.svg?style=flat-square)](LICENSE) <!--
--> [![Mentioned in Awesome Scoop](https://awesome.re/mentioned-badge.svg)](https://github.com/h404bi/awesome-scoop/blob/master/README.md "Awesome Scoop")

View the Scoop Directory sorted by:

[bucket name](https://rasa.github.io/scoop-directory/by-bucket) | [number of apps](https://rasa.github.io/scoop-directory/by-apps) | [number of stars](https://rasa.github.io/scoop-directory/by-stars) | [number of forks](https://rasa.github.io/scoop-directory/by-forks) | [last updated](https://rasa.github.io/scoop-directory/by-date-updated) | [GitHub score](https://rasa.github.io/scoop-directory/by-score) ([deprecated](#Deprecated-pages)) |

The above pages are updated daily.

There are several Scoop application manifest search tools:

1. [scoop-docs.now.sh](https://scoop-docs.now.sh/apps/) searches the [known](https://github.com/lukesampson/scoop#known-application-buckets) Scoop buckets for apps (as well as other well known buckets). Created by [@kidonng](https://github.com/kidonng).

2. [shovel.sh](https://shovel.sh/search) searches just the [known](https://github.com/mertd/shovel-data/blob/ad6133a10cd9f9f2d6e4a674542c429c5ce70209/shovel.go#L45) buckets. Created by [@mertd](https://github.com/mertd).

3. [scoop-search](https://github.com/zhoujin7/scoop-search) is a command line utility that searches the buckets found by scoop-directory. It works with another command-line tool, called [crawl-scoop-directory](https://github.com/zhoujin7/crawl-scoop-directory), which scans the bucket lists and compiles a [Sqlite3 database](https://github.com/zhoujin7/crawl-scoop-directory/blob/master/scoop_directory.db) which can be downloaded from [here](https://github.com/zhoujin7/crawl-scoop-directory/raw/master/scoop_directory.db). Created by [@zhoujin7](https://github.com/zhoujin7).

4. [scoop-search](https://github.com/shilangyu/scoop-search) is another command line search utility utility. It can be installed via `scoop install scoop-search` It  searches the buckets installed locally via `scoop bucket add [bucketname]`. Created by [@shilangyu](https://github.com/shilangyu).

## Notes

A few buckets are excluded as they duplicate other buckets. The list of excluded buckets is [here](https://github.com/rasa/scoop-directory/blob/master/maintenance/github-crawler.py#L135).

## Deprecated pages

The [GitHub score](https://rasa.github.io/scoop-directory/by-score) page is deprecated as the GitHub API returns a score of `1` for every search result.

repository: skyhoshi/scoop-directory

repo_name: skyhoshi/scoop-directory


text:
# OFunction - setParameters()

Defines the parameters used by the function.

## Function Parameters

Functions can take parameters and perform various operations based on the specific things you pass to them.  In order to call an parameter from your function code, you need to have the parameters defined for the [`OFunction`](../OFunction.md) instance.  Using this method you can define a list of parameters available to the function.  To determine what parameters are available to the function, see the [`getParameters()`](getParameters.md) method.

### Syntax

```
OFunction OFunction().setParameters(List<String> params)
```

| Argument | Type | Description |
|---|---|---|
| **`params`** | `List<String>` | Defines the parameters the function receives when called |

#### Return Type

This method returns the updated [`OFunction`](../OFunction.md) instance, which you may find useful when stringing several operations together.

repository: orientechnologies/orientdb-docs

gha_language: CSS

repo_name: orientechnologies/orientdb-docs


text:
# cdk-github-stats-construct

[![NPM Link](https://img.shields.io/npm/v/cdk-github-stats-construct)](https://www.npmjs.com/package/cdk-github-stats-construct)

This is a monorepo containing the code for this CDK construct in `src` and an example app in `example`.

## Installation

```shell
npm install cdk-github-stats-construct
```

repository: lannonbr/cdk-github-stats-construct

repo_name: lannonbr/cdk-github-stats-construct