text:
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
[![Python 3.6](https://img.shields.io/badge/python-3.6-green.svg)](https://www.python.org/)
[![PyTorch 1.0](https://img.shields.io/badge/pytorch-1.0-green.svg)](https://pytorch.org/)

# Exploiting Temporal Consistency for Real-Time Video Depth Estimation
This is the UNOFFICIAL implementation of the paper [***Exploiting Temporal Consistency for Real-Time Video Depth Estimation***](https://arxiv.org/abs/1908.03706), ***ICCV 2019, Haokui Zhang, Chunhua Shen, Ying Li, Yuanzhouhan Cao, Yu Liu, Youliang Yan.***

You can find official implementation (WITHOUT TRAINING SCRIPTS) [here](https://github.com/hkzhang91/ST-CLSTM).

## Framework
![](./assert/framework.png)

## Dependencies
- [Python3.6](https://www.python.org/downloads/)
- [PyTorch 1.0+](https://pytorch.org/)
- [NYU Depth v2](https://cs.nyu.edu/~silberman/datasets/nyu_depth_v2.html)

## Pre-processed Data
We didn't preprocess data as in the official implementation. Instead, we use the dataset shared by [Junjie Hu](https://github.com/JunjH/Revisiting_Single_Depth_Estimation), which is also used by [SARPN](https://github.com/Xt-Chen/SARPN/blob/master/README.md).
You can download the pre-processed data from [here](https://drive.google.com/file/d/1WoOZOBpOWfmwe7bknWS5PMUCLBPFKTOw/view?usp=sharing).

When you have downloaded the dataset, run the following command to creat training list.
```bash
python create_list_nyuv2.py
```

You can also follow the procedure of [ST-CLSTM](https://github.com/hkzhang91/ST-CLSTM) to preprocess the data. It is based on the oficial Matlab [Toolbox](https://cs.nyu.edu/~silberman/datasets/nyu_depth_v2.html). If Matlab is unavailable for you, there is also a [Python Port Toolbox](https://github.com/GabrielMajeri/nyuv2-python-toolbox) for processing the raw dataset by [GabrielMajeri](https://github.com/GabrielMajeri), which contains code for Higher-level interface to the labeled subset, Raw dataset extraction and preprocessing and Performing data augmentation.

The final folder structure is shown below.
```
data_root
|- raw_nyu_v2_250k
| |- train
| | |- basement_0001a
| | | |- rgb
| | | | |- rgb_00000.jpg
| | | | |_ ...
| | | |- depth
| | | | |- depth_00000.png
| | | | |_ ...
| | |_ ...
| |- test_fps_30_fl5_end
| | |- 0000
| | | |- rgb
| | | | |- rgb_00000.jpg
| | | | |- rgb_00001.jpg
| | | | |- ...
| | | | |- rgb_00004.jpg
| | | |- depth
| | | | |- depth_00000.png
| | | | |- depth_00001.png
| | | | |- ...
| | | | |- depth_00004.png
| | |- ...
| |- test_fps_30_fl4_end
| |- test_fps_30_fl3_end>
```
## Train
As an example, use the following command to train on NYUDV2.

```bash
CUDA_VISIBLE_DEVICES="0,1,2,3" python train.py --epochs 20 --batch_size 128 \
                        --resume --do_summary --backbone resnet18  --refinenet R_CLSTM_5 \
                        --trainlist_path ./data_list/raw_nyu_v2_250k/raw_nyu_v2_250k_fps30_fl5_op0_end_train.json \
                        --root_path ./data/ --checkpoint_dir ./checkpoint/ --logdir ./log/
```
## Evaluation
Use the following command to evaluate the trained model on ST-CLSTM [test data](https://github.com/hkzhang91/ST-CLSTM).

```bash
CUDA_VISIBLE_DEVICES="0" python evaluate.py --batch_size 1  --backbone resnet18  --refinenet R_CLSTM_5 --loadckpt ./checkpoint/ \
                        --testlist_path ./data_list/raw_nyu_v2_250k/raw_nyu_v2_250k_fps30_fl5_op0_end_test.json \
                        --root_path ./data/st-clstm/
```
## Pretrained Model
You can download the pretrained model: [NYUDV2](https://github.com/hkzhang91/ST-CLSTM/tree/master/CLSTM_Depth_Estimation-master/prediction/trained_models).

## Citation

```bibtex
@inproceedings{zhang2019temporal,
             title = {Exploiting Temporal Consistency for Real-Time Video Depth Estimation},
             author = {Haokui Zhang and Chunhua Shen and Ying Li and Yuanzhouhan Cao and Yu Liu and Youliang Yan},
             conference={International Conference on Computer Vision},
             year = {2019}
}
```


text:
Change log
==========

## February 27, 2014 - v1.1.2

 * In JavaScriptEngineSwitcher.Msie added support of MSIE JavaScript Engine version 1.4.0

## January 17, 2014 - v1.1.1

 * In JavaScriptEngineSwitcher.V8 added support of the [ClearScript](http://clearscript.codeplex.com/) version 5.3.11 (support of V8 version 3.24.17)

## January 16, 2014 - v1.1.0

 * In JavaScriptEngineSwitcher.Msie added support of [MSIE JavaScript Engine](http://github.com/Taritsyn/MsieJavaScriptEngine) version 1.3.0
 * In JavaScriptEngineSwitcher.V8 improved performance of `CallFunction` method
 * In JavaScriptEngineSwitcher.Jurassic added support of [Jurassic](http://jurassic.codeplex.com/) version of January 11 2014

## December 30, 2013 - v1.0.0

 * Added support of JavaScript `undefined` type
 * In JavaScriptEngineSwitcher.Msie added support of [MSIE JavaScript Engine](http://github.com/Taritsyn/MsieJavaScriptEngine) version 1.2.0

## December 7, 2013 - v0.9.5

 * In JavaScriptEngineSwitcher.V8 the [Noesis Javascript .NET](http://javascriptdotnet.codeplex.com/) was replaced by the [Microsoft ClearScript.V8](http://clearscript.codeplex.com/) library (solves a problem of `V8JsEngine` stable work on 64-bit version of IIS 8.X)
 * In JavaScriptEngineSwitcher.Jurassic added support of [Jurassic](http://jurassic.codeplex.com/) version of September 30 2013

## November 19, 2013 - v0.9.3

 * In JavaScriptEngineSwitcher.V8 changed a mechanism for loading the Noesis Javascript .NET assemblies for different processor architectures
 * Deleted a `/configuration/jsEngineSwitcher/v8` configuration section

## September 5, 2013 - v0.9.2

 * Added JavaScriptEngineSwitcher.ConfigurationIntelliSense NuGet package

## September 4, 2013 - v0.9.0
 * Initial version uploaded

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
# GSOC_TensorCore
TensorCore Vector Processor for Deep Learning - Google Summer of Code Project
![GSoC - Vertical Wide - Gray Text - White BG](https://user-images.githubusercontent.com/61764809/130463041-5dd7a87e-301f-40c8-8e96-9870d8a67aa6.png)

## Project Description
This project focuses on implementing a Deep Learning hardware accelerator called TensorCore - which is a Vector Processor based on v0.10 of the open source RISCV Vector ISA.
It is expected to serve as a proof-point for a Deep Learning research platform to experiment with tensor operators and custom number systems. The focus is on delivering core instructions required for deep learning and linear algebra applications. This design can be used as a starting point to study tensor core based designs to accelerate Deep learning workloads at greater scale.

## Project Goals
1. Research the architecture and micro-architecture details of vector processor and study currently available commercial and academic vector processors geared towards DL
   computations.
2. Micro-architecture design and implementation of a simple open-source Tensor Core RISC-V accelerator to serve as a proof of concept -which can then be used as a starting point
   for students to learn about the architecture and design of vector processor for deep learning as most of the available designs are either commercially licensed or complex for
   students at university level to appreciate the advantages of vector processors for these applications.
3. Create a test bench for executing the tests on our implementation and validate the core design in simulation - eg., SAXPY, dot product, etc.
4. To serve as a proof-point for a Deep Learning research platform to experiment with tensor operators (like fused dot products)and custom number systems(like Posits) . This
   design can be later used/modified to study tensor core based designs to accelerate Deep learning workloads at greater scale with custom instructions.

To achive these goals, The TensorCore vector execution engine needs to supports the following instructions - \
a. Vector load
b. Vector load
c. Vector scale (VS operation)
d. Vector add (VV or VS)
e. Vector dot product (DOT)

## Goals Achieved
We've been able to design the micro-architecture of a singe lane and single VFU based Vector Processor. Currently,our design the supports the following instructions completely -\
a. Vector 32 element load\
b. Vector 32 element store\
c. Vector Scale (or VS multiply)\
d. Vector Multiplication (or VV multiply)\
e. Vector Addition (both VS and VV)

## Running the SAXPY example
The SAXPY is one of the most common vector operations frequently encountered in linear algebra applications. Our SAXPY test is described as follows -
1. Load a scalar value of '2' into the scalar register file address location 0x2.
2. Load vector register 0x1 with 32 elements in the following pattern - (4, 3, 2, 1, 4, 3, 2, 1……, 4, 3, 2, 1).
3. Load vector register 0x2 with 32 elements  in the following pattern - (-8, -6, -4, -2, -8, -6, -4, -2, ……, -8, -6, -4, -2).
4. Compute the VS product between the scalar value in 0x2 of scalar RF with each element of vector register 0x1. Store the result back in vector register 0x2. Now the VR 0x1 has
   values (8, 6, 4, 2, 8, 6, 4, 2, ….).
5. Compute vector addition (VV) between vector registers 0x1 and 0x2 and store the result back into vector register 0x3. Since the values are complements, the ALU output of this
   operation and final result stored in vector register 0x3 will be 0s in all 32 elements.
6. Store this result from vector register 0x3 into memory using store operation. Since the memory interface is not a part of this project, the data is stored in a queue from which
   it can be transferred to a memory.

The test bench can be modified or other tests can be added to run other workloads that use the above defined operations.

##### Note - a hex value of 0xdead_dead on a signal implies "invalid value" and hence is not used for any computation. Signals having invalid values indicate that they're not active in that time period.

## Caveats
1. In the current implementation, the decoder, load and store unit are all implemented in the "sequencer module" - for the basic operations that are required for this project. A
   more extensive decoder implementation can be found in the TLV directory
2. The current v0.10 of the RISCV Vector spec does not define the instruction encoding of a VV Integer dot product. To implement this, we've defined our own custom encoding for
   this operation. The dot product instruction implementation is still under progress although the elementary operations required to compute the dot product are already supported
3. The current design works on vectors with LMUL = 1 and elements with 32 bit precision only. The RISCV Vector extension supports elements with multiple bit precisions and
   multiple ways of grouping elements using different LMUL values. This will be the next goal for future work
4. Since the design is still a work in progress, some additional control flow signals are included in the design to control the execution of of some operations explicitly from the
   test bench. These signals have been referred as such in the comments wherever appropriate. Later, the sequencer and the decoder will communicate directly using internal signals
   without any explicit control through the test bench.

## Future Work
1. Implement the dot product(DP) and the fused dot product (FDP) instruction with Reproducible Computation & Rounding Approach.
   Reproducible computation requires control over rounding decisions. The fused dot product uses a quire to defer rounding till the end of the dot product. The cycle time of the
   quire needs to be balanced with the throughput of the multiply unit. The benefit of the quire is that the precision demands of the source number system are reduced. Research
   has shown that a 32-bit floating-point fused-dot product (FDP) can beat the precision of a 64-bit floating-point that uses fused-multiply-add (FMA).
2. To exploit the full potential of vector processors, we need to execute multiple instructions in parallel. This would require each lane to have multiple pipelined VFUs geared
   towards specific numerical operations(integer, floating point)and multiple such lanes to perform 4–8 parallel operations.
3. Complete the TLV implementation of the design and test it using the sandpiper-verilator test infrastructure - to demonstrate the power of TLV to easily implement pipelined VFUs
   and create a design that is much less verbose and less prone to bugs.

## Contributions and link to future work
This repository is a culmination of the GSOC 2021 project. Hence, it cannot be modified after the end of the programme. All the future work and modifications will be carried out in a spearate public repository the link to which I'll be adding at the end of the GSOC Programme.

## Bug reporting
We've tested the design with SAXPY and multiple other examples. But a design of this scope is still prone to bugs as we've not been able to perform extesive Verification. All the bugs/improvements cab be reported to<EMAIL_ADDRESS>We greatly appreciate your contributions in this regard.

## Contributors
Theodore Omtzigt (https://github.com/stillwater-sc), Primary Mentor\
Akos Hadnagy (https://github.com/ahadnagy), Secondary Mentor\
Steve Hoover (https://github.com/stevehoover), Advisor\
Nitin Mishra, Design & Verification Engineer

branch_name: refs/heads/main


text:
---
layout: paper
categories: papers
permalink: papers/shapeshop
title: ShapeShop
---

# ShapeShop: Towards Understanding Deep Learning Representations via Interactive Experimentation
[Fred Hohman][fred], [Nathan Hodas][nathan], [Duen Horng Chau][polo]

        The ShapeShop system user interface is divided into two main sections.
        The Model Builder (top) contains the training data, model, and hyperparameter selection options where a user follows enumerated steps, concluding with the system building and training an N-image classifier, where each training image selected corresponds to one class.
        In the Experiment Results section (bottom), each time the "Train and Visualize" button is clicked a new set of results appears including the class activation maximization of each class.

## Abstract
Deep learning is the driving force behind many recent technologies; however, deep neural networks are often viewed as "black-boxes" due to their internal complexity that is hard to understand.
Little research focuses on helping people explore and understand the relationship between a user's data and the learned representations in deep learning models.
We present our ongoing work, ShapeShop, an interactive system for visualizing and understanding what semantics a neural network model has learned.
Built using standard web technologies, ShapeShop allows users to experiment with and compare deep learning models to help explore the robustness of image classifiers.

## Materials
[PDF][17-shapeshop-chi-pdf] | Video ([Polo Club][17-shapeshop-chi-video-poloclub], [CHI][17-shapeshop-chi-video-chi]) | [Github][17-shapeshop-chi-github] | [Poster][17-shapeshop-chi-poster] | [BibTeX][17-shapeshop-chi]

## Citation
**[ShapeShop: Towards Understanding Deep Learning Representations via Interactive Experimentation][17-shapeshop-chi]**
[Fred Hohman][fred], [Nathan Hodas][nathan], [Duen Horng Chau][polo]
*Late-Breaking Work, ACM Conference on Human Factors in Computing Systems (CHI). May 6-11, 2017. Denver, CO, USA.*

[PDF][17-shapeshop-chi-pdf] | Video ([Polo Club][17-shapeshop-chi-video-poloclub], [CHI][17-shapeshop-chi-video-chi]) | [Github][17-shapeshop-chi-github] | [Poster][17-shapeshop-chi-poster] | [BibTeX][17-shapeshop-chi]

## BibTeX
```
@inproceedings{hohman2017shapeshop,
  title={ShapeShop: Towards Understanding Deep Learning Representations via Interactive Experimentation},
  author={Hohman, Fred and Hodas, Nathan and Chau, Duen Horng},
  booktitle={Proceedings of the 2017 CHI Conference Extended Abstracts on Human Factors in Computing Systems},
  pages={1694--1699},
  year={2017},
  organization={ACM}
}
```

[fred]: http://fredhohman.com "Fred Hohman"
[nathan]: https://signatures.pnnl.gov/bios/nathan-hodas "Nathan Hodas"
[polo]: http://www.cc.gatech.edu/~dchau/ "Polo Chau"

[17-shapeshop-chi-pdf]: {{ site.url }}/papers/17-shapeshop-chi.pdf
[17-shapeshop-chi-video-poloclub]: https://www.youtube.com/watch?v=XL3fFwZ1DDQ&feature=youtu.be
[17-shapeshop-chi-video-chi]: https://www.youtube.com/watch?v=wRX1xEdrD1g
[17-shapeshop-chi-github]: https://github.com/fredhohman/shapeshop
[17-shapeshop-chi-poster]: {{ site.url }}/papers/17-shapeshop-chi-poster.pdf
[17-shapeshop-chi]: {{ site.url }}/papers/shapeshop

license: MIT

repository: shangtse/homepage

repo_name: shangtse/homepage


text:
# azure-nsg-ban-ips
Block attacker IPs for some days, perfect for Azure Kubernetes (AKS).a

This is much better than banning IPs e.g. in NGINX,
because attackers don't reach any services at all.

Node.js: [npm package](https://www.npmjs.com/package/azure-nsg-ban-ips)

# Usage: Code

```javascript
const nsg = require( 'azure-nsg-ban-ips' )

nsg.login( SERVICE_PRICIPAL_ID, SECRET_KEY, AAD_ID, SUBSCRIPTION_ID, RESSOURCE_GROUP, NSG_NAME )

// clean up and keep ban rules 4 days
await nsg.cleanupOldBlacklists( 4 )

// add IPs to todays blacklist
let todaysBlacklist = await nsg.addIpAddrArrToBlacklist( ['<IP_ADDRESS>','<IP_ADDRESS>'] )
console.log( 'Todays IPs', todaysBlacklist )
```

Details: see [example.js](example.js)

# Usage: Container

There is a ready to use
- Node.js App
- [Docker Container](https://hub.docker.com/r/mahade70/aks-nsg-ingress-ban-ip)
- Kubernetes Pod (using the Docker container)
here: https://github.com/ma-ha/aks-nsg-ingress-ban-ip

This reads the NginX Ingress Controller logs, identify attacks and bans the IP addresses in the NSG.

CI code is provided for easy end-to-end set up of EventHub, LogAnalytics log feed-out etc.

# API

Init and get credentials for all following operations first:
```javascript
login( SERVICE_PRICIPAL_ID, SECRET_KEY, AAD_ID, SUBSCRIPTION_ID, RESSOURCE_GROUP, NSG_NAME )
```

Clean up NSG rules. Optional parameter: keep ban rules X days, default is 2, max is 13:
```javascript
cleanupOldBlacklists()
cleanupOldBlacklists( 4 )
```

Add IP array to todays NSG rule. Returns an array of banned IPs in todays NSG rule.
```javascript
addIpAddrArrToBlacklist( IP_ADDRESS_ARRAY )
```

Read and return all secuirity rules in the NSG:
```javascript
getNsgRules()
```
Set the base prio number for blacklist rules, e.g.
```javascript

setNsgBasePrioConfig( 1234 )
```

# Behind the Scenes

This package creates NSG security rules, for example for the NSG which comes with your AKS.

About the rules:
- one rule is created per day
- rule names are `blacklistYYYYMMDD`, for example `blacklist20201108`
- rules use prio 1000...1365 (1000 + day in year)
- rule description field contains `created by blacklist job`

The description is also used as a filter in the `cleanupOldBlacklists()`
to identify old blacklists to delete.

If you need to set up whitelist rules, you should use a prio with e.g. 200.

repository: ma-ha/azure-nsg-ban-ips

repo_name: ma-ha/azure-nsg-ban-ips


text:
# Susi oh-my-zsh theme

![alt text](https://github.com/carcruz/susi-zsh-iterm/blob/master/preview.png)

## Installation

### Theme

Drop susi.zsh-theme into the ~/.oh-my-zsh/custom/themes/ directory (simply create the themes directory if it does not exist)
Change the theme variable name to ZSH_THEME="susi" in ~/.zshrc
Reload ZSH with source ~/.zshrc

### Colors

Open Preferences pane on the Profiles tab in iTerm
Switch to the Colors tab and import the susi.itermcolors (drop-down in the lower right corner)

by carcruz

repository: withfig/plugins

gha_language: TypeScript

gha_license_id: MIT

repo_name: withfig/plugins


text:
[![build](https://travis-ci.com/chxzqw/imagescraper.svg?branch=master)](https://travis-ci.com/chxzqw/imagescraper#)
[![License: MIT](https://img.shields.io/badge/License-MIT-brightgreen.svg)](https://github.com/chxzqw/imagescraper/blob/master/LICENSE)
![Project-status](https://img.shields.io/badge/Status-experimental-red.svg)
![project-version](https://img.shields.io/badge/version-0.1.0-red.svg)

# Image Scraper

These scripts aim to do image scraping job from websites especially those which needs logins. Currently the program is still in experimental stage and has only been tested on certain websites. There is no guarantee that it performs well on other ones and you may get banned by using these scripts. Run the program at your own risk.

## Getting Started

### Prerequisites

At this time the program is written and tested by following python branch and packages:

Conda 4.5.11
Scrapy 1.5.1
Pillow 5.3.0
PyYAML 3.13

For Linux please refer to relative documents for installation.

For Windows a Miniconda/Anaconda bundle is preferred and make sure it matches the above Python version.
If it unfortunately encounters a `Microsoft Visual C++ 14.0 is required` error, please consider installing `Unofficial Windows Binaries for Python Extension Packages` from <https://www.lfd.uci.edu/~gohlke/pythonlibs/> for desired packages.
Reference: [Microsoft Visual C++ 14.0 is required (Unable to find vcvarsall.bat)](https://stackoverflow.com/questions/29846087/microsoft-visual-c-14-0-is-required-unable-to-find-vcvarsall-bat)

### Installing

After installing dependent libraries, create the project folder in which run
`git clone https://github.com/chxzqw/imagescraper.git`

## Usage

Find the `etc/sample.conf.yaml`, copy and rename the file to `conf-name.conf.yaml` which is then opened with preferred text editor and alter the settings to meet your demand.
In the project folder, run:
`scrapy crawl imagespider -a site=<conf-name>`

Options in <conf-name>.conf.yaml:
* `login_info`: usually includes login name and password, and some other required fields such like token, security question and answer ,etc.
* `page_urls`: urls of pages which holds the images need to be scraped.
* `image_url_match_pattern`: a regex string represents desired images' urls on the web pages.
* `save_dir`: desired save folder for scraped images and is able to contain python-like date time format, e.g. `{%Y%m%d}`
* `file_rename_pattern`: A regex string represents the file name part of the original image url which needs to be searched and renamed later.
* `file_rename_string`: A regex string used to rename the above file name. It supports python-like date time format as well, e.g. `{%Y%m%d}`

## Running the tests

In the project folder just run:
`python -m unittest tests.test_suite_imagescraper`

## Versioning

`0.1.0`

## Known issues

* lack of a proper scraping sandbox website as good example.
* Due to missing proper compiled package Twisted in standard python environment, this project uses Miniconda instead.

## Authors

* **Sid Chen** - *Initial work* - [chxzqw](https://github.com/chxzqw)

## License

MIT

repository: chxzqw/imagescraper

repo_name: chxzqw/imagescraper


text:
# laminarCommCharacterize
Zenodo Concept DOI: [![Concept DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.6526365.svg)](https://doi.org/10.5281/zenodo.6526365)

Characterize Communication Patterns used by Laminar

This is primarily a revision and extension of the core-core benchmark in https://github.com/ucb-cyarp/benchmarking

It is written purely in C to best match the code emitted by Laminar.  It is also simplified.

It focuses on measuring the achieved data rates of the communication style used by Laminar.

## Versions:
**NOTE: Different benchmarking techniques are stored in different branches of the git repository, current versions include:**
  - main: Standard FIFO with `__builtin_memcpy_inline`
  - builtinMemcpyInlined_tmpAligned: Standard FIFO with `__builtin_memcpy_inline` and aligned temporary
  - myMemcpyAligned: Standard FIFO with my implementation of memcpy with aligned vector intrinsics
  - myMemcpyUnalignedWithAlignedTmp: Standard FIFO with my implementation of memcpy with unaligned vector intrinsics but with an aligned temporary
  - myNonTemporalMemcpyAligned: FIFO using my non-temporal implementation of memcpy
  - myNonTemporalMemcpyAligned-seperateLoadStore: FIFO using my non-temporal implementation of memcpy with seperate functions for load and store to take advantage of elements stored in cache

*Note that duty cycle branches are unfinished.*

**NOTE to Zenodo Users:** Archives are stored with the branch name appended to the version number.  Use the concept DOI [10.5281/zenodo.6526365](https://doi.org/10.5281/zenodo.6526365) and look for the version you are interested in.

## Citing This Software:
If you would like to reference this software, please cite Christopher Yarp's Ph.D. thesis.

*At the time of writing, the GitHub CFF parser does not properly generate thesis citations.  Please see the bibtex entry below.*

```bibtex
@phdthesis{yarp_phd_2022,
	title = {High Speed Software Radio on General Purpose CPUs},
	school = {University of California, Berkeley},
	author = {Yarp, Christopher},
	year = {2022},
}
```

repository: ucb-cyarp/laminarCommCharacterize

repo_name: ucb-cyarp/laminarCommCharacterize


text:
# Exercises with the fetch API

Little exercises to be solved using the fetch API to learn the syntax and to learn how to use a external
API and to use the data to change the DOM.

## Resources

- [Using the jsonplaceholder API](https://jsonplaceholder.typicode.com/guide/)
- [JavaScript.info: Fetch](https://javascript.info/fetch)
- [MDN: Fetch API](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API/Using_Fetch)
- [Web Dev Simplified: Fetch API in 6 minutes](https://www.youtube.com/watch?v=cuEtnrL9-H0)
- [Understanding JavaScript Promises](https://www.digitalocean.com/community/tutorials/understanding-javascript-promises)
- [MDN: Promises](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Using_promises)
- [MDN: Response](https://developer.mozilla.org/en-US/docs/Web/API/Response)

repository: yvlange/js-fetch-exercises

gha_language: HTML

repo_name: yvlange/js-fetch-exercises


text:
one day, toolpath will generate toolpaths.
--

For now, though, toolpath slices a model into slices of configurable height and
visualizes the perimeters of the slices. Run it with:

    make -j4
    ./tp path/to/model.obj

Drive the UI with WASD, Q/E for zooming, and n/p for switching between layers.

repository: haldean/toolpath

repo_name: haldean/toolpath


text:
# OpenAPI Diff action
A GitHub Action to identify differences between Swagger or OpenApi specifications.

## Credits
This GitHub Action is a wrapper for the NPM `openapi-diff` package by Atlassian. See the following links for more information:
- https://www.npmjs.com/package/openapi-diff
- https://bitbucket.org/atlassian/openapi-diff/src

## Usage
```yaml
    steps:
      - name: Check out head branch
        uses: actions/checkout@v2
        with:
          path: head
      - name: Check out master branch
        uses: actions/checkout@v2
        with:
          ref: master
          path: base
      - name: Run OpenAPI Diff (from HEAD revision)
        uses<EMAIL_ADDRESS>        with:
          head-spec: head/spec/openapi.yaml
          base-spec: base/spec/openapi.yaml
```

repository: mvegter/openapi-diff-action

repo_name: mvegter/openapi-diff-action


text:
# Firebase Device Store (iOS SDK)

Automatically store Device and FCM Token information for Firebase Auth Users in Cloud Firestore.

> This library is a proof of concept, and very much a work in progress.

## Installation

TODO

## Example usage

TODO

## Documentation

Firebase Device Store automatically stores device and FCM information for Firebase Auth users in Cloud Firestore.

### Data Model

A Document is created in the Cloud Firestore collection for each logged in user:

```
/user-devices
  - userId1: {},
  - userId2: {},
```

The structure of this Document is as follows:

```
{
  devices: Device[],
  userId: string,
}
```

A `Device` object contains the following:

```
{
  deviceId: string, // The browser name and version
  fcmToken: string, // The FCM token
  name: 'Unknown',  // Web browser's do not provide a name field
  os: string,       // The OS of the device
  type: 'Web'
}
```

### API

#### `FirebaseDeviceStore(app, collectionPath)`

Create a new DeviceStore.

Parameters:

- `app`: `FirebaseApp` the Firebase App to use
- `collectionPath`: (Optional) `string` the Cloud Firestore collection where devices should be stored. Defaults to `user-devices`.

Returns a `FirebaseDeviceStore`.

#### `FirebaseDeviceStore.signOut(): void`

Indicate to the DeviceStore that the user is about to sign out, and the current device token should be removed.

This cannot be done automatically with `onAuthStateChanged` as the user won't have permission to remove the token from Firestore as they are already signed out by this point and the Cloud Firestore security rules will prevent the database deletion.

#### `FirebaseDeviceStore.subscribe(): void`

Subscribe a device store to the Firebase App. This will:

1. Subscribe to Firebase Auth and listen to changes in authentication state
2. Subscribe to Firebase Messaging and listen to changes in the FCM token
3. Automatically store device and FCM token information in the Cloud Firestore collection you specify

#### `FirebaseDeviceStore.unsubscribe(): void`

Unsubscribe the device store from the Firebase App.

### Security rules

You will need to add the following security rules for your Cloud Firestore collection:

```
service cloud.firestore {
  match /databases/{database}/documents {
    // Add this rule, replacing `user-devices` with the collection path you would like to use:
    match /user-devices/{userId} {
      allow create, read, update, delete: if request.auth.uid == userId;
    }
  }
}
```

repository: mikelehen/firebase-device-store-ios-sdk

repo_name: mikelehen/firebase-device-store-ios-sdk


text:
my Glitch is hosted here: a1-eos7l.glitch.me

---
PLEASE USE THIS LINK FOR GRADING:
https://eos7l.github.io/a1-gettingstarted/

For some reason, Glitch doesn't want to use my latest code and keeps rewinding back to the original template. I made sure I imported from Github correctly because my README can be found on glitch. All other files are fine on Glitch except my CSS styling sheets. My CSS files kept getting replaced by the original CSS files that came with the template although I did not do anything to glitch. Also Glitch is supposed to auto-save but it does not want to save the changes even if I tried pasting my styling sheets manually in there. I don't think there is anything wrong with my code because it can be opend up fine on
1) my localhost
2) directly opened as a HTML file
3) with Webstorm.

__Design Achievement__:
- Self-picked every single color used in this project and made up an overall cohesive color palette. My inspo came from LOLColors
- Modified an animated staggering bar chart using another color scheme (original here: https://codepen.io/vajkri/pen/NxzZwL)
- Replacecd the original background with particle.js with some personal modifications. It took me some time to find out how to change the background but only for the main page
- Most elements are animated while the original template is pretty much static (the original template can be found here for comparison: https://startbootstrap.com/previews/resume/)

__Technical Achievement__:
- Learned how to use multiple JQuery/JS/Angular/CSS libraries including:
  - animate on scroll
  - scroll reveal
  - animate.css
  - particles.js
  - typeit.js
- Designed an animated widget box of coursework
- Fully functional on mobile (through bootstrap)
- Fixed bugs with the original template where the email hyperlink malfunctions if the previous textbox inline is not long enough

In Progress:
Currently working on inserting a sticky section title with Waypoint but got stuck and could not figure out why...


text:
# BrightID Anti-Sybil
This package provides a framework to evaluate the quality of different anti-sybil [algorithms](#algorithms), by simulating different [attacks](#attacks) to [BrightID's social graph](https://explorer.brightid.org).

![](https://explorer.brightid.org/charts/compare_graph.png)

*Comparing performance of different algorithms in detecting sybils in different attacks in a dense graph*

You can find more details about performance of different algorithms [here](https://github.com/BrightID/BrightID-AntiSybil/wiki/Compare-Yekta-with-other-anti-sybil-algorithms).

## Algorithms

- [SybilRank](https://github.com/BrightID/BrightID-AntiSybil/blob/master/anti_sybil/algorithms/sybil_rank.py) is a well-known sybil detection algorithm that is based on the assumption that sybils have limited social connections to real users. It relies on the observation that an early-terminated random walk starting from a non-Sybil node in a social network has a higher degree-normalized (divided by the degree) landing probability to land at a non-sybil node than a sybil node.

- [GroupSybilRank](https://github.com/BrightID/BrightID-AntiSybil/blob/master/anti_sybil/algorithms/group_sybil_rank.py) is an enhanced version of the SybilRank algorithm. In this algorithm, a graph is created in which the BrightID groups are nodes  and edges are weighted based on affinity between groups. Then original SybilRank algorithm will be applied to this graph of groups and users get scores from the best group they belong to.

- [WeightedSybilRank](https://github.com/BrightID/BrightID-AntiSybil/blob/master/anti_sybil/algorithms/weighted_sybil_rank.py) is an enhanced version of the SybilRank algorithm that uses the number of common neighbors of the tow connected nodes as weight (trustworthy factor) of the edge.

- [LandingProbability](https://github.com/BrightID/BrightID-AntiSybil/blob/master/anti_sybil/algorithms/landing_probability.py) is the probability of landing of a random walk started from seed nodes on each node of the graph. The result is the same with SybilRank except nodes' ranks are not normalized by dividing them to nodes' degree.

- [NormalizedSybilRank](https://github.com/BrightID/BrightID-AntiSybil/blob/master/anti_sybil/algorithms/normalized_sybil_rank.py) is calculating SybilRank on a normalized graph. To normalize the graph:
  - Each node will be connected to 8 nearest neighbors that are in the same cluster
  - Prevent non-seed nodes from having connections to more than 4 seeds
  - Prevent seeds from having connections to more than 4 nodes in their own clusters and 2 in other clusters

- [ClusterRank](https://github.com/BrightID/BrightID-AntiSybil/blob/master/anti_sybil/algorithms/cluster_rank.py) ranks nodes from 1-5 based on the number of clusters that they have neighbors in.

- [SeednessScore](https://github.com/BrightID/BrightID-AntiSybil/blob/master/anti_sybil/algorithms/seedness_score.py) gives scores to nodes by clustering graph with different resolutions and dividing number of seeds to number of cluster members.

- [Yekta](https://github.com/BrightID/BrightID-AntiSybil/blob/master/anti_sybil/algorithms/yekta.py) rank nodes from 1-5 based on nodes normalized degree. The algorithm decrease the weight for inside edges for the clusters that their number of inside edges are more than average, and then calculate weighted degree for each node.

## Attacks

### Lone Attacks
One attacker attempting to propagate score to the Sybils to verify them by connecting to other nodes and creating groups.
We assumed that an attacker will have one account with a normal or above-average number of direct connections to honest users which they can use for interconnections to sybil accounts.

- One attacker attempts to connect to some of the seed nodes and create some sybil nodes. [implementation](https://github.com/BrightID/BrightID-AntiSybil/blob/e73e1e633585896fd56e025bc5846decde20e793/anti_sybil/tests/attacks/lone_attacks.py#L9) - [graph](https://explorer.brightid.org/graphs/one_attacker_targeting_seeds.html)

- One attacker attempts to connect to some of the top-ranked honests and create some sybil nodes. [implementation](https://github.com/BrightID/BrightID-AntiSybil/blob/e73e1e633585896fd56e025bc5846decde20e793/anti_sybil/tests/attacks/lone_attacks.py#L38) - [graph](https://explorer.brightid.org/graphs/one_attacker_targeting_top_nodes.html)

- One attacker attempts to connect to some of the honests and create some sybil nodes. [implementation](https://github.com/BrightID/BrightID-AntiSybil/blob/e73e1e633585896fd56e025bc5846decde20e793/anti_sybil/tests/attacks/lone_attacks.py#L38) - [graph](https://explorer.brightid.org/graphs/one_attacker_targeting_random_nodes.html)

- One attacker attempts to connect to one of the top-ranked honests and create multiple (duplicate) groups of the sybils. [implementation](https://github.com/BrightID/BrightID-AntiSybil/blob/e73e1e633585896fd56e025bc5846decde20e793/anti_sybil/tests/attacks/lone_attacks.py#L71) - [graph](https://explorer.brightid.org/graphs/one_attacker_group_target_attack.html)

- A seed node attempts to create some sybils nodes. [implementation](https://github.com/BrightID/BrightID-AntiSybil/blob/e73e1e633585896fd56e025bc5846decde20e793/anti_sybil/tests/attacks/lone_attacks.py#L105) - [graph](https://explorer.brightid.org/graphs/one_seed_as_attacker.html)

- An honest node attempts to create some sybils nodes. [implementation](https://github.com/BrightID/BrightID-AntiSybil/blob/e73e1e633585896fd56e025bc5846decde20e793/anti_sybil/tests/attacks/lone_attacks.py#L105) - [graph](https://explorer.brightid.org/graphs/one_honest_as_attacker.html)

### Collaborative Attacks
Multiple attackers attempting to propagate score to the Sybils to verify them by connecting to other nodes and creating groups.
Attackers are able to connect to each other and each others’ sybil accounts in any way.
We assumed that each attacker will have one account with a normal or above-average number of direct connections to honest users which they can use for interconnections to sybil accounts.
All these attacks can be performed by one or more groups of attackers who collaborate together.

- One or more groups of attackers attempt to connect to some of the seeds and create some sybil nodes. [implementation](https://github.com/BrightID/BrightID-AntiSybil/blob/e73e1e633585896fd56e025bc5846decde20e793/anti_sybil/tests/attacks/collaborative_attacks.py#L8)
  - target new and low degree seeds: [graph for single group](https://explorer.brightid.org/graphs/one_group_targeting_seeds.html) - [graph for multiple groups](https://explorer.brightid.org/graphs/n_groups_targeting_seeds.html)
  - target active and high degree seeds: [graph for single group](https://explorer.brightid.org/graphs/one_group_targeting_high_degree_seeds.html) - [graph for multiple groups](https://explorer.brightid.org/graphs/n_groups_targeting_high_degree_seeds.html)

- One or more groups of attackers attempt to connect to some of the top-ranked honests and create some sybil nodes. [implementation](https://github.com/BrightID/BrightID-AntiSybil/blob/e73e1e633585896fd56e025bc5846decde20e793/anti_sybil/tests/attacks/collaborative_attacks.py#L53) - [graph for single group](https://explorer.brightid.org/graphs/one_group_targeting_top_nodes.html) - [graph for multiple groups](https://explorer.brightid.org/graphs/n_groups_targeting_top_nodes.html)

- One or more groups of attackers attempt to connect to some honest and create some sybil nodes. [implementation](https://github.com/BrightID/BrightID-AntiSybil/blob/e73e1e633585896fd56e025bc5846decde20e793/anti_sybil/tests/attacks/collaborative_attacks.py#L53) - [graph for single group](https://explorer.brightid.org/graphs/one_group_targeting_random_nodes.html) - [graph for multiple groups](https://explorer.brightid.org/graphs/n_groups_targeting_random_nodes.html)

- A group of attackers attempts to connect to some of the top-ranked honests  and create multiple (duplicate) groups of the sybils. [implementation](https://github.com/BrightID/BrightID-AntiSybil/blob/e73e1e633585896fd56e025bc5846decde20e793/anti_sybil/tests/attacks/collaborative_attacks.py#L100) - [graph for signle group](https://explorer.brightid.org/graphs/one_group_group_target_attack.html)

- One or more groups of seed nodes attempt to create some sybil nodes. [implementation](https://github.com/BrightID/BrightID-AntiSybil/blob/e73e1e633585896fd56e025bc5846decde20e793/anti_sybil/tests/attacks/collaborative_attacks.py#L142)
  - New and low degree seeds attack: [graph for single group](https://explorer.brightid.org/graphs/one_group_of_seeds_as_attacker.html) - [graph for multiple groups](https://explorer.brightid.org/graphs/n_groups_of_seeds_as_attacker.html)
  - Active and high degree seeds attack: [graph for single group](https://explorer.brightid.org/graphs/one_group_of_high_degree_seeds_as_attacker.html) - [graph for multiple groups](https://explorer.brightid.org/graphs/n_groups_of_high_degree_seeds_as_attacker.html)
  - Seeds disconnected from non-sybil nodes attack: [graph for single group](https://explorer.brightid.org/graphs/one_group_of_disconnected_seeds_as_attacker.html) - [graph for multiple groups](https://explorer.brightid.org/graphs/n_groups_of_disconnected_seeds_as_attacker.html)

- One or more groups of honest nodes attempt to create some sybil nodes. [implementation](https://github.com/BrightID/BrightID-AntiSybil/blob/e73e1e633585896fd56e025bc5846decde20e793/anti_sybil/tests/attacks/collaborative_attacks.py#L142) - [graph for single group](https://explorer.brightid.org/graphs/one_group_of_honests_as_attacker.html) - [graph for multiple groups](https://explorer.brightid.org/graphs/n_groups_of_honests_as_attacker.html)

- A group of seed nodes attempt to create some sybil nodes by creating a group per sybil node and all seed nodes join that group. [implementation](https://github.com/BrightID/BrightID-AntiSybil/blob/e73e1e633585896fd56e025bc5846decde20e793/anti_sybil/tests/attacks/collaborative_attacks.py#L232) - [graph](https://explorer.brightid.org/graphs/many_small_groups_attack.html)

- A group of seed nodes attempt to create multiple clusters and connect sybils in each cluster to random sybils in other clusters. [implementation](https://github.com/BrightID/BrightID-AntiSybil/blob/e73e1e633585896fd56e025bc5846decde20e793/anti_sybil/tests/attacks/collaborative_attacks.py#L185) - [graph](https://explorer.brightid.org/graphs/multi_cluster_attack.html)

### Manual attack
This is a way to manually add new nodes/edges/groups to the BrightID graph and see how different algorithms rank those nodes. You can use `MANUAL_ATTACK_OPTIONS` variable in the [config.py](https://github.com/BrightID/BrightID-AntiSybil/blob/master/anti_sybil/tests/attacks/config.py) file to define the manual attack. This example adds 3 sybil nodes, connect them to `xGUyVQLYV80pajm8QP-9cfHC7xri49V58k02kqTAiUI` as attacker and add them to a new group. [graph for this manual attack](https://explorer.brightid.org/graphs/manual_attack.html)

    MANUAL_ATTACK_OPTIONS = {
        'top': True,
        'connections': [
            ['xGUyVQLYV80pajm8QP-9cfHC7xri49V58k02kqTAiUI', 'sybil1'],
            ['xGUyVQLYV80pajm8QP-9cfHC7xri49V58k02kqTAiUI', 'sybil2'],
            ['xGUyVQLYV80pajm8QP-9cfHC7xri49V58k02kqTAiUI', 'sybil3'],
            ['sybil1', 'sybil2'],
            ['sybil1', 'sybil3'],
        ],
        'groups': {
            'new_group_1': [
                'sybil1',
                'sybil2',
                'sybil3'
            ]
        }
    }

## Install
    $ git clone https://github.com/BrightID/BrightID-AntiSybil.git
    $ cd BrightID-AntiSybil
    $ pip3 install .

## Running Tests

You can configure the algorithms and attacks you want to test by editing the [config.py](https://github.com/BrightID/BrightID-AntiSybil/blob/master/anti_sybil/tests/attacks/config.py) file in `anti_sybil/tests/attacks/config.py` and then run the tests by

    $ python3 anti_sybil/tests/attacks/run.py

The result will contain:
- An interactive graph ([example](https://explorer.brightid.org/graphs/n_groups_targeting_top_nodes.html)) per algorithm/attack that visualize the graph and scores each sybil/attacker/honest node achieved

![](https://explorer.brightid.org/assets/graph.gif)

- A CSV file ([example](https://explorer.brightid.org/assets/result.csv)) that has a column per algorithm/attack and provide following information for each algorithm/attack

|Results                   |GroupSybilRank one group group target attack|
|--------------------------|--------------------------------------------|
|No. Successful Honests    |416                                         |
|Successful Honests Percent|78.1954887218045                            |
|Sybils scored >= %        |0.080091533180778                           |
|Avg Honest - Avg Sybil    |17.4819290581162                            |
|Max Seed                  |100                                         |
|Avg Seed                  |59.6248484848485                            |
|Min Seed                  |31.88                                       |
|Max Honest                |100                                         |
|Avg Honest                |29.3145290581162                            |
|Min Honest                |0                                           |
|Max Attacker              |13.96                                       |
|Avg Attacker              |13.96                                       |
|Min Attacker              |13.96                                       |
|Max Sybil                 |13.96                                       |
|Avg Sybil                 |11.8326                                     |
|Min Sybil                 |5.87                                        |
|Border                    |14                                          |

- A chart to compare effectiveness of different anti-sybil algorithms to detect sybils in different attacks
![](https://explorer.brightid.org/charts/compare_graph.png)

## Old Version
The old version of BrightID Anti-Sybil algorithms, tests and documents can be found [here](https://github.com/BrightID/BrightID-AntiSybil/tree/py2).

license: ISC

repository: pezzdoge/BrightID-AntiSybil

repo_name: pezzdoge/BrightID-AntiSybil


text:
---
layout: default
---

# 1996-04-11 - liibulletin - Announcement of New Related Services (fwd)

## Header Data

From: Rich Graves<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: eac968df9e55ada1a10dfba93dc6909951881c08de5ab5dff3a4713bde3296d4

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1996-04-11 23:22:58 UTC

Raw Date: Fri, 12 Apr 1996 07:22:58 +0800

## Raw message

```
{% raw  %}From: Rich Graves<EMAIL_ADDRESS>Date: Fri, 12 Apr 1996 07:22:58 +0800
To<EMAIL_ADDRESS>Subject: liibulletin - Announcement of New Related Services (fwd)
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

I have no joke. I just like saying, "barratry.law.cornell.edu." Oh, and
the full-text availability of recent net.relevant decisions (numero dos)
should be useful to somebody.

So how do I get to be the Unabomber's pen pal? Hmm, what jail was he in
again? I wonder if they'll accept packages for him with excessive postage.

-rich
 and now, back to bilingual 9-bit-punks

---------- Forwarded message ----------
Date: Thu, 11 Apr 1996 12:13:36 -0400
From: "Peter W. Martin"<EMAIL_ADDRESS>To: Multiple recipients of list<EMAIL_ADDRESS>Subject: liibulletin - Announcement of New Related Services

[...]
The announcement:
================================================================
                                             April 11, 1996

Two New Services from Cornell's Legal Information Institute

I. Landmark Supreme Court Decisions

 Cornell's Legal Information Institute is pleased to announce the
addition of important "new" decisions to its Supreme Court collection.
Under a license, recently concluded with InfoSynthesis, publishers of
the USSC+ CD-ROM, the LII will be placing a steadily growing number of
historic decisions on its WWW server.  The first of these historic
decisions are now in place, including: Brown v. Board of Education (I
and II), New York Times v. Sullivan, The "Pentagon Papers" case, and
Bakke.  These join an existing collection of important decisions dealing
with privacy, the First Amendment, administrative law, patents, and
copyright.
 All decisions in this collection carry links to current U.S. Court of
Appeals decisions in which they are cited (using the LII's full-text
index of Court of Appeals decisions on the Net) and to other related
documents in the LII collection (e.g., statutes, topical summaries, the
Constitution).
 The "new" cases are accessible from the base address for Supreme Court
materials
  http://www.law.cornell.edu/supct/
or directly at
  http://www.law.cornell.edu/supct/cases/historic.htm
Additions will follow on a regular basis.

II. LII's Eye on the Courts

 Joining the current awareness services already offered by Cornell's LII
-- BigEar (http://barratry.law.cornell.edu:5123/notify/buzz.html),
liibulletin and liibulletin-ny (see
 http://www.law.cornell.edu/focus/bulletins.html) -- is a new WWW page
providing links to newsworthy decisions handed down by any of the many
appellate courts now covered on the Net, along with relevant
background, when available. LII's Eye on the Courts can be found at
  http://www.law.cornell.edu/focus/liieye.htm
================================================================

{% endraw %}
```

## Thread

+ Return to [April 1996](/archive/1996/04)

+ Return to "[Rich Graves <llurch@networking.stanford.edu>](/authors/rich_graves_llurch_at_networking_stanford_edu_)"

+ 1996-04-11 (Fri, 12 Apr 1996 07:22:58 +0800) - liibulletin - Announcement of New Related Services (fwd) - _Rich Graves<EMAIL_ADDRESS>


text:
---
title: View currently executing tasks in tsqlScheduler
shareimage: "./CurrentlyExecutingTasks.png"
tags: [SQL, tsqlScheduler]
date: "2017-09-03T00:00:00.0Z"
# cSpell:ignore InstanceId executesql binarypayload TaskId IsJson datediff DMVs openjson
---

[tsqlScheduler 1.0](https://github.com/taddison/tsqlScheduler/releases/tag/1.0) was released today, and now contains a feature which allows you to view currently running tasks by storing information about that task in [context_info](https://docs.microsoft.com/en-us/sql/t-sql/functions/context-info-transact-sql).

The view **scheduler.CurrentlyExecutingTasks** can be queried and joined back to the core tables to produce results that tell us at a glance how long the task has been running for, and how long it took last time.

```sql
select	te.StartDateTime
		,datediff(second,te.StartDateTime, getutcdate()) as DurationSeconds
		,t.Identifier
		,lastResult.StartDateTime as LastStartTime
		,datediff(second,lastResult.StartDateTime, lastResult.EndDateTime) as LastDurationSeconds
		,lastResult.IsError as LastIsError
from	scheduler.CurrentlyExecutingTasks as cet
join    scheduler.GetInstanceId() as id
on      cet.Instanceid = id.Id
join	scheduler.Task as t
on		t.TaskId = cet.TaskId
join	scheduler.TaskExecution as te
on		te.ExecutionId = cet.ExecutionId
outer apply (
	select top 1 *
	from scheduler.TaskExecution as teh
	where teh.TaskId = t.TaskId
	and teh.ExecutionId <> te.ExecutionId
	order by ExecutionId desc
) as lastResult
```

![Currently executing tasks](./CurrentlyExecutingTasks.png)

In this example there are four tasks which have been running for 55 seconds. They normally take 60 seconds to run, and they last ran a minute ago (with no errors).

The rest of this post talks through how the mapping works.

## Recap of tsqlScheduler

tsqlScheduler creates one SQL Agent job per entry in the _scheduler.Task_ table. The agent job calls the _scheduler.ExecuteTask_ procedure, which eventually calls sp_executesql to run the TSQL specified by the entry in the task table.

The execution of of each task is logged in the _scheduler.TaskExecution_ table.

## Storing information against each task

In order to tag each execution with the metadata we need to tie back to the task & execution data we use context_info. This allows us to store up to 128 bytes of data against a session which can then be queried through the [dm_exec_requests](https://docs.microsoft.com/en-us/sql/relational-databases/system-dynamic-management-views/sys-dm-exec-requests-transact-sql) and [dm_exec_sessions](https://docs.microsoft.com/en-us/sql/relational-databases/system-dynamic-management-views/sys-dm-exec-sessions-transact-sql) DMVs.

The information we'll store against each execution are:

- The scheduler instance identifier
- The task id
- The execution id

Each instance when deployed has a unique guid generated that identifies that instance (returned via the function _scheduler.GetInstanceId_). We need this as the task id is a number, and so for any SQL instance with multiple scheduler instances deployed (e.g. one standalone and multiple AGs) we use the instance id to disambiguate which instance the task belongs to.

Context info requires a binary payload, and rather than worrying about packing and unpacking a payload I've opted to use json to allow for a fairly flexible schema (I'd have preferred to use [session_context](https://docs.microsoft.com/en-us/sql/t-sql/functions/session-context-transact-sql) but you can't query that from other sessions at the moment).

As each task is executed the ExecuteTask procedure calls into the following procedure to build and store our json data:

```sql
create or alter procedure scheduler.SetContextInfo
    @instanceIdentifier uniqueidentifier
    ,@taskId int
    ,@executionId int
as
begin
    declare @descriptor varchar(128) =
	    '{ "i":"' + cast(@instanceIdentifier as varchar(36))
	    + '","t":' + cast(@taskId as varchar(12))
	    + ',"e":' + cast(@executionId as varchar(12))
	    + '}';

    declare @binaryPayload varbinary(128) = cast(@descriptor as varbinary(128));
    set context_info @binarypayload;
end
```

SQL Agent does use pooled connections, though it resets each connection before each job is executed, which means that we don't have to worry about resetting the context_info after every execution.

## Viewing task information

The view _scheduler.CurrentlyExecutingTasks_ returns one row for each task currently executing, regardless of the scheduler instance the task was deployed into.

```sql
select  tasks.InstanceId
        ,tasks.TaskId
        ,tasks.ExecutionId
from    sys.dm_exec_requests as r
cross apply (
    select try_cast(r.context_info as varchar(128)) as ContextInfo
) as i
cross apply openjson (i.ContextInfo, N'$')
	with (
		InstanceId uniqueidentifier	N'$.i'
		,Taskid int	N'$.t'
		,ExecutionId int N'$.e'
	) as tasks
where r.context_info <> 0x
and   isjson(i.ContextInfo) = 1
```

Most sessions have no context_info associated with them (0x) so we can ignore those. For sessions which do have a payload we attempt to convert to varchar and then check if they're valid json. We then extract the json and correctly type the values.

To filter the currently executing tasks for the current scheduler instance only (the database that contains the view), you can modify the query to join onto the function that returns the instance's unique Id:

```sql
select cet.*
from   scheduler.CurrentlyExecutingTasks as cet
join   scheduler.GetInstanceId() as id
on     cet.Instanceid = id.Id
```

This is the same join that is used in the monitoring query at the start of the post, and is essential in deployments where multiple scheduler schemas are concurrently executing.

repository: taddison/personal-site

gha_language: Nunjucks

repo_name: taddison/personal-site


text:
# About

## What is mdBook?

> "mdBook is a utility to create modern online books from Markdown files"

## Resources

Learn more about [mdBook](https://michaelcurrin.github.io/dev-resources/resources/rust/packages/mdbook.html) in my Dev Resources and how an mdBook project is structured.

repository: MariaCharaKarypidou/mdbook-quickstart

repo_name: MariaCharaKarypidou/mdbook-quickstart


text:
@function can-compute.computed compute
@parent can-compute
@group can-compute/computed/events events
@group can-compute/computed/methods methods

@description A derived value from other computes and observable maps.

@signature `compute([newVal])`

Gets the compute's value if no arguments are provided, otherwise calls the compute's setter with the value passed as the first argument.

@param {*} [newVal] If the compute is called with an argument, the first argument is used
to set the compute to a new value. This may trigger a
`"change"` event that can be listened for with [can-computed.bind].

If the compute is called without any arguments (`compute()`), it simply returns
the current value.

@return {*} The current value of the compute.

@body

## Use

A compute instance is created with [can-compute] and used as an observable value. Computes are useful to provide a value representative of multiple other observables:

```js
const person = new Person( {
	first: "Matthew",
	last: "Phillips"
} );

const fullName = compute( function() {
	return person.first + " " + person.last;
} );

console.log( fullName() ); // -> "Matthew Phillips".
```

Calling the compute with a value will cause it to run as a setter function:

```js
const count = compute( 0 );

console.log( count() ); // -> 0

count( 5 );

console.log( count() ); // -> 5
```

This depends on how the [can-compute getterSetter] is defined, and can adjust how it handles setters:

```js
const plusOne = compute( function( val ) {
	if ( val ) {
		return val + 1;
	} else {
		return 1;
	}
} );

console.log( plusOne() ); // -> 1

plusOne( 5 );

console.log( plusOne() ); // -> 6
```

repository: canjs/can-compute

gha_language: JavaScript

repo_name: canjs/can-compute


text:
# About cdproto

Package `cdproto` contains the generated commands, types, and events for the
[Chrome DevTools Protocol domains][devtools-protocol].

This package is generated by the [`cdproto-gen`][cdproto-gen] command.  Please
refer to that project and to the main [`chromedp`][chromedp] project for
information on using the commands, types, and events available here.

## API

Please see the [GoDoc listing][godoc].

## Contributing

If you would like to submit a change to the code in this package, please submit
your Pull Request to the [`cdproto-gen`][cdproto-gen] project. Any Issues and
Pull Requests submitted to this project will be closed without being reviewed.

[devtools-protocol]: https://chromedevtools.github.io/devtools-protocol/
[cdproto-gen]: https://github.com/chromedp/cdproto-gen
[chromedp]: https://github.com/chromedp/chromedp
[godoc]: https://godoc.org/github.com/chromedp/cdproto

repository: tstromberg/demoit

gha_language: Go

repo_name: tstromberg/demoit


text:
# pixCode
Convert messages to binary and encode them into an image.

---
### Options:
1. Encode
- With this option you can encode a simple message.
- **Usage:**

    *1. type your message in the message field.*

    *2. specify a filename.*

---

2. Decode
- With this option you can decode a message.
- **Usage:**

    *1. drag & drop the encoded image file.*

---

3. Encode (File)
- With this option you can encode a longer message.
- **Usage:**

    *1. drag & drop the message file.*

    *2. specify a filename*

---

4. Decode (File)
- With this option you can decode a message and save it to a file.
- **Usage:**

    *1. drag & drop the encoded image file.*

    *2. specify a filename*

---

##### note: 3 accepts only text files so far.

repository: Sanduuz/pixCode

repo_name: Sanduuz/pixCode


text:
---
title: State
page_title: State
description: Steps State of the Stepper for Blazor.
slug: stepper-state
tags: telerik,blazor,stepper,state
published: True
position: 5
---

# Steps State

The Stepper for Blazor allows you to control the state of its steps. You can use to following `StepperStep` parameters to customize the state of the steps:

* [Optional](#optional)
* [Disabled](#disabled)

## Optional

To mark a step as optional, you can set its `Optional` parameter to `true` (its default value is `false`). This configuration strives to visually notify the user that a certain step is not required by rendering "(Optional)" text underneath the corresponding step. It doesn't come with a built-in functionality to skip the step if a [linear flow]({%slug stepper-linear-flow%}) is enabled.
The stepper component will also allow you to [localize]({%slug globalization-localization%}) the "Optional" text.

>caption Set an optional step. The result from the snippet.

![Optional step](images/optional-step-example.png)

````CSHTML
@* Stepper with one optional step. *@

<div style="width:700px">
    <TelerikStepper>
        <StepperSteps>
            <StepperStep Label="Cart"<EMAIL_ADDRESS>            <StepperStep Label="Delivery address"<EMAIL_ADDRESS>            <StepperStep Label="Payment method"<EMAIL_ADDRESS>            <StepperStep Optional="true" Label="Preview"<EMAIL_ADDRESS>            <StepperStep Label="Finish Order"<EMAIL_ADDRESS>        </StepperSteps>
    </TelerikStepper>
</div>
````

## Disabled

You can disable a step by setting the `Disabled` parameter of the the desired `StepperStep` to `true` (its default value is `false`). You can also toggle its value to conditionally enable/disable steps based on your application logic.

This feature serves to mark the desired step as disabled, so users cannot click and select it. If [linear flow]({%slug stepper-linear-flow%}) is enabled, users will not be able to skip the disabled step and click on the next enabled.

>caption Set a disabled step. The result from the snippet.

![Disabled step](images/disabled-step-example.png)

````CSHTMl
* Stepper with one disabled step. *@

<div style="width:700px">
    <TelerikStepper>
        <StepperSteps>
            <StepperStep Label="Cart"<EMAIL_ADDRESS>            <StepperStep Label="Delivery address"<EMAIL_ADDRESS>            <StepperStep Label="Payment method"<EMAIL_ADDRESS>            <StepperStep Disabled="true" Label="Preview"<EMAIL_ADDRESS>            <StepperStep Label="Finish Order"<EMAIL_ADDRESS>        </StepperSteps>
    </TelerikStepper>
</div>
````

## See Also

  * [Live Demo: Stepper State](https://demos.telerik.com/blazor-ui/stepper/state)

repository: telerik/blazor-docs

repo_name: telerik/blazor-docs


text:
##  Report Definition (RD.E)

<PageHeader />

##

![](./RD-E-1.jpg)

**Report ID** Enter the name of an existing report, or the name you want to
assign to a new report. If you leave this field blank then a report id will be
automatically assigned when you save the record based on the file name
specified for the report. For example, if the file name used for the report is
SALES then the system will assign an id in the format SALES.CRn where n is the
next available number not already assigned to an existing report starting with
the text SALES.CR.

**Title** Enter the title that is to appear in caption of the report
procedure.

**File Name** Enter the name of the file from which the data for the report
will be extracted.

**Suppress Detail** Check this box if the report detail is to be suppressed
(i.e. only print totals).

**Double Space** Check this box if the report output is to be double spaced.

**Max Width** The system will automatically calculate the width of the report
based on the output fields selected. If you wish to force the output into a
vertical format you may do so by specifying a maximum report width in this
field.

**Heading** Enter each line of heading text that is to appear at the top of
the report.

**Print Field** Enter the names of all of the fields that are to appear on the
report in the order the are to appear on the page.

**Total Field** Check this box if totals are to be calculated for the
associated field name.

**Sort Field** Enter the names of each field that is to be used as a criteria
for sorting the report output. Enter the field names in order with the first
field entered being the primary sort criteria.

**Sort Sequence** Enter the sort sequence for the associated field name. Enter
"A" for ascending or "D" for descending.

**Sort Break** You may specify a break point with the associated sort field. A
break point occurs when the data in the field being sorted changes. If you
specify a break point and have indicated that totals are to be generated (as
specified in the Output Field section) then subtotals will be generated at
these break points in addition to the grand totals at the end of the report.

The three options are:
N - No break point (Default)
B - Process break point
P - Process break point and start a new

**Compare Field** Enter the name of each field for which a predefined
comparison (filter) is to be specified for the report.

**Compare Oper** Enter one of the following comparison operators:

EQ - Equal
GT - Greater Than
LT - Less Than
GE - Greater Than or Equal
LE - Less Than or Equal
S - Starting With
E - Ending With
C - Containing
NEQ - Not Equal
NGT - Not Greater Than
NLT - Not Less Than
NGE - Not Greater Than or Equal
NLE - Not Less Than or Equal
NS - Not Starting With
NE - Not Ending With
NC - Not

**Compare Value** Enter one or more values to be compared to the data in the
associated field. Multiple values are treated as an or condition.

**Prompt Field** Enter the name of each field that is to be compared to one or
more values that are to be entered by the user at the time the report is run.

**Prompt Oper** Enter one of the following comparison operators:

EQ - Equal
GT - Greater Than
LT - Less Than
GE - Greater Than or Equal
LE - Less Than or Equal
S - Starting With
E - Ending With
C - Containing
NEQ - Not Equal
NGT - Not Greater Than
NLT - Not Less Than
NGE - Not Greater Than or Equal
NLE - Not Less Than or Equal
NS - Not Starting With
NE - Not Ending With
NC - Not

**Prompt Name** Enter the text that is to appear as a prompt to the user for
entering the value to be used for the associated comparison.

**Prompt Multi** Check this box if the user is allowed to make multiple
entries for the associated comparison. Multiple entries are treated as an "OR"
condition.

**Import RD.E** Click this button if you want to load the definition of an
existing report defined through RD.E.

**Import REPORT.E** Click this button if you want to load the definition of an
existing report defined through REPORT.E.

<badge text= "Version 8.10.57" vertical="middle" />

<PageFooter />

repository: zumasys/docs

repo_name: zumasys/docs


text:
---
name: EV Suit Picard
rarity: 5
series: tng
memory_alpha:
bigbook_tier: 6
events: 28
in_portal: true
date: 17/09/2021
obtained: Event
mega: false
published: true
---

Reminiscent of a Mirror Spock or Survivalist Kirk, this Picard is a sum-of-his-parts crew who checks value boxes in an effort to overcome poor surface-level metrics. Viable in the realms of gauntlet, events, collections, and arena to varying degrees, you'll want to check how he stacks up against your current options rather than treating him like a first round draft pick whose power will force his way into service for you.

The easy comparison in gauntlet is a beefy Braxton. Better pri/sec pair and single CMD roll than the transcendent voyager means that Picard will outperform him there in almost every instance, despite not having any 45% or better crit sets. The resultant low bases combined with sufficient event chances might get him lost in the crowd of an endgame roster on occasion, but makes him more valuable than most one-off characters.

repository: joshurtree/datacore-website

repo_name: joshurtree/datacore-website


text:
# FunFox

<img align="right" src=assets/img/icon.svg height="150px">

FunFox is a scraper and downloader for manga chapters from [Fanfox](http://fanfox.net/) written in **Typescript** with **Nodejs** and [Electron](https://www.electronjs.org/)

### Features

- Download chapters for any manga from [Fanfox](http://fanfox.net/)
- Specify path to save chapters
- Specify start chapter number for downloading

### Install

```sh
npm install
```

### Getting Started

to run program just paste
```sh
npm start
```

repository: FunHB/FunFox

repo_name: FunHB/FunFox


text:
![license badge](https://img.shields.io/badge/License-MIT-lightgrey.svg)

Link to deployed application: https://jamesbroski.github.io/theVibeForecast/

# theVibeForecast

As a musically inclined weather enthusiast

I want to enter in my current city

So I can see the current weather

I want to be able store a few cities in the navigation bar

So I can save the last few cities I searched

I want to listen to songs that relate to the weather vibes in the city

So I can listen to the songs

I want to be able to like and save songs

So that I can replay songs that I liked.

# nav bar

-will include searchbar that allows the user to choose their location for weather data pull

-include the name of our project

# jumbotron

-display local weather

-will display the music hashtags that will be given to you based on the weather

# track container

-will display 8 tracks in 8 seperate card containers

-each card will diplay track ID, related tags, like button(add to local storage)

# aside container

-when a track is liked it will be added to this container

-this container will also show saved cities

# footer container

-digital media agency business name "created by The Vibe Doctors"

-will include links to each one of our github accounts

# Below is a screen shot of what the user can expect:

![Screen Shot 2021-09-19 at 9 09 35 PM (2)](https://user-images.githubusercontent.com/87332492/133953653-c2ba8915-f8fe-4752-a16d-afb9fd2fbbc1.png)

repository: jamesbroski/theVibeForecast

repo_name: jamesbroski/theVibeForecast


text:
# ![logo](docs/logo.png)

Pronounced ["boat-shahft"](https://forvo.com/word/botschaft/)

> :warning: The original Python implementation is deprecated, and has been moved to `botschaft-py`.
>
> :construction: Development on Botschaft will continue with `botschaft_otp`, implemented in Elixir. This document refers only to botschaft_otp.

# What is Botschaft?

Botschaft is unified messaging & notifications appliance. Use Botschaft to send messages via Slack, Discord, and Telegram. Group multiple destinations into "Topics" and send messages to multiple destinations with a single request.

It's as easy as `curl http://my.botschaft.server/slack?channel=general&message=Hello!`

# No, _what is 'botschaft'_?

> `Botschaft`, German, noun, feminine (genitive Botschaft, plural Botschaften)

Botschaft is "message" in German. The "bot" prefix seemed appropriate for what is essentially a notification bot.

# Why use Botschaft?

- Many teams start out using one messaging provider and later switch to another. Maybe you use Slack today, but next year your team might move to Discord. Avoid the headache of re-implementing outgoing messages by targeting Botschaft instead. This way, you can change the declarative Botschaft configuration instead of changing your app source code.
- If you have multiple application deployments and want to avoid proliferating Slack or Discord credentials and secrets. Centralize the messaging API credentials in Botschaft, and route your messages through it.
- If you want to give non-programmers control over multiple messaging channels and the formatting of the messages. Botschaft supports messages templates. Change your messages without re-deploying your application (and without restarting Botschaft!)

# Features

- Dead simple HTTP API
- Declarative configuration
- "Topics", flexible, customizable groups of destinations
- Configuration reloading - no restart required

repository: tmkontra/botschaft

repo_name: tmkontra/botschaft


text:
---
layout: news
title: "Multiple Postdoctoral Positions Available"
author: "Mark Fuge"
author_handle: "fuge"
image: /assets/images/news/default-news.png
category: news
tags: [openings]
---

Multiple postdoctoral positions are open in our lab to study fundamental mathematical and computational techniques for the conceptual design of engineered systems. Specifically, we are looking for talented researchers with expertise and a publication track-record in one (or more) of the following areas:

 * Design Theory and Methodology, for example, in Computational Design Synthesis for engineering systems involving the interplay of function, behavior, and structure.
 * Data-Driven Design and Optimization, for example, simulation-based design, multi-fidelity optimization, robotics, or optimal control.
 * Computer Science, for example, machine learning/AI, software architecture, functional programming, lambda-calculus, and computer graphics/geometry.
 * Applied Mathematics, for example, operator algebras, category theory, differential geometry, topology, or mathematical logic.

For more information, see [the official posting](https://ejobs.umd.edu/postings/55188)


text:
# Web to Plex ![Icon](src/img/48.png)

![Logo](src/img/256.png)

This browser extension searches your [Plex Media Server (PMS)](https://www.plex.tv/downloads/) for matching media on sites like [IMDb](https://imdb.com), letting you immediately open the movie or TV show in Plex, if it is available. If the item isn't found on your PMS, then a download button is added instead.

Optionally, you can configure [Sonarr](https://sonarr.tv/) (TV Shows), [Radarr](https://radarr.video/) (Movies), [Watcher 3](https://nosmokingbandit.github.io/) (Movies), and/or [CouchPotato](https://couchpota.to/) (Both) in the extension's options. After that, you can immediately add a TV show or movie to CouchPotato/Sonarr/Radarr with one click, right from your favorite site.

![Examples](example.png)

----

## Status: 426 (UPGR-RQ)

Getting the repo ready for a pull request.

----

## Features:

- Can save media directly from noted sites (file downloads/magnet URLs)
  - Right-click | Web to Plex | Save as "Show/Movie (Year)"
- Can push requests to your chosen NZB manager
  - [Radarr](https://radarr.video/)
  - [Sonarr](https://sonarr.tv/)
  - [CouchPotato](https://couchpota.to/)
  - [Watcher 3](https://nosmokingbandit.github.io/) ("Watcher, version 3")
- Offers search options via right-click (context menu)
  - Right-click | Web to Plex | Find "Show/Movie (Year)"
- Offers a Plex-like GUI
  - Settings page
  - Pop-up page
- Offers a status via the browser badge
  - Orange: item is available/found
  - Grey: item is unavailable/not found
- Offers an easy login feature
  - Offers an API login feature
- Offers a "Direct Plex URL" feature
  - i.e. you can specify `localhost:32400` as your Plex URL to avoid bandwidth usage for Plex requests

## Supported sites: *Site (button location)*

*Given in order of completion*

1.  [Movieo](http://movieo.me/) ([button location](button-locations/movieo.png))
2.  [IMDb](http://imdb.com/) ([button location](button-locations/imdb.png))
3.  [Trakt.tv](https://trakt.tv/) ([button location](button-locations/trakt.png))
4.  [Letterboxd](https://letterboxd.com/) ([button location](button-locations/letterboxd.png))
5.  [Flenix](https://flenix.co/)1/5 ([button locations](button-locations/flenix.png))
6.  [TV Maze](http://www.tvmaze.com/) ([button location](button-locations/tvmaze.png))
7.  [The TVDb](https://www.thetvdb.com/) ([button location](button-locations/tvdb.png))
8.  [The MovieDb](https://www.themoviedb.org/) ([button location](button-locations/tmdb.png))
9.  [VRV](https://vrv.co/)2 ([button location](button-locations/vrv.png))
10. [Hulu](https://hulu.com/)2/3/4 ([button location](button-locations/hulu.png))
11. [Google Play Store](https://play.google.com/store/movies/) ([button location](button-locations/google.png))
12. [iTunes](https://itunes.apple.com/)3/5 ([button location](button-locations/itunes.png))
13. [Metacritic](http://www.metacritic.com/)4 ([button location](button-locations/metacritic.png))
14. [Fandango](https://www.fandango.com/) ([button location](button-locations/fandango.png))
15. [Amazon](https://www.amazon.com/)5 ([button location](button-locations/amazon.png))
16. [Vudu](https://www.vudu.com/) ([button location](button-locations/vudu.png))
17. [Verizon](https://www.tv.verizon.com/) ([button location](button-locations/verizon.png))
18. [CouchPotato](http://couchpotato.life/) ([button location](button-locations/couch-potato.png))
19. [Rotten Tomatoes](https://www.rottentomatoes.com/) ([button location](button-locations/rotten-tomatoes.png))
20. [ShowRSS](https://showrss.info/)1 (no button location)
21. [Netflix](https://netflix.com/)3 ([button location](button-locations/netflix.png))

*Notes*

- `1` *This site uses the `Right click | Web to Plex | Save as...` feature (file download), or a direct link (usually magnet URL).*
- `2` *This site has a loading issue, simply refresh the page if the button doesn't appear.*
- `3` *This site doesn't allow media browsing, or requires a subscription beforehand.*
- `4` *This site is network intensive (loads slowly). Be patient.*
- `5` *This site is known to update frequently, support may change without notice.*

## In Progress sites (adding support):

- Nothing here... for now

## En Progress sites (may add support):

- Nothing here... for now

## Installing Web to Plex

- **Download the [CRX](https://github.com/Ephellon/web-to-plex/raw/master/src.crx)**

- **Download the [ZIP](https://github.com/Ephellon/web-to-plex/raw/master/src.zip)**

- **Download the [SRC](https://github.com/Ephellon/web-to-plex/archive/master.zip)**

## Requirements

+ [**Plex Media Server v<IP_ADDRESS>**](https://www.plex.tv/downloads/#getdownload) or higher

+ Before using the [extension](chrome://extensions), you must configure the settings

## Issues & Contributions

If you have any problem with the extension, please don't hesitate to [submit an issue](https://github.com/Ephellon/web-to-plex/issues/new).

All contributions are welcome.

repository: wiiickedlady/web-to-plex

repo_name: wiiickedlady/web-to-plex


text:
VITA Remote Cheat
=================
VITA Remote Cheat is a plugin for taihen used to modify memory or unlock trophies from PC throught network

Installation
------------
1. Copy tai/rcsvr.skprx to your taihen plugin folder, modify tai plugin config.txt, add rcsvr.skprx to *KERNEL section, e.g. if you copy it to ux0:tai/rcsvr.skprx, add 2 lines in config.txt as following:

        *KERNEL
        ux0:tai/rcsvr.skprx

2. Copy tai/rcsvr.suprx to ux0:tai/

3. Ensure the IP address of your PSVITA/PSTV can be accessed from your PC, start any game on PSVITA, run rcsvr_client on PC after "VITA Remote Cheat" shown up, click Autoconnect button

4. If step 3 is not connecting, you can get PSVITA IP address in Network Settings or VitaShell (Press SELECT in FTP MODE), input in the client and click Connect button

5. Now your can search memory or unlock trophies as well

repository: leecloudvictor/vita-rcheat

repo_name: leecloudvictor/vita-rcheat


text:
---
title: M/01
fullname: M/01 Desert version
nickname: T/99
family: flecktarn
terrain: desert
country: dk
image: m01.jpg
cover: m01-cover.jpg
---
It is a 3 colour camouflage pattern, similar in design to the Danish M/84 pattern. It is considered to be the desert counterpart of M/84, and consists of different colors better suited for arid climates. The uniform contains splotches of earthy red and dark green on a sand-coloured background.

History
-------
The first version of T/99 was trialled in 1999 and issued in 2000 to Danish personnel attached to the Multinational High Readiness Standby Brigade for United Nations Operations. These service personnel were dispatched to Africa under the United Nations banner to enforce and uphold a ceasefire line between the nations of Eritrea and Ethiopia, as part of the United Nations mission in these two countries.

Danish soldier (on right) wearing a T/99 patterned uniform in Kabul, Afghanistan.
In 2001, the pattern was further researched and improved upon, with a new variant coming into existence later that same year. The new variant, known as Kampuniform M/01 Ørken (desert) was first seen on members of the Danish ISAF contingent. The desert camouflage uniform is issued in relatively small quantities, and only to troops actually deploying to Afghanistan.

While T/99 is rumoured to be a modified variant of German Desert Flecktarn (Tropentarn) camouflage, it is actually a recoloured variant of the original Danish M84 Pletsløring (spot camouflage) pattern, in which earthy red has replaced black, dark green has replaced light green, and the sand colour has replaced the olive green of the original M/84.

Sources
-------
[Wikipedia](https://en.wikipedia.org/wiki/M84_camouflage_pattern)
[Wikipedia](https://en.wikipedia.org/wiki/T99_(camouflage))

gha_language: CSS


text:
# api-server# basic-api-server

## API Feature

- All the Data stored in MONGODB with collection of food and clothes in **Atlas**

- Get all data realted to food or clothes in the routes `/food`, `/clothe`.

- Get a certain data about food or clothes in the routes `/food/:id`, `/clothes/:id`.

- Add data related to food or clothes in the routes `/food`, `/clothes`.

- Upgrade existing data related to food or clothes `/food/:id`, `/clothes/:id` and send new data to this routes.

- Delete existing data realted to food or clothes `/food/:id`, `/clothes/:id`.

_all feature have been implemented in the `dev` branch_

## URL links

- main branch
  [oht-api-server-lab04](https://oht-api-server-lab04.herokuapp.com/)

- Github Pull Request
  [Pull-Request](https://github.com/Omar-Tarawneh/api-server/pull/1)

- Action
  [Action](https://github.com/Omar-Tarawneh/api-server/actions)

## Feature tests

you can check from the action tap for all the test - the link provided above- or just test it in you local machine the final resulte is like this.

![data-flow-diagram](img/testing-lab04.png)

## Data Flow Diagram

![data-flow-diagram](img/lab03.png)

## Download And Start

- Clone the Repository into your local machine
  `git clone httpLink/sshlink`

- Get into the repo directory
  `cd basic-api-server`

- Install the dependences for tha app
  `npm install`

- Add your dotenv File and add your PORT
  `touch .env`
  `PORT=3000`
  `MONGODB_URI=mongodb+srv://omar:0000@api-server.xifht.mongodb.net/api-server-db?retryWrites=true&w=majorit`

- Test the functionality of the app by typing:
  `npm test`

- Then to start the server type in the terminal:
  `npm start`

repository: Omar-Tarawneh/api-server

repo_name: Omar-Tarawneh/api-server


text:
## Numeral prefix

https://en.wiktionary.org/wiki/Appendix:English_arities_and_adicities

https://en.wikipedia.org/wiki/Numeral_prefix
https://en.wikipedia.org/wiki/Binary_prefix
https://en.wikipedia.org/wiki/Metric_prefix#double
https://en.wikipedia.org/wiki/Demi_(disambiguation)
https://en.wikipedia.org/wiki/Category:IEC_prefixes
https://en.wikipedia.org/wiki/Category:SI_prefixes
https://en.wikipedia.org/wiki/Category:Mathematical_prefixes
https://en.wikipedia.org/wiki/Category:Function_prefixes
https://en.wikipedia.org/wiki/Category:Metric_prefixes
https://en.wikipedia.org/wiki/Category:Metric_double_prefixes
https://en.wikipedia.org/wiki/Deca-_(prefix)
https://en.wikipedia.org/wiki/Dera
https://en.wikipedia.org/wiki/Meta
https://en.wikipedia.org/wiki/Entero
https://en.wikipedia.org/wiki/-phil-
https://en.wikipedia.org/wiki/Pseudo-
https://en.wikipedia.org/wiki/Numeral_prefix#semi
https://en.wikipedia.org/wiki/Unit_prefix

Numeral prefixes are derived from numerals or occasionally other numbers.

In English and other European languages, they are used to coin numerous series of words, such as unicycle – bicycle – tricycle, dyad – triad – decade, biped – quadruped, September – October – November – December, decimal – hexadecimal, sexagenarian – octogenarian, centipede – millipede, etc.

There are two principal systems, taken from Latin and Greek, each with several subsystems; in addition, Sanskrit occupies a marginal position.

There is also an international set of metric prefixes, which are used in the metric system, and which for the most part are either distorted from the forms below or not based on actual number words.

In some forms, a final vowel is dropped before a root that begins with a vowel, with the exceptions of bi-, which is bis- before a vowel, and of the other monosyllables, du-, di-, dvi-, tri-, which are invariable.

* Cardinal series
- derived from cardinal numbers
- English:
  - one, two, three, four, five, six, seven, eigth, nine, ten
  - Short scale: septillion (1000^8)
  - Long scale: quadrillion (10^24)
- Greek  : mono, bi, ter, quater, quint, hepta, sesta
- Latin  : un(us), due, tres, quattor, quinque, sex, septa, octa, nove, deci

* Multiple series
  - based on adverbial numbers
  - English: once, twice, thrice (or three times), then `n times`

* Distributive series:
  - original meaning is now frequently lost
  - English: one each, two each,... `n each`
  - one by one, two by two, ..., `n by n`

* Ordinal series
  - based on ordinal numbers
  - EN: first, second, third, fourth, fifth, sixth, seventh, eighth, ninth, tenth
  - EN: written numerically, numbers are suffixed with `-th` unless ending in:
    - `-1` suffix: `-st` (1st, 21st, 101st, etc)
    - `-2` suffix: `-nd` (2nd, 32nd, 502nd, etc)
    - `-3` suffix: `-rd` (3rd, 93rd, 1203rd, etc)

* Fractions:
  - If n>2, the ordinal forms are used for fractions
  - only the fraction `1/2` has special forms

For the hundreds, there are competing forms:
- `-gent-` derived from the original Latin
- `-cent-` derived from `centi-` (and similar) plus prefixes for 1..9

Deca- (and dec-) sometimes deka- is a common English-language numeral prefix derived from the Late Latin decas ("(set of) ten"), from Ancient Greek δέκας (dékas), from δέκα (déka, "ten").[

Decennial, ten-yearly or a celebration of ten years.

The decimal numeral system also called base-ten positional numeral system, and occasionally called *denary* or *decanary*.

- `demi` (metric prefix) (or demi-), a former metric unit prefix not adopted by SI
- `demi-` (numerical prefix), a linguistic prefix representing half, see Numeral prefix

## Arity (adicity)

Or the number of arguments a function et al. takes

Where *many* in the table means more then 1 and *loose* means variable number of arguments, i.e. a variadic function can handle being called with any number of arguments.

| nr.   | Latin      | Greek     | Note              |
|-------|------------|-----------|-------------------|
| argc  | Arity      | Adicity   | number of args    |
| `n`   | `n-ary`    | `n-adic`  |                   |
| 0     | nullary    | niladic   | medadic, zeroadic |
| 1     | unary      | monadic   |                   |
| 2     | binary     | dyadic    |                   |
| 3     | ternary    | triadic   |                   |
| 4     | quaternary | tetradic  |                   |
| 5     | quinary    | pentadic  |                   |
| 6     | senary     | hexadic   |                   |
| 7     | septenary  | heptadic  |                   |
| 8     | octonary   | ogdoadic  |                   |
| 9     | novenary   | enneadic  |                   |
| 10    | denary     | decadic   |                   |
| 11    | undenary   | endecadic |                   |
| 12    | duodenary  | dodecadic |                   |
| 20    | vigenary   | icosadic  |                   |
| many  |            | polyadic  |                   |
| (...) |            | variadic  |                   |

Arity: nullary (0), unary (1), binary (2), ternary (3), quaternary (4), quinary (5), senary (6), septenary (7), octonary (8), novenary (9), denary (10)

Adicity: 0 niladic, 1 monadic, 2 dyadic, 3 triadic, 4 tetradic, 5 pentadic, 6 hexadic, 7 heptadic, 8 octadic, 9 enneadic, 10 decadic

## unsorted

**nonary**
- relating to or based on the number 9
- from Latin `nōnus` ninth
`nonarius` from

duadic
nonadic
k-adic
p-adic

## Tuples
solitary
double, pair
triple, triplet
quadruple
quintuple
sextuple (hextuple)
septuple (heptuple)

## Folds
twofold, duplicate
threefold, triplicate
fourfold
fivefold
sixfold
sevenfold

---

**novemdecillion** (US) 1 followed by 60 zeros, (UK) 1 followed by 114 zeros

license: Unlicense


text:
[![Build Status](https://travis-ci.org/madflojo/automatron.svg?branch=master)](https://travis-ci.org/madflojo/automatron) [![Coverage Status](https://coveralls.io/repos/github/madflojo/automatron/badge.svg?branch=master)](https://coveralls.io/github/madflojo/automatron?branch=master)

![Automatron](https://raw.githubusercontent.com/madflojo/automatron/master/docs/img/logo_huge.png)

Automatron **(Ah-Tom-a-tron)** is an open source framework designed to detect and remediate IT systems issues. Meaning, it can be used to monitor systems and when it detects issues; correct them.

## Features

* Automatically detect and add new systems to monitor
* Monitoring is executed over SSH and completely agent-less
* Policy based Runbooks allow for monitoring policies rather than server specific configurations
* Supports Nagios compliant health check scripts
* Allows arbitrary shell commands for both checks and actions
* Runbook flexibility with **Jinja2** templating support
* Pluggable Architecture that simplifies customization

## Runbooks

Automatron's actions are driven by policies called **Runbooks**. These runbooks are used to define what health checks should be executed on a target host and what to do about those health checks when they fail.

### A simple Runbook

The below example is a Runbook that will execute a monitoring plugin to determine the amount of free space on `/var/log` and based on the results execute a corrective action.

```yaml
name: Verify /var/log
schedule: "*/5 * * * *"
nodes:
  - "*"
checks:
  mem_free:
    # Check for the % of disk free create warning with 20% free and critical for 10% free
    execute_from: target
    type: plugin
    plugin: systems/disk_free.py
    args: --warn=20 --critical=10 --filesystem=/var/log
actions:
  logrotate_nicely:
    execute_from: target
    trigger: 0
    frequency: 300
    call_on:
      - WARNING
    type: cmd
    cmd: bash /etc/cron.daily/logrotate
  logrotate_forced:
    execute_from: target
    trigger: 5
    frequency: 300
    call_on:
      - CRITICAL
    type: cmd
    cmd: bash /etc/cron.daily/logrotate --force
```

### A Runbook with Jinja2

Jinja2 support was added to Runbooks to allow for extensive customization. The below example shows using Jinja2 to determine which `cmd` to execute based on Automatron's **facts** system.

This example will detect if `nginx` is running and if not, restart it.

```yaml
name: Verify nginx is running
schedule:
  second: "*/30"
nodes:
  - "*web*"
checks:
  nginx_is_running:
    # Check if nginx is running
    execute_from: target
    type: cmd
    {% if "Linux" in facts['os'] %}
    cmd: service nginx status
    {% else %}
    cmd: /usr/local/etc/rc.d/nginx status
    {% endif %}
actions:
  restart_nginx:
    execute_from: target
    trigger: 2
    frequency: 300
    call_on:
      - WARNING
      - CRITICAL
    type: cmd
    {% if "Linux" in facts['os'] %}
    cmd: service nginx restart
    {% else %}
    cmd: /usr/local/etc/rc.d/nginx restart
    {% endif %}
```

For more examples and information on getting started checkout the Automatron [wiki](https://github.com/madflojo/automatron/wiki).

## Deploying with Docker

Deploying Automatron within Docker is quick and easy. Since Automatron by default uses `redis` as a datastore we must first start a `redis` instance.

```console
$ sudo docker run -d --restart=always --name redis redis
```

Once `redis` is up and running you can start an Automatron instance.

```console
$ sudo docker run -d --link redis:redis -v /path/to/config:/config --restart=always --name automatron madflojo/automatron
```

## Stay in the loop

Follow [@Automatronio on Twitter](https://twitter.com/automatronio) for the latest Automatron news and join the community in [#Automatron on Gitter](https://gitter.im/madflojo/automatron).

## License

   Copyright 2016 Benjamin Cane

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

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

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

repository: nynhex/automatron

repo_name: nynhex/automatron