text:
# Flashget
[![Code Health](https://landscape.io/github/balrok/Flashget/master/landscape.png)](https://landscape.io/github/balrok/Flashget/master)
[![Build Status](https://travis-ci.org/balrok/Flashget.svg?branch=master)](https://travis-ci.org/balrok/Flashget)

A tool to download flashstreams from movie-streaming sites like kinox.to or anime-loads.org

## Bugs:

Since all webpages change often and the program relies on the html-structure of them many pages and streams are not working.
Currently (21.04.2014) the page [ddl.me](http://ddl.me) and the streams [streamcloud](http://streamcloud.eu),
[nowvideo](http://nowvideo.sx), [firedrive](http://firedrive.com) are working.
To check the streams you can run `python stream_tests.py`.

## Features:

- Support(ed) several streaming sites as kinox.to anime-loads.org movie-loads animeseed eliteanimes
- Support(ed) several streamhoster like: bitshare, megavideo, eatlime, videobb, myvideo, stagevu, veoh, sevenload, putlocker/sockshare,
  zeec, ccf and generic xvid, directdownload
- allows to build up a database from the streamhoster - I made a little php stream-database with that if there is interest mail me
- extensive caching with various backends
- multiple downloads / queues
- many hidden bugs and eastereggs

## Thanks:

Many download-algorithms are from foreign websites or foreign source code. I'm not sure if I marked every codesection as such. But still
want to thank them for making their software opensource or writing good blog posts. If you find uncredited code please write me - it was no
bad intent :)

## Contributing:

If you like to improve this program but don't like the ugly code - just send me a mail and I will help you.

# GUI

If you want a gui:

* pip install gooey
* also install: dev-python/wxpython

## License:

MIT License
Copyright (c) 2009-2012 Carl Schönbach

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

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

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

## Other/similar projects:

### Streams

* [http://code.google.com/p/dmd-xbmc/](http://code.google.com/p/dmd-xbmc/)
* [http://t0mm0.github.com/xbmc-urlresolver/tutorials/resolverplugin/analyse.html](http://t0mm0.github.com/xbmc-urlresolver/tutorials/resolverplugin/analyse.html)
* [https://github.com/pyload/pyload](https://github.com/pyload/pyload)
* [http://code.google.com/p/rapidleech/](http://code.google.com/p/rapidleech/)
* [https://github.com/Lynx187/plugin.video.xstream](https://github.com/Lynx187/plugin.video.xstream)
* [https://code.google.com/p/plowshare/](https://code.google.com/p/plowshare/)
* [https://github.com/Eldorados/script.module.urlresolver](https://github.com/Eldorados/script.module.urlresolver)
* <https://github.com/rg3/youtube-dlhttps://github.com/rg3/youtube-dl> - this is definitely the best - only one with tests and a lot of
  streams

### Pages

* <https://github.com/mmllnr/plugin.video.xstream>
* <https://github.com/joschi36/kinoxto-linkextractor>

repository: balrok/Flashget

repo_name: balrok/Flashget


text:
## Calculator with two fields
This Calculator App was written in Java and can be used cross platformed. The app provides standard, scientific functionality.
Input is performed only through buttons, without possibility to input from keyboard.\
\
![Calculator work](images/calc.jpg)

### Graphic Interface libraries
* Java Swing
* Abstract Window Toolkit (AWT)

license: Unlicense

repository: AleSergio/Java-Projects

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: AleSergio/Java-Projects


text:
# Module System (Separate from Transpilation)

## Primary Goals

1. Allow for module lookup at runtime, including an index built of all available/existing files in the application (and node_modules)
  a. Everything in node_modules/@travetto/* by default
  b. package.json can define additional metadata about dependencies to search?
  c. Allow for relative paths to be used
     - Useful in monorepos
     - Useful in framework development

2. Packaging needs to use precompiled as output form.
  a. Prod === precompiled (cannot compile at runtime)
  b. precompiled !== prod (can precompile without being in prod mode)

3. File Operations
  a. Source file, regardless of location
    - Search: configured folders, scans
    - Resolve to Target: with respect to module system
    - Generate module id
  b. Target file, node_modules/ file written out
    - Search: node_modules, needs to map into source files
    - Resolve to Source: convert node_modules/* path into source file
    - Resolve to hypothetical source: convert to realized typescript file (toUnixSource)
    - Generate module id

4. Transpiler
  - Typescript needs the Target converted into hypothetical source to honor the root

## Module Scenarios

### Precompiled (prod=run)
1. Need to load via node_modules, as usual
2. Need to scan pre-compiled files

### Standard (dev=debug, test=test)
1. Scan node_modules/@travetto for default imports
2. Transpile/compile on demand
3. Load/Unload modules on demand

### Monorepo (dev=debug, test=test)
1. Everything in STANDARD
2. Need to resolve code paths relative to monorepo root
3. Allow for mapping in local, peer modules as node_modules

license: MIT

repository: travetto/travetto

branch_name: refs/heads/main

gha_language: TypeScript

gha_license_id: MIT

repo_name: travetto/travetto


text:
# jBus #

## Introduction ##

In standard modern web applications, client-side scripts are either standalone, or tightly coupled with one another. Browser extensions and Greasemonkey userscripts, on the other hand, are running in a sandbox beneath an artificial `window` object and can only be loosely coupled via message-passing by sending custom DOM events, or by using [proprietary APIs][Chrome cross-extension messaging API].

The problem is that tight coupling is often undesirable, proprietary APIs are non-portable and custom events are a very crude means of communication prone to misconfiguration and event name collisions. jBus, on the other hand, is a cross-extension messaging architecture designed with the prevention of naming collisions in mind, which features a simple but expressive API and which enables loose coupling between any two pieces of JavaScript code sharing as little as a DOM [event target][EventTarget].

  [Chrome cross-extension messaging API]: https://developer.chrome.com/extensions/messaging#external "Message Passing - Google Chrome"
  [EventTarget]: http://www.w3.org/TR/DOM-Level-2-Events/events.html#Events-EventTarget "DOM 2 Events Specification"

## Documentation ##

  * [Architecture](docs/architecture.md) and [API](docs/api.md)
  * [Example userscripts](docs/examples.md)
  * [An example web application](docs/webchat.md)

## Compatibility ##

jBus is compatible with any browser, which supports [ECMAScript 3+][ECMA-262 3rd edition] including the extensions described in the [WHATWG JavaScript specification][ECMAScript web extensions], the `window.document` object as described in the [WHATWG HTML specification][Window interface specification], DOM 2 Events as described in the [DOM 2 Events W3C recommendation][DOM 2 Events] and the [`CustomEvent`][CustomEvent] interface as described in the [DOM 3 Events W3C working draft][DOM 3 Events]. The list includes:

  * Opera 11+
  * Mozilla/Firefox 6+
  * Internet Explorer 9+
  * Webkit 533.3+
    * Safari 5.1+
    * Chrome

[CustomEvent]: http://www.w3.org/TR/DOM-Level-3-Events/#interface-CustomEvent "DOM 3 Events Specification"
[Window interface specification]: http://www.whatwg.org/specs/web-apps/current-work/multipage/browsers.html#the-window-object "HTML Standard"
[DOM 2 Events]: http://www.w3.org/TR/DOM-Level-2-Events/ "DOM 2 Events Specification"
[DOM 3 Events]: http://www.w3.org/TR/DOM-Level-3-Events/ "DOM 3 Events Specification"
[ECMA-262 3rd edition]: http://www.ecma-international.org/publications/files/ECMA-ST-ARCH/ECMA-262,%203rd%20edition,%20December%201999.pdf "ECMAScript Language Specification"
[ECMAScript web extensions]: http://javascript.spec.whatwg.org/ "JavaScript, aka. Web ECMAScript"

## Compilation ##

### Assembly ###

The assembly of the jBus source files requires a [POSIX.2][]-compliant environment. To begin the assembly, run the `make build` command in the uppermost folder of the project. At the end of the process, the following files will be present in the `build` folder:

  * `jBus.js` -- A static build of jBus, which defines:
    * The `JBus.Node` object constructor.
    * The `JBus.Scope` object constructor and method.
  * `jBus.debug.js` -- A static build of jBus, which defines:
    * Logs any outgoing messages to the console.
    * Defines:
        * The `JBus.Node` object constructor.
        * The `JBus.Scope` object constructor and method.
        * The `JBus.Node.messages.*` object constructors.
        * The `JBus.Node.services.*` methods.

[POSIX.2]: http://pubs.opengroup.org/onlinepubs/009695399/ "The Open Group Base Specifications Issue 6"

### Minification ###

The minification of the jBus source files requires the `closure-compiler` binary of the [Closure Compiler by Google][] to be executable and to reside within one of the directories in the `PATH` environment variable. To begin the minification, run the `make min` command in the uppermost folder of the project. At the end of the process, the following files will be present in the `build` folder:

  * `jBus.min.js` -- A static and minified build of jBus, which defines:
    * The `JBus.Node` object constructor.
    * The `JBus.Scope` object constructor and method.
  * `jBus.min.debug.js` -- A static and minified build of jBus, which:
    * Logs any outgoing messages to the console.
    * Defines:
        * The `JBus.Node` object constructor.
        * The `JBus.Scope` object constructor and method.
        * The `JBus.Node.messages.*` object constructors.
        * The `JBus.Node.services.*` methods.

The latest minified jBus builds are also available online:

  * [`jBus.min.js`](http://tiny.cc/jBus)
  * [`jBus.debug.min.js`](http://tiny.cc/jBusDebug)

Alternatively, you can use any other minification tool or service, as long as the license notice is kept intact.

  [Closure Compiler by Google]: https://developers.google.com/closure/compiler/ "Closure Tools -- Google Developers"

## Installation ##

### Userscripts ###

#### Dynamic loading ####

If you wish to dynamically load the latest version of jBus into your userscript, use the [`@require` metadata key][Greasemonkey @require] as follows:

```js
// ==UserScript==
// ...
// @require http://tiny.cc/jBus
// ...
// ==/UserScript==
```

  [Greasemonkey @require]: http://wiki.greasespot.net/Metadata_Block#.40require "Metadata Block - GreaseSpot Wiki"

#### Static embedding ####

If you wish to statically embed jBus into your userscript, include the contents of the jBus build you wish to use directly into your userscript. Make sure you include it before any calls to the library.

#### Best practice ####

If you prefer to dynamically load the latest version of jBus into your userscript, but you want to include a static fallback, then the best practice is the following:

  1. Use the `@require` metadata key to attempt to load the latest version of jBus into your userscript.
  2. Include the contents of the jBus build you wish to use directly into your userscript with the following modification:
    * Replace the initial `var JBus = ` with `var JBus; if(!JBus) JBus = `.

This will allow users, whose script managers don't support the `@require` metadata key, to fall back on the statically embedded jBus library.

### Web pages ###

To be able to use jBus on your web page, input the following code in either the head or the body of the webpage. Make sure you include it before any scripts that use the library:

```html
<script src="jBus.js"></script>
```

Replace `jBus.js` with a pathname to the jBus build you wish to use.

## Unit testing ##

By loading the `src/test.html` file in your browser, you can run a suite of tests against the `src/jBus.js` and `src/framework.js` files. You can use this to check, whether:

  * jBus is compatible with a given browser.
  * Your modified version of jBus works as intended.

If the you only want to check browser compatibility, [the online version](https://dl.dropboxusercontent.com/u/48267088/JBus/test/test.html) of the test suite may be a more convenient route for you.

## FAQ ##

  1. _Isn't this essentially what [custom events][CustomEvent] are for?_

    It is. jBus is an [architecture](docs/architecture.md) built on top of custom events, which also allows for [scoping](docs/examples.md#scoping), [dependencies](docs/examples.md#dependencies) and [unicast + multicast messaging](docs/architecture.md#addresses). If global broadcasting of events is all you need, you can equally well use [custom events][CustomEvent] directly.

  2. _Isn't this essentially what [storage events][] are for?_

    Not quite. While it is true that you can store data in the [`localStorage`][localStorage] and [`sessionStorage`][sessionStorage] objects and any listener will be notified about your changes, you can only store textual data, whereas a [custom events][CustomEvent]-based architecture (such as jBus) allows you to pass around any kind of data including functions along with their [scope chain][Multiply-nested functions], which doesn't survive serialization to string.

    By the same token, [storage events][] *do* offer functionality, which cannot be achieved using [custom events][CustomEvent]. Since the [`localStorage`][localStorage] object is specific to a protocol and a domain (hereinafter an origin), any change to the object will emit a [storage event][storage events] in any open window / iframe containing the [`localStorage`][localStorage] object of the given origin other than the event  dispatcher.

    This allows for functionality such as pausing music playback in all windows other than the current one (as implemented by [soundcloud.com](http://soundcloud.com)). By contrast, a [custom events][CustomEvent]-based architecture (such as jBus) only allows for event dispatchment within the original window and other windows and iframes, to which there is a reference.

    It should now be clear that [custom events][CustomEvent]-based architectures (such as jBus) and [storage events][]-based architectures (such as [ding][]) each offer capabilities, which are mutually complementary, rather than one being a subset of the other.

[localStorage]: http://www.w3.org/TR/webstorage/#the-localstorage-attribute "Web Storage"
[sessionStorage]: http://www.w3.org/TR/webstorage/#the-sessionstorage-attribute "Web Storage"
[Storage Events]: http://www.w3.org/TR/webstorage/#the-storage-event "Web Storage"
[Multiply-nested functions]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions#Multiply-nested_functions "Functions and function scope - JavaScript | MDN"
[ding]: https://github.com/witiko/ding "Witiko/ding"

## License (MIT) ##

Copyright (c) 2014 Vít Novotný

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

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

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

repository: Witiko/jBus

gha_language: JavaScript

repo_name: Witiko/jBus


text:
# Problem solving and Fun projects

This repo is a collection of solved problems from [kattis](https://open.kattis.com/), [UVAOJ](https://uva.onlinejudge.org/) and other problems
inspired by [Projects](https://github.com/karan/Projects) repo.


text:
# node-red-contrib-mijia-filter

This Node-Red module contains the "Mijia BLE Filter" node that filters and extracts the sensor data of Mijia BLE devices obtained via [node-red-contrib-ble-scan](https://github.com/sjroe/node-red-contrib-ble-scan).

## Acknowledgements

The methodolgy and parser has been obtained from the [homebridge-mi-hygrothermograph](https://github.com/hannseman/homebridge-mi-hygrothermograph) project on GitHub.

## Installation

To install this module use Node-Red GUI installer or console command:

```
npm install node-red-contrib-mijia-filter
```

## Usage

**Input message:** **msg.payload** must be the output message from [node-red-contrib-ble-scan](https://github.com/sjroe/node-red-contrib-ble-scan).

**Output message:** **msg.payload** object that contains the following:
* _address_ - MAC address of Mijia sensor
* _data_ - object of the sensor data that may contain the following dependant on sensor type and data broadcast:
  * temperature_ - temperature from sensor
  * _battery_ - battery level in percents
  * _humidity_ - Mijia Temperature Humidity device only
  * _light_, _moisture_, _conductivity_ - MiFlora device only

## Tested With

This module has been tested with:
* MJ_HT_V1
* LYWSD02

repository: DeuceCode/node-red-contrib-mijia-filter

repo_name: DeuceCode/node-red-contrib-mijia-filter


text:
# random-code

## Contributions

If you'd like to contribute to this project,
[check out this blog post](https://whitep4nth3r.com/blog/how-to-build-test-and-release-node-module-es6)
to understand how to build and test the code locally.

---

Need some code for your project? We've got you covered. Choose your language. Choose how much code.
BÄM! You got code.

## Install package

```bash
npm install @whitep4nth3r/random-code
```

## Get random code

There are two functions available for you to use:

```javascript
import { getLanguages, generateRandomCode } from "@whitep4nth3r/random-code";
```

Use `getLanguages()` to return an Object with key/value pairs of available languages.

Use `generateRandomCode()` to generate some random code with two optional parameters.

- language (a key from `getLanguages()`)
- lines (an integer of how many lines of code you require)

If you do not provide these parameters, your result will be random.

Here's an example request:

```javascript
const myRandomCode = generateRandomCode("js", 3);
```

Here's an example response:

```json
{
  "code": "const replaceObject = () => {\n    /* FIXME: For some reason this is causing the code below to error out? */\n    const property = true;\n    return 0;\n}",
  "lines": "3",
  "languageKey": "js",
  "languageValue": "JavaScript",
  "contributors": ["whitep4nth3r", "lukeocodes", "negue", "isabellabrookes"]
}
```

## Profit

And lol.


text:
# Importing the package locally

```
"repositories": [
    {
      "type": "path",
      "url": "/../../../packages/coding-jedi-academy/laravel-package"
    }
  ]
```
---
#### Inspired by
[laravelpackage.com](https://laravelpackage.com/)

repository: CodingJediAcademy/laravel-package

repo_name: CodingJediAcademy/laravel-package


text:
# How to run the TUG demo

This tutorial will show you how to run the TUG demo on the [real robot](#running-the-tug-demo-on-the-robot) and within the [simulation environment `gazebo`](#running-the-tug-demo-on-gazebo).

## Running the TUG demo on the robot

The related application can be found [here](https://github.com/robotology/assistive-rehab/blob/master/app/scripts/AssistiveRehab-TUG.xml.template).

### Requirements

The following hardware is required:

- **NVIDIA graphics card**: for running `yarpOpenPose`;
- **[Mystrom wifi button](https://mystrom.ch/wifi-button/)**: for triggering the speech pipeline;

    !!! tip "Alternatively"
        The speech pipeline can be alternatively triggered by the hand up / down option (see [below](#running-the-demo))

- **Setup for external microphone**

### Setting up the robot

Turn on the robot, by switching on cpu and motors.

Open `yarpmanager`, click on the `Cluster` tab on the left. Click on the play icon below the `nameserver node`, then select the systems in the window underneath and click on play.

!!! tip "R1-mk2"
    Specifically, R1-mk2 has the following systems available:

    - `r1-base`: where `yarpserver` runs;
    - `r1-console-linux`: where the main modules and visualizers run;
    - `r1-console-cuda`: connected to an external Cuda box, where `yarpOpenPose` runs. Here we also deployed the [Virtual Machine](#virtual-machine-for-speech-interaction) for the speech pipeline;
    - `r1-torso1`: where the camera runs;
    - `r1-face`: where the speak and the face expression modules run;

Now that all systems are running, open a terminal and type:

```
ssh -X r1-base
yarprobotinterface
```

!!! caution
    The robot is going to move around during the demo.
    Therefore, after running the `yarprobotinterface`, be sure to unplug it from the power supply.

#### Virtual Machine for speech interaction

For running the [`speechInteraction`](https://github.com/robotology/assistive-rehab/tree/master/modules/speechInteraction) modules, you will need access to [**Google Cloud API**](https://cloud.google.com/natural-language/), which is currently deployed on the `Ubuntu 18 Virtual Machine (VM)` installed on `r1-console-cuda`.

On this system, open the `VM` and start `Ubuntu18-VM`.

When the system is on, open `yarpmanager` and run the `Google_Speech_Processing` app. Hit play and then connect.

!!! warning
    Be sure that the external microphone is connected to the system.

### Running the demo

Now we are ready to run the demo!

In `yarpmanager`, click on `Applications` and then `Assistive Rehabilitation TUG App` app, hit run and then connect.
The demo is now running!

Before starting the TUG, we need to define our world made of lines, robots and skeletons!
For doing so, you can follow [this tutorial](tug_lines.md#detecting-lines-on-the-robot).

Let's run a TUG session!

!!! question "Want to ask questions to the robot?"
    Remember to be equipped the WiFi button, the external microphone and the Virtual Machine running.

    !!! tip "Alternative to WiFi button"
        The speech pipeline can be alternatively triggered by the hand up / down option: the 3D skeleton is analyzed to detect if the hand is raised up / dropped down and consequently a start / stop is sent to the speech pipeline (the hand has to stay up during the question). This can be achieved by running `managerTUG` with the option `--detect-hand-up true`.
        However, such approach is less robust than using the button for two reasons:

          1. the person is assumed to be always in the FOV, which cannot be guaranteed in a HRI scenario;
          2. it may lead to false detection and thus trigger the speech when not required.

Open a terminal and type:

```tab="Terminal 1"
yarp rpc /managerTUG/cmd:rpc
start
```

The robot will move to the starting position defined by `starting-pose` [here](https://github.com/robotology/assistive-rehab/blob/master/modules/managerTUG/app/conf/config-it.ini).
When the robot has reached this point, the interaction starts!

The interaction keeps going on, with the robot keeping engaging the user.
You can stop it by typing in `Terminal 1`:

```tab="Terminal 1"
stop
```

## Running the TUG demo on `gazebo`

The related application can be found [here](https://github.com/robotology/assistive-rehab/blob/master/app/scripts/AssistiveRehab-TUG_SIM.xml.template).

### Dependencies

After [installing](https://robotology.github.io/assistive-rehab/doc/mkdocs/site/install/) `assistive-rehab`, you will need the following dependencies:

- [cer](https://github.com/robotology/cer/tree/devel): for running the gaze-controller and face expressions;
- [navigation](https://github.com/robotology/navigation): for controlling the robot wheels;
- [gazebo](https://github.com/vvasco/gazebo): for running the virtual environment;

!!! warning "Work in progress"
    This is a fork of `gazebo` which contains the required changes to the `Actor` class. We are working to open a pull request on the upstream repository.

- [gazebo-yarp-plugins](https://github.com/robotology/gazebo-yarp-plugins): for exposing YARP interfaces in `gazebo`;
- [cer-sim](https://github.com/robotology/cer-sim): which includes the model loaded by `gazebo` in `tug-scenario.world`;
- [speech](https://github.com/robotology/speech): for running the `iSpeak` module;
- [nodejs](https://nodejs.org/en/download/package-manager/): for handling triggers from the wifi button.

### Requirements

The following hardware is required:

- **NVIDIA graphics card**: for running `yarpOpenPose`;

#### Optional

If you want to simulate the speech interaction, you will need:

- access to [**Google Cloud API**](https://cloud.google.com/natural-language/): for running the [`speechInteraction`](https://github.com/robotology/assistive-rehab/tree/master/modules/speechInteraction) modules;

!!! warning
    You will need to have an account to access Google Cloud API.

- a [Mystrom wifi button](https://mystrom.ch/wifi-button/).

!!! info "How to configure the button"
    On the robot, the WiFi button is already configured to send triggers within the robot network. To configure your own button to run within your network, follow [this tutorial](wifi_button.md).

### Running the demo

Now that all dependencies and requirements are met, you are ready to run the demo in `gazebo`!

The first step is to open a terminal and run `yarpserver`.
Open `yarpmanager`, run the `AssistiveRehab-TUG_SIM App` and hit connect.

!!! important
    If you wish to simulate the speech interaction, be sure to run `node-button.js` on the machine you used to configure the wifi button, as explained [here](wifi_button.md).
    This script is in charge of getting the `POST` request from the button and sending a trigger to `managerTUG`.

The TUG scenario appears within the simulation environment, including the robot, a human model standing in front of it, a chair and two ArUco lines:

![default_gzclient_camera(1)-2020-05-15T18_01_58 893982](https://user-images.githubusercontent.com/9716288/82071312-3b488e80-96d6-11ea-8cee-d9119a396060.jpg)

!!! info
    The loaded scenario is described in [`tug-scenario.world`](https://github.com/robotology/assistive-rehab/blob/master/app/gazebo/tug/tug-scenario.world).

!!! tip
    By default, `gazebo` has the origin and the external gui visible. To remove the origin, you can click on `View` and deselect `Origin`. To remove the gui, you can click on `Window` and `Full screen`.

When the demo is launched, `managerTUG` waits for the command `start` to run the TUG session, which can be sent to the rpc port `/managerTUG/cmd:rpc`.
Once this is provided, the interaction starts and the simulated user successfully completes the test, while its step length is computed in real-time.
The following video shows a successful test:

[![normal](https://user-images.githubusercontent.com/9716288/82469666-a2928400-9ac4-11ea-8f1f-170f7349fdc5.png)](https://youtu.be/qbAJ97jQw_c)

!!! tip
    The demo keeps going on even after the TUG is completed, with the robot engaging the human model, which executes the TUG.

    If you want to stop the demo, you will need to provide a `stop` command to  the rpc port `/managerTUG/cmd:rpc`.

#### Simulating the verbal interaction

The verbal interaction between the robot and the human model is simulated through the following steps:

- the [Mystrom wifi button](https://mystrom.ch/wifi-button/) is integrated within the simulated demo: when the button is pressed, the human model / the robot (depending which one is moving) stops and a question can be "asked";
- a question is simulated through the [`question-simulator.sh`](https://github.com/robotology/assistive-rehab/blob/master/app/scripts/question-simulator.sh) script. The user can choose 4 keywords, specifically `speed`, `repetition`, `aid`, `feedback`, each associated to a set of questions. The script randomly selects a question associated to the chosen keyword and sends it to `googleSpeechProcess` which analyses the sentence; when `googleSpeechProcess` provides the output to `managerTUG`, the human model / the robot starts walking / navigating from where it stopped.

The following video shows how the verbal interaction is integrated within the demo:

[![questions](https://user-images.githubusercontent.com/9716288/82469863-e5ecf280-9ac4-11ea-900e-53e96ee3267d.png)](https://youtu.be/b7_848Rt98E)

#### Simulating failures

Thrift services are provided in order to simulate the human model failing the TUG.
Two possible failures are implemented:

- **the human model does not reach the target**: the robot says that the test was not passed. This can be achieved providing the command `set_target` to `/managerTUG/cmd:rpc`, as shown in the following video:

[![not-reached](https://user-images.githubusercontent.com/9716288/82470125-395f4080-9ac5-11ea-8aca-09fb4916de20.png)](https://youtu.be/OZFbunThnVE)

!!! note
    The target is defined with respect to the gazebo world frame, thus `X` pointing forward (with respect to the human model), `Y` pointing left, `Z` pointing up.

- **the human model stops**:  the robot encourages the user to finish the test, reminding to push the button to ask questions. If the human model does not complete the test, the test is not passed. This can be achieved providing the command `pause` to `/tug_input_port`, as shown in the following video:

[![pause](https://user-images.githubusercontent.com/9716288/82470264-6875b200-9ac5-11ea-8889-3f06eca99877.png)](https://youtu.be/ehFkVaHG8tA)

!!! tip
    You can also set the time during which the human model has to be paused, by specifying the seconds after `pause`. For example, to pause it for `2 s`, you can provide `pause 2.0` to `tug_input_port`: after the `2 s`, the human model starts walking again.

repository: zhangfaquan/assistive-rehab

repo_name: zhangfaquan/assistive-rehab


text:
# Software Developer Jobs in Dubai
A curated list of companies who hire in Dubai. Inspired by this Reddit posting: https://redd.it/85wul5

## Companies hiring
- [Bayzat](https://www.bayzat.com/careers)
- [Careem](https://jobs.jobvite.com/careem/search?l=Dubai+Basecamp&c=Engineering&q=)
- [Consensys](https://new.consensys.net/careers/)
- [dubizzle](https://www.joinolx.com/careers/search/uae/engineering)
- [Emaratech](https://ldd.tbe.taleo.net/ldd03/ats/careers/searchResults.jsp?org=EMARATECH&cws=1)
- [Fetchr](https://fetchr.workable.com/)
- [Namshi](https://tech.namshi.io/join-us/)
- [Track24](https://www.track24.com/joinus/)
- [Tribalscale](http://www.tribalscale.com/careers)

## Recruiters looking
- [Digital Gurus](http://www.digitalgurus.ae/jobs/technical)
- [Leap](https://helloleap.com/company/all/job?job_location=7830&keyword=&keyword=software)
- [Salt](https://www.welovesalt.com/uae/jobs/job-location/uae-dubai/)

## Contributing
See something that is missing from this list? Stale link? Suggestions for improvement? Send me a pull request! Thanks 😎

[![](https://ga-beacon.appspot.com/UA-116354229-1/)](https://github.com/igrigorik/ga-beacon)

repository: tvthatsme/dubai-dev-jobs

repo_name: tvthatsme/dubai-dev-jobs


text:
# GifMagic

[![CI Status](http://img.shields.io/travis/onmyway133/GifMagic.svg?style=flat)](https://travis-ci.org/onmyway133/GifMagic)
[![Version](https://img.shields.io/cocoapods/v/GifMagic.svg?style=flat)](http://cocoadocs.org/docsets/GifMagic)
[![Carthage Compatible](https://img.shields.io/badge/Carthage-compatible-4BC51D.svg?style=flat)](https://github.com/Carthage/Carthage)
[![License](https://img.shields.io/cocoapods/l/GifMagic.svg?style=flat)](http://cocoadocs.org/docsets/GifMagic)
[![Platform](https://img.shields.io/cocoapods/p/GifMagic.svg?style=flat)](http://cocoadocs.org/docsets/GifMagic)
![Swift](https://img.shields.io/badge/%20in-swift%203.0-orange.svg)

## Encoder

#### Encode images into gif file

```swift
let url = Encoder().encode(images: images, frameDuration: 0.05)
```

## Decoder

#### Decode gif file into images and get info

```swift
let info = Decoder().decode(gifUrl: url)

info.images
info.frameDuration
info.pixelWidth
info.pixelHeight
```

#### Decode video file into images and get info

```swift
let info = Decoder().decode(videoUrl: url)

info.images
```

## Modifier

#### Modify each frame within the gif

```swift
let newGifUrl = Handler().modify(gifUrl: url, closure: { image in
  // Handle image the way you want
  return image
})
```

## Installation

**GifMagic** is available through [CocoaPods](http://cocoapods.org). To install
it, simply add the following line to your Podfile:

```ruby
pod 'GifMagic'
```

**GifMagic** is also available through [Carthage](https://github.com/Carthage/Carthage).
To install just write into your Cartfile:

```ruby
github "onmyway133/GifMagic"
```

**GifMagic** can also be installed manually. Just download and drop `Sources` folders in your project.

## Author

Khoa Pham<EMAIL_ADDRESS>
## Contributing

We would love you to contribute to **GifMagic**, check the [CONTRIBUTING](https://github.com/onmyway133/GifMagic/blob/master/CONTRIBUTING.md) file for more info.

## License

**GifMagic** is available under the MIT license. See the [LICENSE](https://github.com/onmyway133/GifMagic/blob/master/LICENSE.md) file for more info.

repository: mohsinalimat/GifMagic

repo_name: mohsinalimat/GifMagic


text:
---
title: Simple upload example | Sirius Upload
---

# Simple example

### Initialize the upload handler class

Let's consider a simple contact form that has the following field: `name`, `email`, `phone` and `message`.

```php
use Sirius\Upload\Handler as UploadHandler;
$uploadHandler = new UploadHandler('/path/to/local_folder');

// set up the validation rules
$uploadHandler->addRule('extension', ['allowed' => 'jpg', 'jpeg', 'png'], '{label} should be a valid image (jpg, jpeg, png)', 'Profile picture');
$uploadHandler->addRule('size', ['size' => '20M'], '{label} should be less than {size}', 'Profile picture');
$uploadHandler->addRule('imageratio', ['ratio' => 1], '{label} should be a square image', 'Profile picture');

```

### Process the upload

```php

$result = $uploadHandler->process($_FILES['picture']); // ex: subdirectory/my_headshot.png

if ($result->isValid()) {
    try {

        // do something with the image like attaching it to a model etc
        $profile->picture = $result->name;
        $profile->save();
        $result->confirm(); // this will remove the .lock file

    } catch (\Exception $e) {

        // something wrong happened, we don't need the uploaded files anymore
        $result->clear();
        throw $e;

    }
} else {

    // image was not moved to the container, where are error messages
    $messages = $result->getMessages();

}
```

repository: siriusphp/upload

gha_language: PHP

repo_name: siriusphp/upload


text:
SlideShareEmbed
===============

jQuery plugin to embed SlideShare player by simply providing the URL

#Usage

Right now the plugin is very bare.  Simply create an anchor tag with the SlideShare URL as the href attribute and then supply the element/class/id to the slideShareEmbed plugin.

Include the script after jQuery is included
```HTMl
<script src="../YourPathHere/jquery.slideShareEmbed.js"></script>
```

##Example

###HTML
```HTMl
<a class="slideshare" href="http://www.slideshare.net/mykebates/power-without-plugins-wordcamp-miami-2012">SlideShare Test</a>
```

###JavaScript
```JavaScript
$(function() {
	$(".slideshare").slideShareEmbed();
});
```

repository: mykebates/SlideShareEmbed

repo_name: mykebates/SlideShareEmbed


text:
---
layout: page
title: About Me
permalink: /about/
---

I'm Dean, currently a *Senior Software Engineer* at *LinkedIn* based in the Bay Area,
California. I've spent over 4 years in the bay working as a leader in the intersection
of Data Science and Big Data Engineering at consulting firms, startups,
and top tech companies such as *Facebook* and *LinkedIn*.

Outside of my career, I spend my time learning and teaching about personal finance
and investing. I've been a serious investor for nearly a decade, making my money
grow and work for me with passive income and good financial management. I've
invested in things like high-yield savings accounts, stocks, options, bonds crypto,
and real estate.

I hope to make this blog a documentation of the things I've learned and a way to
help others progress in their careers and financial lives as much as possible.

### My Data Science and Engineering Experience (4+ years)

I graduated from Reed College in 2016 with a B.A. in Mathematics-Economics. I loved
working with data, statistics, and computer science and knew I wanted to make a career
out of it.

My first forage into the tech world was with a health-tech startup, Nuna Health.
The company's product was a Data Science product that personalized matches for
patients and healthcare providers. I was a Data Scientist by title, but in the
startup world you wear many hats. I not only spent time creating machine learning
solutions but also implementing them in production pipelines to keep the product
running scalably, something that usually falls in the hands of ML/data engineers.

I got a great opportunity to move to Facebook as a Data Scientist to work in their
small business space. There I also worked at the intersection of data science and
engineering. My largest accomplishment was in completely automating a sales reporting
pipeline that reported on millions of advertisers and hundreds of dimensions which
reduced report compilation times from weeks to hours.

Next I decided that I wanted build more on my engineering skills while still
supporting data science efforts. A perfect opportunity came for me at LinkedIn,
where I am now. I support a marketing data science team in their data foundations.

**Throughout my career, I have given and participated in dozens of interviews for
both data science and data engineering. In addition to Nuna, Facebook, LinkedIn,
I've also done and passed interviews at several top tech companies in the Bay Area
including Netflix, Apple, and Houzz.**

### My Investing and Personal Finance Experience

When I started in college I had less than $1,000 to my name. I started off by
opening a high-yield savings account that paid far more interest than most brick
and mortar banks. By following the principles of *financial minimalism* strictly,
I was able to graduate college with 5-figures of savings.

I worked several jobs and internships throughout my time in college and used the
money to open a Roth IRA to invest in stock index funds.

Fast forward to today, I've invested in stocks, bonds, options, real estate, and
even dipped my toes in crypto. I've amassed a 6-figure investment portfolio by
abiding strictly by the principles of *financial minimalism* and also staying
the course even when there is market turmoil.

### Contact me

Please direct all business inquiries to:

[{{ site.email }}](mailto:{{ site.email }})


text:
# Progress towards my learning goals

## 2018

something about your goals here

## Progress

Current
Courses Completed: 0
Total Points earned:

| Date Finished | Activity                  | Points | Links  |
| ------------- | ------------------------- | ------ | ------------------------------------------- |
|  |  |  |  |

## Get Job Ready - Python Edition

Work through these courses, read the books listed below, and frequently supplement with "bonus activities" listed below.

- [ ]  [College Algebra and Problem Solving](https://www.edx.org/course/college-algebra-problem-solving-asux-mat117x)
- [ ]  [Precalculus](https://www.edx.org/course/precalculus-asux-mat170x)
- [ ]  [Try Git](https://try.github.io/levels/1/challenges/1)
- [ ]  [Learn to Code HTML & CSS](http://learn.shayhowe.com/html-css/)
- [ ]  [Programming for the Web with JavaScript](https://www.edx.org/course/programming-web-javascript-pennx-sd4x)
- [ ]  [Learn to Code Advanced HTML & CSS](http://learn.shayhowe.com/advanced-html-css/)
- [ ]  [Data Visualization and D3.js](https://www.udacity.com/course/data-visualization-and-d3js--ud507)
- [ ]  [MongoDB for Developers](https://university.mongodb.com/courses/M101P/about) - note: this course is only intermittently offered, sign up at the start of the Tier, then proceed to the other courses and return to this one when it's in session
- [ ]  [Introduction to Computer Science and Programming Using Python](https://www.edx.org/course/introduction-computer-science-mitx-6-00-1x-11)
- [ ]  [Calculus One](https://www.coursera.org/learn/calculus1)
- [ ]  [Introduction to Computational Thinking and Data Science](https://www.edx.org/course/introduction-computational-thinking-data-mitx-6-00-2x-6)
- [ ]  Challenge: [Python Interview Prep](https://www.hackerrank.com/chingu-challenge-3) on Hackerrank. Sign up now and work problems alongside the rest of the courses.
- [ ]  [Mathematics for Computer Science](https://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-042j-mathematics-for-computer-science-spring-2015/index.htm)
- [ ]  [Intro to Machine Learning](https://www.udacity.com/course/intro-to-machine-learning--ud120)
- [ ]  [Database Mini-Courses](https://lagunita.stanford.edu/courses/DB/2014/SelfPaced/about) - take all mini-courses

---

## Book Suggestions
- [ ]  [College Algebra](https://openstax.org/details/books/college-algebra)
- [ ]  [Precalculus](https://openstax.org/details/books/precalculus)
- [ ]  [You Don't Know JS: Up & Going](https://github.com/getify/You-Dont-Know-JS/blob/master/up%20&%20going/README.md#you-dont-know-js-up--going)
- [ ]  [You Don't Know JS: Scope & Closures](https://github.com/getify/You-Dont-Know-JS/blob/master/scope%20&%20closures/README.md#you-dont-know-js-scope--closures)
- [ ]  [You Don't Know JS: this & Object Prototypes](https://github.com/getify/You-Dont-Know-JS/blob/master/this%20&%20object%20prototypes/README.md#you-dont-know-js-this--object-prototypes)
- [ ]  [You Don't Know JS: Types & Grammar](https://github.com/getify/You-Dont-Know-JS/blob/master/types%20&%20grammar/README.md#you-dont-know-js-types--grammar)
- [ ]  [You Don't Know JS: Async & Performance](https://github.com/getify/You-Dont-Know-JS/blob/master/async%20&%20performance/README.md#you-dont-know-js-async--performance)
- [ ]  [You Don't Know JS: ES6 & Beyond](https://github.com/getify/You-Dont-Know-JS/blob/master/es6%20&%20beyond/README.md#you-dont-know-js-es6--beyond)
- [ ]  [JavaScript Allongé, the "Six" Edition](https://leanpub.com/javascriptallongesix)
- [ ]  [JavaScript Design Patterns](https://addyosmani.com/resources/essentialjsdesignpatterns/book/)
- [ ]  [Think Python](http://greenteapress.com/thinkpython2/thinkpython2.pdf)
- [ ]  Study: [The Flask User Guide](http://flask.pocoo.org/docs/0.12/) or [the Django documentation](https://docs.djangoproject.com/en/1.11/) - pick based on which is more prevalent in your area, which you personally prefer, or any other criteria you choose, but pick one and study it thoroughly. Do the tutorials, read it all, learn testing, auth, databases, all of it.
- [ ]  Study: [The pytest testing tool](https://docs.pytest.org/en/latest/) read the docs thoroughly, experiment with the examples and become proficient with pytest (including unittest and nose).
- [ ]  [Open Data Structures](http://www.aupress.ca/books/120226/ebook/99Z_Morin_2013-Open_Data_Structures.pdf)

Additional books can be found [here](https://github.com/P1xt/speedstudy/blob/master/book-lists.md)

## Bonus List

| Activity                                    | Points for completing | Activity type |
| ------------------------------------------- | --------------------- | ------------- |
| Basic Project                               | 100                   | project       |
| Substantial Project                         | 200                   | project       |
| Large Project                               | 300                   | project       |
| Gigantic Project                            | 400                   | project       |
| Duolingo or MosaLingua (1 level)            | 100                   | foundation    |
| Book                                        | 200                   | foundation    |
| Tutorial site (Udemy/Pluralsight/Egghead/Treehouse/etc) course                            | 100                   | foundation    |
| University level course (Coursera/edX/MITOCW/etc)                    | 500                   | foundation    |
| Physical Activity (30 minutes)                          | 10                    | foundation    |
| Musical Instrument Practice (30 minutes)                          | 10                    | foundation    |
| Khan Academy (30 minutes)                          | 10                    | foundation    |
| Analytics Vidhya Competition                | 50                    | data-science  |
| Crowd Analytix Competition                  | 50                    | data-science  |
| Kaggle Competition                          | 50                    | data-science  |
| Driven Data Competition                     | 50                    | data-science  |
| Blog Post on any topic                      | 15                    | communication |
| Blog Post Tutorial                          | 40                    | communication |
| Video Tutorial                              | 50                    | communication |
| Open Source PR                              | 50                    | communication |
| Module to npm                               | 200                   | communication |
| Team Up for a project                       | 100                   | communication |
| Diary entry                                 | 5                     | communication |
| CodeWars (10 problems)                      | 50                    | algorithms    |
| CodinGame (1 Tier)                          | 100                   | algorithms    |
| CodinGame (1 Bot Competition)               | 20                    | algorithms    |
| HackerRank (10 problems)                    | 50                    | algorithms    |
| Google Code Jam (1 round from past contest) | 100                   | algorithms    |

## Project ideas

*   Pick a template from [\[here\]](https://freebiesbug.com/psd-freebies/website-template/), [\[here\]](http://www.os-templates.com/free-website-templates), or [\[here\]](http://www.os-templates.com/free-website-templates) and implement the frontend of a website with it as your inspiration (do not use its assets)
*   Complete any 5 projects from [100 Days of CSS](https://100dayscss.com/).
*   Select an API from [Todd Motto's API List](https://github.com/toddmotto/public-apis) and build a frontend-only application powered by data fetched from the API you chose.
*   Complete a CSS theme for [CSS Zen Garden](http://www.csszengarden.com/)
*   Clone your favorite non-trivial website such as: Medium, Twitter, Slack, Netflix, Reddit.
*   Clone a video game such as: Breakout, Tetris, Pacman, Super Mario Bros, Zelda, Final Fantasy.
*   Complete any project on The Odin Project or FreeCodeCamp.
*   Clone your favorite browser extension, or create one you wish existed.
*   Clone your favorite mobile app, or create one you wish existed.
*   Any project you want to build - the above are all just ideas for if you're stuck for an idea - really, just build what you want!

repository: khyati-k/speedstudy

repo_name: khyati-k/speedstudy


text:
---
layout: default
title: SystemInfo
description: Information about a system's capabilities and properties!
---
# SystemInfo

Information about a system's capabilities and properties!

## Instance Fields and Properties

|  |  |
|--|--|
|int [displayHeight]({{site.url}}/Pages/Reference/SystemInfo/displayHeight.html)|Height of the display surface, in pixels! For a stereo display, this will be the height of a single eye.|
|[Display]({{site.url}}/Pages/Reference/Display.html) [displayType]({{site.url}}/Pages/Reference/SystemInfo/displayType.html)|The type of display this device has.|
|int [displayWidth]({{site.url}}/Pages/Reference/SystemInfo/displayWidth.html)|Width of the display surface, in pixels! For a stereo display, this will be the width of a single eye.|

repository: rblenkinsopp/StereoKit

repo_name: rblenkinsopp/StereoKit


text:
### MIDI

Todo

### Global hotkeys

Uses pynput, but on Mac permissions are a pain now: [helpful instructions](https://textexpander.com/kb/mac/textexpander-is-forcing-me-to-enable-access-for-assistive-devices-how-and-what-is-that/#:~:text=Go%20to%20the%20System%20Preferences,%E2%80%9CEnable%20for%20assistive%20devices.%E2%80%9D)

repository: beesandbombs/coldtype

repo_name: beesandbombs/coldtype


text:
# SmoothieHeatmap
Drawing real-time heatmaps using smoothie interface.

Only redraws the right edge of the heatmap, so fairly performant. Canvas is "copy-pasted" on each tick from right-to-left.

Demo here: https://mharradon.github.io/SmoothieHeatmap/

Based off http://smoothiecharts.org/

See example for usage.

repository: mharradon/SmoothieHeatmap

repo_name: mharradon/SmoothieHeatmap


text:
# PlaytestingPlugin

This is a Spigot (Minecraft) plugin which hooks into a Discord bot to handle automatic whitelisting for playtest players for my plugin challenge streams over at https://youtube.com/c/JordanOsterberg.

You'll need to create a Discord bot to use this plugin.


text:
## Contribute

Please read the [code of conduct] before contributing.

If you want to run from BaGet's source code:

1. Install the [.NET SDK] and [Node.js]
2. Run `git clone https://github.com/loic-sharma/BaGet.git`
3. Navigate to `./BaGet/src/BaGet`
4. Start the service with `dotnet run`
5. Open the URL `http://localhost:5000/v3/index.json` in your browser

[Code of conduct]: CODE_OF_CONDUCT.md
[.NET SDK]: https://www.microsoft.com/net/download
[Node.js]: https://nodejs.org/


text:
# Gathering System

# Interactive Object:
An actor that can be `Interacted` with the player. <br/>
The Interactive Objects can be interacted based on what the player is holding and the quality tier.
* Data:
  * Required Tool: `Tool`
  * Required Tool-Tier: `Tier Number`
  * Item Objects: `List of Item Object`
  * Dropper Component: `Dropper Component`

__Required Tool__: What Tool required to be interacted with this Interactive Object.
__Required Tool-Tier__: What the tool tier has to be for the Interacted Object to be interacted.
__Item Objects__: A list of the possible item drops that can be dropped.
__Dropper Component__: The Dropper Components will be ONLY used for Interactive and Enemies. Dropper Component will calculate the random drop rate based on Player Skill Level and the Interactive Object itself.

# Item Object:
An actor that can be `picked up` by the player.
* Data:
  * Quantity
  * Item Info

__Quantity__: The number of Item object that is going to be dropped
__Item Info__: Item information data.

# Item information (DATA)
A `structure` that contains all the data that describes the item. This is our main data that will be passed around.
* Data:
  * Item name (TEXT)
  * Item description (TEXT)
  * Item category (E_Item_Category)
  * Item quantity (INT)
  * Item rarity (INT)
  * Item maxStack (INT)
  * Item icon (Texture 2D)

## Item Category Types (E_Item_Category)
__NEEDS ATTENTION__
* Material
* Consumable
* Equipment

## Equipment Category (E_Equipment_Category)
__NEEDS ATTENTION__
* Pickaxe
* Axe
* Sword
* GreatSword
* Helm
* Torso
* Legging
* Shield
* Fishing Rod


text:
# FastaFinder

FastaFinder is a tool for quickly finding the FASTA sequence given only an accession number.
Dedicated server to come!

## Installation
Clone the repository and use a python3 virtualenv to install python requirements.
```bash
>>> git clone https://github.com/liamhawkins/FastaFinder.git
>>> cd FastaFinder
>>> virtualenv venv -p $(which python3)
>>> source venv/bin/activate
>>> pip install -r requirements.txt
```

## Usage
Launch the Django web server
```bash
>>> python manage.py runserver
```
Then point your browser to the web server

`http://<IP_ADDRESS>:8000/`

You can directly query an accession by appending it to the url

`http://<IP_ADDRESS>:8000/P04797`

Which returns the Uniprot Human GAPDH Fasta sequence! Cool!
![Screenshot](./screenshot.png?raw=true)

## Supported Accession IDs
Currently the following accessions are supported:

| Source | Example |
| --- | --- |
| Uniprot | P04797 |
| NCBI Refseq | NP_001243728.1 |
| MirBase ID | MI0000060 |
| MicroRNA name | hsa-let-7a-1 |

## Test
Tests can be run using the Django test runner
```bash
>>> python manage.py test
```

## LICENSE
[Link](https://choosealicense.com/licenses/mit/)

repository: liamhawkins/FastaFinder

gha_language: Python

repo_name: liamhawkins/FastaFinder


text:
# Authorization Web App

It is a web app with configured compiling of TS into JS and bundling with webpack.
The app shows how to use the APIs from `@here/olp-sdk-dataservice-api`.

You can use all the `AuthorizationAPI` functions in the same way as in this example.

## Setup

1. Download the current folder to your PC.
2. Add your app key and secret to your enviropment.
    ```
    export OLP_APP_KEY=<your app key>
    export OLP_APP_SECRET=<your app secret>
    ```
3. Install the dependencies.

    ```
    npm install
    ```

## Build and run

1. Compile TS into JS.

    ```
    npm run compile
    ```

2. Bundle with webpack.

    ```
    npm run build
    ```

3. Start the web server.

    ```
    npm start
    ```

4. Open in your favorite browser http://localhost:8080

repository: OleksiiZubko/here-data-sdk-typescript

repo_name: OleksiiZubko/here-data-sdk-typescript


text:
---
layout: post
title: Linux-Explorer - Live Forensics Toolbox
---
![](/images/2020-06-17-linexp/0.png)

Issue: (Exception: error: YARA not installed solution)

Hello guys, The other day I was testing some DFIR tools and I came across this linux live forensic tool called linux-explorer. The reason why I am writing this tutorial is due to the lack of documentation or tutorial out on the internet that helps people with common issues that you might encounter during installation. I spend quite some time trying to find a solution for an issue I encountered and I want to show you guys how I solved it and hopefully this might save you some time.

Linux Explorer is an Easy-to-use live forensics toolbox for Linux endpoints written in Python & Flask.

The link to the Github repo : [https://github.com/intezer/linux-explorer](https://github.com/intezer/linux-explorer)

This tool can be used to get information from linux such as :

 process list, Inspect process memory map & fetch memory strings easly, Dump process memory in one click, Automatically search hash in public services, users list etc.

Other capabilities include: Scan a file or directory using YARA signatures by @Neo23x0, Scan a running process memory address space, Upload your own YARA signature.

###Installation

```
git clone https://github.com/intezer/linux-explorer.git
```

This will clone the repository to your local machine.

Before any installation make sure to install

1) YARA
2) Chkrootkit

On an ubuntu machine you can install these by:

```
sudo apt install yara
```

```
sudo apt install chkrootkit
```

Now cd into the repo

```
cd linux-explorer/
```

The repository have a requirement.txt file that specify all python modules needed for this to work, so go ahead and install that by:

```
pip install -r requirement.txt
```

now start the script by

```
./start_server.sh
```

This script is intended to deploy the linux_explorer.py for you.

So, this is where I encountered an error:

```
Traceback (most recent call last):
File "linux_explorer.py", line 21, in
toolbox = dict({'yara': tools.YARA(),
File "/home/linux_expl0rer/tools.py", line 16, in __init__
raise Exception('error: %s not installed' % self.__class__.__name__)
Exception: error: YARA not installed
```

Intresting, I installed YARA but I still got the error. I tried searching to find a solution for this error but eventually after snooping through all clutters I gave and decide to read the source code.

```
class YARA(Tool):
  def _is_installed(self):
    return os.path.isfile('/usr/bin/yara')

  def set_cmdline(self, rule_file, dir='/', recursive=True, pid=None):
    if pid:
          self._proc_cmdline = ['/usr/bin/yara', rule_file, pid]

    else:
        self._proc_cmdline = ['/usr/bin/yara'] + ['-r',rule_file, dir] if recursive els

```

so this code is looking for yara at the predefined location /usr/bin/yara.

Lets see where our yara is installed:

```
find / -name yara 2> /dev/null
```

In the result I noticed that yara is installed in:

```
/usr/local/bin/yara
```

Okay !! so now we just have to edit the code to point the correct location in our OS.

Now the source code will look as follow :

```
class YARA(Tool):
  def _is_installed(self):
    return os.path.isfile('/usr/local/bin/yara')

  def set_cmdline(self, rule_file, dir='/', recursive=True, pid=None):
    if pid:
          self._proc_cmdline = ['/usr/local/bin/yara', rule_file, pid]

    else:
        self._proc_cmdline = ['/usr/local/bin/yara'] + ['-r',rule_file, dir] if recursive els

```

Now start the script again and it should work and you can navigate to the browser view by:

```
start firefox http://<IP_ADDRESS>:8080
```

gha_language: CSS


text:
# go-whosonfirst-markdown

There are many Markdown tools. This one is ours.

## Install

You will need to have both `Go` (specifically a version of Go more recent than 1.7 so let's just assume you need [Go 1.9](https://golang.org/dl/) or higher) and the `make` programs installed on your computer. Assuming you do just type:

```
make bin
```

All of this package's dependencies are bundled with the code in the `vendor` directory.

## Important

Everything is in flux, right now. Lots of things will change.

 That your Markdown files have Jekyll-style "front matter"
2. That you have one Markdown file per directory

## What is "front matter"

"Front matter" is metadata included between `---` brackets at the top of a Markdown file. For example:

```
---
layout: page
category: blog
title: Bundling up descendants into GeoJSON
excerpt: We made a handy tool that lets you download the descendants of a place as GeoJSON.
image: images/wof_canada-descender.gif
authors: [burritojustice, stepps00, dphiffer]
tags: [whosonfirst, data]
---

Every record in [Who’s On First](https://whosonfirst.mapzen.com/spelunker/), our gazetteer of places around the world, has two powerful properties -- geometry and hierarchy. Since the raw data of any WOF record is a blob of GeoJSON, you can take the URL and draw it in any modern mapping application with minimal effort. We thought it would be nice to let you grab GeoJSON for a bunch of records at once, so we added a tool called the Bundler for you using the soon-to-be-released Who’s On First API.
```

## Tools

### wof-md2html

Render one or more Markdown files as HTML.

```
./bin/wof-md2html -h
Usage of ./bin/wof-md2html:
  -footer string
    	The path to a custom (Go) template to use as a footer for your HTML output
  -header string
    	The path to a custom (Go) template to use as header for your HTML output
  -input string
    	What you expect the input Markdown file to be called (default "index.md")
  -mode string
    	Valid modes are: files, directory (default "files")
  -output string
    	What you expect the output HTML file to be called (default "index.html")
  -writer value
    	One or more writer to output rendered Markdown to. Valid writers are: fs=PATH; null; stdout
```

### wof-markdown-to-search

_This tool will be renamed. Also it is incomplete. Hence the weird results below, but you get the idea..._

```
./bin/wof-markdown-search -query bummer examples/index.md
2018/01/07 18:37:25 INDEX examples/index.md Who's On First, Chapter Two
2018/01/07 18:37:25 2 matches, showing 1 through 2, took 251.079µs
    1. debug (0.008869)
    2. Who's On First, Chapter Two (0.008866)
```

Currently this uses [Bleve](https://github.com/blevesearch/bleve) under the hood.

## See also

* github.com/microcosm-cc/bluemonday
* gopkg.in/russross/blackfriday.v2


text:
# oneleif Website Front End

Repository for the oneleif website's front-end, written with the JavaScript Library React.

The oneleif website is aiming to serve as a central hub for oneleif members to find active projects, make posts, search for help/advice and communicate with recruiters for career advice/potential jobs.

## Table of contents
* [Contribution](#contribution)
* [Goals & Roadmap](#goals)
* [Associated Projects](#associated-projects)
* [How to Join](#how-to-join-oneleif)
* [Questions?](#questions)

## Contribution

To get started working on this project, please see our wiki: https://github.com/oneleif/olWebsite-React/wiki

## Goals

### Roadmap
##### Version 1.0.0 - MVP
* Landing View/Home Page
* Contact Us Page
* Active Projects Page
* Detailed Project View
* Meet the team Page

##### Version 2.0.0
* Login/Register Functionality
* User Profile View
  * User View (Self)
  * External View
* Create Posts Functionality
* Search Functionality

### Important Links

| Description   | Link         |
| ------------- | ------------ |
| Production Environment  | https://oneleif.com/ |
| Development Environment | https://dev.oneleif.com/ |
| Website Designs (Figma) | https://www.figma.com/file/zukLdUXgDYBhPAU8NZbljW/OL-Website-Workspace?node-id=418%3A6 |
| Meeting Notes (HackMD)  | https://hackmd.io/@oneleif |
| CI/CD (CircleCI)        | https://app.circleci.com/pipelines/github/oneleif/olWebsite-React |

### Associated Projects

To see the Swift/Vapor back-end for the oneleif website, please see the following repository: https://github.com/oneleif/VaporWebsite

To see the oneleif iOS app please see the following repository: https://github.com/oneleif/olGO

To see the oneleif Android app please see the following repository: https://github.com/oneleif/olgo-android

![](https://github.com/oneleif/olDocs/blob/master/assets/images/oneleif_logos/full_logo/oneleif_transparent.png?raw=true)
This project is a oneleif active project, meaning it is open sourced and ran by members of oneleif, with support of other oneleif members.

[![](https://img.shields.io/badge/oneleif-Twitter-blue.svg)](https://twitter.com/oneleifdev)

[![](https://img.shields.io/badge/oneleif-YouTube-red.svg)](https://www.youtube.com/channel/UC3HN0jID38K0Vb_WChvgQmA)

## How to join oneleif
Click on the link below to join the Discord server.

You will start with limited permissions, in a text channel that only moderators will see.

To get full access: read the rules, make an introduction in #introductions, and add an appropriate username.

When you're done with the above, shoot a message to the #start channel to let us know, and we will give you full access.

[![](https://img.shields.io/badge/oneleif-Discord-7284be.svg)](https://discord.gg/tv9UdJK)

## Questions?
Feel free to email us at<EMAIL_ADDRESS>or throw a question into the #oneleif-website channel in our discord server

repository: oneleif/olWebsite-React

branch_name: refs/heads/develop

repo_name: oneleif/olWebsite-React


text:
---
layout: default
---

# 1997-06-07 - Re: Privacy in Europe

## Header Data

From: "William H. Geiger III"<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: 25818044cdd00cf7fcc96d727d2e931ef0105a0c98d6e92fb25f50ca3f57968a

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1997-06-07 01:47:44 UTC

Raw Date: Sat, 7 Jun 1997 09:47:44 +0800

## Raw message

```
{% raw  %}From: "William H. Geiger III"<EMAIL_ADDRESS>Date: Sat, 7 Jun 1997 09:47:44 +0800
To<EMAIL_ADDRESS>Subject: Re: Privacy in Europe
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

-----BEGIN PGP SIGNED MESSAGE-----

In <Pine.3.89.9706061758.A25516-0100000@netcom22>, on 06/06/97
   at 05:49 PM, Lucky Green<EMAIL_ADDRESS>said:

>The recent post by John Young about the German woman charged with linking
> to Radikal caused me to investigate this issue.

>You may have heard that Radikal had an article on sabotaging train
>systems. The article simply stated that if you break open a certain type
>of control box found next to train tracks and yank the circuit boards,
>the trains will refuse to enter the given track segment. Hardly the worst
>of possible sabotages and considerably less fatal than other methods
>discussed on a mailing list near you.

>BTW, the woman has now been slapped with a new charge. Apparently it is
>illegal in Germany to publish criminal complaints. [Due to privacy
>regulations?]

>Since the woman has the official paperwork detailing the charges against
>her on her web site, she has now been charged *again* for violating the
>prohibition against publishing the official court documents.

>Things are better in Europe? You must to be joking.

The problem with Europe is we kicked out the Germans and left the Nazi's.

- --
- ---------------------------------------------------------------
William H. Geiger III  http://www.amaranth.com/~whgiii
Geiger Consulting    Cooking With Warp 4.0

Author of E-Secure - PGP Front End for MR/2 Ice
PGP & MR/2 the only way for secure e-mail.
OS/2 PGP 2.6.3a at: http://www.amaranth.com/~whgiii/pgpmr2.html
- ---------------------------------------------------------------

-----BEGIN PGP SIGNATURE-----
Version: 2.6.3a
Charset: cp850
Comment: Registered_User_E-Secure_v1.1b1_ES000000

iQCVAwUBM5i6no9Co1n+aLhhAQFIYAQAoK5o6kQ36FeI3B5uP2/FGZfpTDanDYnc
LY0TCxv1BeJrzCw8nvWleouOw3IwzJmK3EiCp6A4K9svrZPfWGSXhZjvyW+6tJPB
ujAz/gyUj2mFNdLz6/bJHp4uIirWPxyiJrGlBuEA8uJrGiu4n20zsXeBAvNNUY6u
6kiak6sbr9Y=
=Tj5L
-----END PGP SIGNATURE-----

{% endraw %}
```

## Thread

+ Return to [June 1997](/archive/1997/06)

+ Return to "["William H. Geiger III" <whgiii@amaranth.com>](/authors/william_h_geiger_iii_whgiii_at_amaranth_com_)"

+ 1997-06-07 (Sat, 7 Jun 1997 09:47:44 +0800) - Re: Privacy in Europe - _"William H. Geiger III"<EMAIL_ADDRESS>


text:
# Irpex pseudozilingianus (Parmasto) Saaren. & Kotir., 2002 SPECIES

#### Status
SYNONYM

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

#### Published in
in Kotiranta & Saarenoksa, Polish Botanical Journal 47(2): 106 (2002)

#### Original name
Chaetoporus pseudozilingianus Parmasto, 1959

### Remarks
null

repository: mdoering/backbone

path: /life/Fungi/Basidiomycota/Agaricomycetes/Polyporales/Meruliaceae/Junghuhnia/Junghuhnia pseudozilingiana/ Syn. Irpex pseudozilingianus/README.md

repo_name: mdoering/backbone


text:
# OpenCv server

This app reads from the pi zero's video feed it then
processes the output and streams the output on its
server on the default flask port of 5000.

It assumes you already have opencv and numpy installed.

only the main.py and camera.py are used in this repos, the
other files are for trying out things.

To run:

```python3

# install the dependencies.
> pip3 install -r requirements.txt

# run the app
> python3 server.py
```

repository: philstenning/openCV-face

repo_name: philstenning/openCV-face


text:
Delegates user resources and permissions as part of the IT - Employee Offboarding playbook.

## Dependencies
This playbook uses the following sub-playbooks, integrations, and scripts.

### Sub-playbooks
This playbook does not use any sub-playbooks.

### Integrations
* Builtin

### Scripts
This playbook does not use any scripts.

### Commands
* setIncident
* gmail-delegate-user-mailbox
* send-mail
* gmail-set-autoreply

## Playbook Inputs
---

| **Name** | **Description** | **Default Value** | **Source** | **Required** |
| --- | --- | --- | --- | --- |
| UserManagerEmail | The email of the manager of the user that is being offboarded. | employeemanageremail | incident | Optional |
| OffboardingUserEmail | The email address of the user that is being offboarded. | employeeemail | incident | Required |
| AutoreplyMessage | The automatic message that is sent as a reply message from the user that has been offboarded once they no longer have access to their email account. | This employee is no longer with our company. | - | Optional |

## Playbook Outputs
---
There are no outputs for this playbook.

## Playbook Image
---
![Employee_Offboarding_Delegate](https://raw.githubusercontent.com/demisto/content/1bdd5229392bd86f0cc58265a24df23ee3f7e662/docs/images/playbooks/Employee_Offboarding_Delegate.png)

repository: demisto/content

repo_name: demisto/content


text:
# gdg-tokyo.github.io
This page for GDG DevFest 2018 Tokyo.

## Thank you for landen.co
We created landing page using landen.
And they allowed for us to publish source code at GitHub.
Thanks for any convennience.

### What's landen?
[landen.co](https://www.landen.co/) design beautiful landing pages.
They can use free basically.


text:
# Dairy_Business
#### A website on a Dairy Business that uses the function properties as well as other html and css properties I have learnt on web development, 30 Apr 2021
#### By **Robert Maina**
## Description

This application is a website on Dairy Business. It will provide a report on how much milk is produced per shed and the total amount of milk produced by all sheds. The purpose of the application is to solidify my understanding of concepts learnt during the week i.e. data-types, functions and math functions.
## Setup/Installation Requirements
* Visual Studio Code
* Browser

## Known Bugs

## Technologies Used
HTML, CSS and JAVASCRIPT
## Support and contact details
<EMAIL_ADDRESS>
##My gh-pages link
[https://github.com/Robert-Moringa/Dairy_Business]
### License
*Licensed under the [MIT LICENSE](LICENSE.txt)*
Copyright (c) 2021 **Robert Maina*


text:
# Rover Search and Return - Udacity

Simulator Settings:
	- Screen Resolution: 640 X 480
    - Graphics Quality: Good

[//]: # (References)

[image1]: ./calibration_images/example_grid1.jpg
[image2]: ./calibration_images/angle_example.jpg
[image3]: ./calibration_images/transform_ex.png
[image4]: ./calibration_images/thresholding.png
[image5]: ./calibration_images/coordinate.png
[gif1]: ./output/giphy.gif

---

## Notebook Analysis

Within this [Jupyter Notebook](./code/Rover_Project_Test_Notebook.ipynb) are all the functions providing the necessary data that will allow the rover to autonomously navigate its environment.

#### Sample Data

In the simulator, you can toggle a grid onto the the ground for calibration. The image below is an example. We will use this as a reference for the perspective transform function, allowing us to choose source points, as well as adjust the offset value from the bottom, to account for image data directly in front of the rover.

![Grid Image][image1]

#### Perspective Transform

This function allows us to tranform the image from front point-of-view to a top-down point-of-view, allowing us to calculate the average angle based on available path pixels, once color thresholding is applied, which is the next step.

![Perspect Transform][image3]

#### Color Thresholding

We will apply three seperate color thresholding functions to account for the navigable terrain, obstacles, and the goals. You could condense this into one function, and pass in the rgb threshold, I just prefer this method as it's cleaner and one can know exactly which threshold you're applying via the naming conventions. Although I only use the goal and navigable terrain thresholding for the rover, I plan on coming back and using obstacle thresholding to closely follow the wall, as it is apparently the most efficient navigation method.

Using the RGB image splitting function, I looked at the intensity values and approximated the values that would be needed in order for the robot to "see" its goal points and its obstacles.

The resultant image is an image that only displays the information we want from that particular function. In the case of the goal_thresholding function, it shows a pixel intesity of 1 at every threshold point.

![Threshold][image4]

#### Coordinate Transformation - Rover

In order for the environment to be correctly observed, we "flipped the pixels" to rover-centric coordinates. It first grabs all non-zero pixels from the resultant images of the color thresholding functions, and flipped to seperate axis, while also applying some filters (subtractng to flip rover x-axis, dividing x axis for steering, etc.)

![Coordinate Transform - Rover][image5]

#### Coordinate Transformation - World

We then transform the pixels to world map coordinates via the rotation function, and then a transform, allowing us to update the map real time while we traverse the environment. The obstacles, navigable terrain, and goal points are colored in respectively. Below is an example of the update.

![World Transform][gif1]

---

## Autonomous Navigation and Mapping

Using the functions defined above as tools, we then define two functions that will allow the Rover to percieve and act upon its environment.

#### Perception

In the perception step, we use the prevoiously defined functions to convert the pixels to the rover coordinate frame, the world coordinate frame, and then convert pixels from the respective rover coordinate frame to a polar coordinate frame, allowing use to determine distance of each pixel from the origin, along with the angle from the x-axis. We calculate the average angle and distance for the navigable terrain parameter, along with the goal point parameter. We also add the floored current pixel positions to a discovered-map parameter, which will allow us to create boundaries (which I'll get back to sometime in the future). The last step was to increase the fidelity of the system by limiting the rover to only map pixel coordinates if its pitch and roll angles are within a predefined limit.

#### Decision

In the decision step, we distinguish between navigable terrain angles and goal point angles. If a goal point is located, the systems primary focus will be to navigate toward the goal point, otherwise its business as usual.

##### Parameter Tracking

Within the navigable terrain block, we keep track of several parameters of the rover. Below each script is a description.

___

1. Stuck

```python
if (Rover.throttle > 0) and (Rover.vel < 0.3) and (Rover.forward_time > 3) and not(Rover.picking_up):
            Rover.throttle = 0
            Rover.mode = 'get_unstuck'
```

Forward_time is a parameter that will allow us to determine the amount of time the rover has been trying to move forward. This in conjunction with a velocity smaller than 0.3 should help us to determine if the rover is stuck. The forward_time parameter is incremented within the forward function. Once all conditions are met, it sets the rover's mode to 'get_unstuck'

___

2. Circle

```python
if (Rover.steer == 15) or (Rover.steer == -15):
            if(Rover.steer == Rover.past_steer):
                Rover.steer_time = Rover.steer_time + 0.03
            else:
                Rover.steer_time = 0
            if(Rover.steer_time > Rover.max_steer_time):
                Rover.mode = 'steer_anew'
                Rover.to_steer = Rover.steer
```

Past_steer is a parameter that sets itself to the prior steering angle. If the steering angle is equal to either of the extemes, and this steering angle is equal to the prior, increment steering time. Once the steering time is greater than 10 seconds, it sets the rover's mode to 'steer_anew'

___

3. Sample Collected

```python
if Rover.samples_collected == 6:
            if(np.abs(Rover.pos[0] - Rover.start_pos[0]) < 6 and np.abs(Rover.pos[1] - Rover.start_pos[1]) < 6):
                Rover.throttle = 0
                Rover.brake = Rover.brake_set
                Rover.steer = 0
                Rover.finished = True

```

Start_pos is determined in the supplemental_functions.py file, where at the beginning, when total_time equals 0, we set it equal to rovers starting pos. We then track the number of samples the rover has collected, and navigate until the (x,y) position of the rover is within six digits.

##### Modes

When the conditions are met above, the following modes are called. Below each script is a description.

1. Unstuck

```python
elif Rover.mode == 'get_unstuck':
            if (Rover.stuck_time < Rover.max_stuck_time):
                Rover.throttle = -0.2
                Rover.steer = 15
                Rover.stuck_time  = Rover.stuck_time + 0.03
                Rover.mode = 'get_unstuck'
            else:
                #In case rover is stuck in different situation
                if(np.abs(Rover.pos[0] - Rover.last_pos[0]) < 0.3 and np.abs(Rover.pos[1] - Rover.last_pos[1]) < 0.3):
                    Rover.mode = 'maneuver'
                    Rover.forward_time = 0
                    Rover.stuck_time = 0
                #else rover was freed
                else:
                    Rover.brake = Rover.brake_set
                    Rover.throttle = Rover.throttle_set
                    Rover.forward_time = 0
                    Rover.mode = 'forward'
                    Rover.stuck_time = 0

```

We'll track the amount of time maneuvering out of the stuck position with stuck_time. We set the throttle to a negative value to encourage the rover to move backward at a steering degree of 15. These are arbitrary values I picked, and could obviously be changed to increase the fidelity of the system. Once the max time has passed, we check if the rover is still stuck by checking if the last position and the current position are within a set tolerance. If so, it goes onto a different maneuvering mode. If not, we continue forward.

___

2. Maneuver

```python
elif Rover.mode == 'maneuver':
            if(Rover.maneuver_time < 2):
                Rover.throttle = 0
                Rover.steer = 15
                Rover.maneuver_time = Rover.maneuver_time + 0.03
            else:
                Rover.mode = 'forward'
                Rover.maneuver_time = 0

```

Maneuver is called if the rover is unable to become unstuck after "get_unstuck" is called. This just turns the rover without a throttle being applied.

___

3. Steer Anew

```python
elif Rover.mode == 'steer_anew':
            Rover.throttle = 0
            Rover.brake = Rover.brake_set
            if(Rover.duration_steer < 2):
                if(Rover.to_steer == 15):
                    Rover.steer = -15
                else:
                    Rover.steer = 15
                Rover.duration_steer = Rover.duration_steer +0.03
            else:
                Rover.mode = 'forward'
                Rover.throttle = Rover.throttle_set
                Rover.duration_steer = 0
                Rover.steer_time = 0
```

Steer_anew is called once the robot has been determined to be steering in a circle for an x amount of time. It changes the steering angle and continues forward.

---

## Conclusions

On average, the rover maps around 94% of its environment at approximately 80% fidelity. Time taken is a metric I could improve upon, and hope to in the future using boundaries based on the discovere_map parameters I have added. I also wish to increase the fidelity of the system.

##### Future Plans

1. Increase fidelity of the system.
2. Use map boundaries.

repository: twbot/Brodeur-RoboND-Rover

repo_name: twbot/Brodeur-RoboND-Rover


text:
Genealogy vendors and their GEDCOM support
==========================================

There are multiple vendors supporting different flavours of GEDCOM

FamilySearch.org
----------------

It has the largest database, since it scans documents from the public archives all over the world.

* Provides an ability to import GEDCOM 5.5.1 file.
* Only deceased relatives are added. This deceased vs living handling differences causes issues for users.
* No built-in GEDCOM export support. It is suggested to use its API or thirdparty software that supports it.

FamilySpace.ru
--------------

Popular russian vendor.

* Both export and import of GEDCOM 5.5 is supported.
* Uses non-standard maiden/marriage name format.
* Death fields are not exported.

repository: ktp-forked-repos/gedcom-tree

repo_name: ktp-forked-repos/gedcom-tree


text:
---
name: Bug report
about: Report a problem with pheweb
title: ''
labels: ''
assignees: ''

---

Please include:

- the version of pheweb you're using, gotten from `pheweb -h`.  If you're not on the latest version, consider upgrading with `pip3 install --upgrade` and trying again.

- the command you were running and its output/error.

- snippets of relevant files, especially files mentioned in the error.

- your `config.py`.

repository: statgen/pheweb

repo_name: statgen/pheweb


text:
---
title: listServerRefs
sidebar_label: listServerRefs
id: version-1.x-listServerRefs
original_id: listServerRefs
---

Fetch a list of refs (branches, tags, etc) from a server.

| param                            | type [= default]              | description                                                                                |
| -------------------------------- | ----------------------------- | ----------------------------------------------------------------------------------------------------------- |
| [**http**](./http)               | HttpClient                    | an HTTP client                                                                                |
| [onAuth](./onAuth)               | AuthCallback                  | optional auth fill callback                                                                                |
| [onAuthFailure](./onAuthFailure) | AuthFailureCallback           | optional auth rejected callback                                                                             |
| [onAuthSuccess](./onAuthSuccess) | AuthSuccessCallback           | optional auth approved callback                                                                             |
| **url**                          | string                        | The URL of the remote repository. Will be gotten from gitconfig if absent.                                  |
| corsProxy                        | string                        | Optional [CORS proxy](https://www.npmjs.com/%40isomorphic-git/cors-proxy). Overrides value in repo config.  |
| forPush                          | boolean = false               | By default, the command queries the 'fetch' capabilities. If true, it will ask for the 'push' capabilities. |
| [headers](./headers)             | Object\<string, string\>      | Additional headers to include in HTTP requests, similar to git's `extraHeader` config                       |
| protocolVersion                  | 1  |  2 = 2              | Which version of the Git Protocol to use.                                                                   |
| prefix                           | string                        | Only list refs that start with this prefix                                                                  |
| symrefs                          | boolean = false               | Include symbolic ref targets                                                                                |
| peelTags                         | boolean = false               | Include annotated tag peeled targets                                                                        |
| return                           | Promise\<Array\<ServerRef\>\> | Resolves successfully with an array of ServerRef objects                                                    |

This object has the following schema:

```ts
type ServerRef = {
  ref: string; // The name of the ref
  oid: string; // The SHA-1 object id the ref points to
  target?: string; // The target ref pointed to by a symbolic ref
  peeled?: string; // If the oid is the SHA-1 object id of an annotated tag, this is the SHA-1 object id that the annotated tag points to
}
```

This is a rare command that doesn't require an `fs`, `dir`, or even `gitdir` argument.
It just requires an `http` argument.

### About `protocolVersion`

There's a rather fun trade-off between Git Protocol Version 1 and Git Protocol Version 2.
Version 2 actually requires 2 HTTP requests instead of 1, making it similar to fetch or push in that regard.
However, version 2 supports server-side filtering by prefix, whereas that filtering is done client-side in version 1.
Which protocol is most efficient therefore depends on the number of refs on the remote, the latency of the server, and speed of the network connection.
For an small repos (or fast Internet connections), the requirement to make two trips to the server makes protocol 2 slower.
But for large repos (or slow Internet connections), the decreased payload size of the second request makes up for the additional request.

Hard numbers vary by situation, but here's some numbers from my machine:

Using isomorphic-git in a browser, with a CORS proxy, listing only the branches (refs/heads) of https://github.com/isomorphic-git/isomorphic-git
- Protocol Version 1 took ~300ms and transfered 84 KB.
- Protocol Version 2 took ~500ms and transfered 4.1 KB.

Using isomorphic-git in a browser, with a CORS proxy, listing only the branches (refs/heads) of https://gitlab.com/gitlab-org/gitlab
- Protocol Version 1 took ~4900ms and transfered 9.41 MB.
- Protocol Version 2 took ~1280ms and transfered 433 KB.

Finally, there is a fun quirk regarding the `symrefs` parameter.
Protocol Version 1 will generally only return the `HEAD` symref and not others.
Historically, this meant that servers don't use symbolic refs except for `HEAD`, which is used to point at the "default branch".
However Protocol Version 2 can return *all* the symbolic refs on the server.
So if you are running your own git server, you could take advantage of that I guess.

#### TL;DR
If you are _not_ taking advantage of `prefix` I would recommend `protocolVersion: 1`.
Otherwise, I recommend to use the default which is `protocolVersion: 2`.

Example Code:

```js live
// List all the branches on a repo
let refs = await git.listServerRefs({
  http,
  corsProxy: "https://cors.isomorphic-git.org",
  url: "https://github.com/isomorphic-git/isomorphic-git.git",
  prefix: "refs/heads/",
});
console.log(refs);
```

```js live
// Get the default branch on a repo
let refs = await git.listServerRefs({
  http,
  corsProxy: "https://cors.isomorphic-git.org",
  url: "https://github.com/isomorphic-git/isomorphic-git.git",
  prefix: "HEAD",
  symrefs: true,
});
console.log(refs);
```

```js live
// List all the tags on a repo
let refs = await git.listServerRefs({
  http,
  corsProxy: "https://cors.isomorphic-git.org",
  url: "https://github.com/isomorphic-git/isomorphic-git.git",
  prefix: "refs/tags/",
  peelTags: true,
});
console.log(refs);
```

```js live
// List all the pull requests on a repo
let refs = await git.listServerRefs({
  http,
  corsProxy: "https://cors.isomorphic-git.org",
  url: "https://github.com/isomorphic-git/isomorphic-git.git",
  prefix: "refs/pull/",
});
console.log(refs);
```

---

Tip: If you need a clean slate, expand and run this snippet to clean up the file system.

```js live
window.fs = new LightningFS('fs', { wipe: true })
window.pfs = window.fs.promises
console.log('done')
```

repository: isomorphic-git/isomorphic-git

repo_name: isomorphic-git/isomorphic-git


text:
---
title: "Scalars"
date: 2018-09-09T12:52:46+10:00
description: How scalar types work in graphql and how to write your own scalars
---
# Scalars in GraphQL

## Scalars

The leaf nodes of the GraphQL type system are called scalars. Once you reach a scalar type, you
cannot descend any further into the type hierarchy. A scalar type is meant to represent
an indivisible value.

The [GraphQL specification](https://spec.graphql.org/draft/#sec-Scalars) states that all implementations must have the following scalar types:

* String aka ``GraphQLString`` - A UTF‐8 character sequence.
* Boolean aka ``GraphQLBoolean`` - true or false.
* Int aka ``GraphQLInt`` - A signed 32‐bit integer.
* Float aka ``GraphQLFloat`` - A signed double-precision floating-point value.
* ID aka ``GraphQLID`` - A unique identifier which is serialized in the same way as a String. However, defining it as an ID signifies that it is not intended to be human‐readable.

The class ``graphql.Scalars`` contains singleton instances of the provided scalar types.

[graphql-java-extended-scalars](https://github.com/graphql-java/graphql-java-extended-scalars) adds the following scalar types which are useful in Java based systems:

* Long aka ``GraphQLLong`` - a java.lang.Long based scalar
* Short aka ``GraphQLShort`` - a java.lang.Short based scalar
* Byte aka ``GraphQLByte``  - a java.lang.Byte based scalar
* BigDecimal aka ``GraphQLBigDecimal`` - a java.math.BigDecimal based scalar
* BigInteger aka ``GraphQLBigInteger`` - a java.math.BigInteger based scalar

## Writing your own Custom Scalars

You can write your own custom scalar implementations. In doing so you take on the responsibility for coercing values
at runtime, which we will explain in a moment.

Imagine we decide we need to have an email scalar type.  It will take email addresses as input and output.

We would create a singleton ``graphql.schema.GraphQLScalarType`` instance for this.

```java
public static final GraphQLScalarType EMAIL = GraphQLScalarType.newScalar()
        .name("email")
        .description("A custom scalar that handles emails")
        .coercing(new Coercing() {
            @Override
            public Object serialize(Object dataFetcherResult) {
                return serializeEmail(dataFetcherResult);
            }

            @Override
            public Object parseValue(Object input) {
                return parseEmailFromVariable(input);
            }

            @Override
            public Object parseLiteral(Object input) {
                return parseEmailFromAstLiteral(input);
            }
        })
        .build();
```

## Coercing values

The real work in any custom scalar implementation is the ``graphql.schema.Coercing`` implementation. This is responsible for 3 functions:

* ``parseValue`` - takes a variable input object and converts into the Java runtime representation
* ``parseLiteral`` - takes an AST literal ``graphql.language.Value`` as input and converts into the Java runtime representation
* ``serialize`` - takes a Java object and converts it into the output shape for that scalar

So your custom scalar code has to handle 2 forms of input (`parseValue` / `parseLiteral`) and 1 form of output (`serialize`).

Imagine this query, which uses variables, AST literals and outputs our scalar type ``email``.

```graphql
mutation Contact($mainContact: Email!) {
  makeContact(mainContactEmail: $mainContact, backupContactEmail<EMAIL_ADDRESS>{
    id
    mainContactEmail
  }
}
```

Our custom Email scalar will:

* be called via ``parseValue`` to convert the ``$mainContact`` variable value into a runtime object
* be called via ``parseLiteral`` to convert the AST ``graphql.language.StringValue``<EMAIL_ADDRESS>into a runtime object
* be called via ``serialize`` to turn the runtime representation of mainContactEmail into a form ready for output

## Validation of input and output

The methods can validate that the received input makes sense. For example our email scalar will try to validate that the input
and output are indeed email addresses.

The JavaDoc method contract of ``graphql.schema.Coercing`` says the following:

* The ``serialize`` MUST ONLY allow ``graphql.schema.CoercingSerializeException`` to be thrown from it. This indicates that the
value cannot be serialized into an appropriate form.  You must not allow other runtime exceptions to escape this method to get
the normal graphql behaviour for validation.

* The ``parseValue`` MUST ONLY allow ``graphql.schema.CoercingParseValueException`` to be thrown from it. This indicates that the
value cannot be parsed as input into an appropriate form. You must not allow other runtime exceptions to escape this method to get
the normal graphql behaviour for validation.

* The ``parseLiteral`` MUST ONLY allow ``graphql.schema.CoercingParseLiteralException`` to be thrown from it. This indicates that the
AST value cannot be parsed as input into an appropriate form. You must not allow any runtime exceptions to escape this method to get
the normal graphql behaviour for validation.

Some people try to rely on runtime exceptions for validation and hope that they come out as graphql errors. This is not the case. You
MUST follow the ``Coercing`` method contracts to allow the graphql-java engine to work according to the graphql specification on scalar types.

## Example implementation

The following is a really rough implementation of our imagined ``email`` scalar type to show you how one might implement the ``Coercing`` methods.

```java
public static class EmailScalar {

    public static final GraphQLScalarType EMAIL = GraphQLScalarType.newScalar()
            .name("email")
            .description("A custom scalar that handles emails")
            .coercing(new Coercing() {
                @Override
                public Object serialize(Object dataFetcherResult) {
                    return serializeEmail(dataFetcherResult);
                }

                @Override
                public Object parseValue(Object input) {
                    return parseEmailFromVariable(input);
                }

                @Override
                public Object parseLiteral(Object input) {
                    return parseEmailFromAstLiteral(input);
                }
            })
            .build();

    private static boolean looksLikeAnEmailAddress(String possibleEmailValue) {
        // ps.  I am not trying to replicate RFC-3696 clearly
        return<EMAIL_ADDRESS>possibleEmailValue);
    }

    private static Object serializeEmail(Object dataFetcherResult) {
        String possibleEmailValue = String.valueOf(dataFetcherResult);
        if (looksLikeAnEmailAddress(possibleEmailValue)) {
            return possibleEmailValue;
        } else {
            throw new CoercingSerializeException("Unable to serialize " + possibleEmailValue + " as an email address");
        }
    }

    private static Object parseEmailFromVariable(Object input) {
        if (input instanceof String) {
            String possibleEmailValue = input.toString();
            if (looksLikeAnEmailAddress(possibleEmailValue)) {
                return possibleEmailValue;
            }
        }
        throw new CoercingParseValueException("Unable to parse variable value " + input + " as an email address");
    }

    private static Object parseEmailFromAstLiteral(Object input) {
        if (input instanceof StringValue) {
            String possibleEmailValue = ((StringValue) input).getValue();
            if (looksLikeAnEmailAddress(possibleEmailValue)) {
                return possibleEmailValue;
            }
        }
        throw new CoercingParseLiteralException(
                "Value is not any email address : '" + String.valueOf(input) + "'"
        );
    }
}
```

repository: graphql-java/graphql-java-page

repo_name: graphql-java/graphql-java-page