text:
[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0) [![Maven Central](https://img.shields.io/maven-central/v/com.github.abagabagon/verifico.svg?label=Maven%20Central)](https://search.maven.org/search?q=g:%22com.github.abagabagon%22%20AND%20a:%22verifico%22)

### **Background**
One of the disadvantages of Selenium and Appium is the steep learning curve required for users to be able to implement it. One also have to go over issues such as automation test flakiness, unhandled exceptions, etc. so they could learn how to properly implement commands of Selenium and Appium. The project is built in order to eliminate this issue.

### **Components**

| Component         | Java API                                                                                | Version     |
| ----------------- | ------------------------------------------------------------------------------------------------------------- | ----------- |
| Web Automation    | [Selenium](https://www.seleniumhq.org/download/)                                                              | 3.141.59    |
| Mobile Automation | [Appium](http://appium.io/)                                                                                | 7.3.0       |
| Logging Tool      | [Log4J2](https://logging.apache.org/log4j/2.0/download.html)                                                  | 2.13.3      |
| Reporting Tool    | [ExtentReports](http://relevantcodes.com/extentreports-for-selenium/)                                         | 5.0.1       |
| Excel             | [Apache POI](https://poi.apache.org/download.html)                                                            | 4.1.2       |
| MySQL             | [MySQL Connector](https://dev.mysql.com/doc/connectors/en/)                                                   | 8.0.21      |
| MSSQL             | [MSSQL Connector](https://docs.microsoft.com/en-us/sql/connect/sql-connection-libraries?view=sql-server-ver15)| 8.2.2.jre8  |

### **Java Dependency**

#### **Maven**

```xml
<!-- https://mvnrepository.com/artifact/com.github.abagabagon/verifico -->
<dependency>
    <groupId>com.github.abagabagon</groupId>
    <artifactId>verifico</artifactId>
    <version>1.1.1</version>
</dependency>
```

### **Usage**

#### **Web Automation**

For Web Application Automation, create an instance of the `WebAutomation` Object which is shown below:

```java
Browser browser = Browser.CHROME;
boolean isHeadless = false;

Verifico verifico = new Verifico();
WebAutomation I = verifico.getWebAutomation(browser, isHeadless);
```

Web Application Automation on Mobile Devices is also supported. Same as above, an instance of the `WebAutomation` Object will need to be created but with different parameters:

```java
String deviceName = "YT9117XT7C";
Mobile mobile = Mobile.Android
String platformVersion = "6.0.1";
Browser browser = Browser.CHROME;
URL appiumServerUrl = new URL("http://<IP_ADDRESS>:4723/wd/hub");

Verifico verifico = new Verifico();
WebAutomation I = verifico.getWebAutomation(deviceName, mobile, platformVersion, browser, appiumServerUrl);
```

The created `WebAutomation` instance would be able to access Browser and User Action Commands.

```java
I.openBrowser();
I.goTo("http://www.somewebsite.com/");
I.type(PageLogin.EMAIL_ADDRESS_TEXTBOX, "abagabagon@yopmail.com");
I.type(PageLogin.PASSWORD_TEXTBOX, "ABCabc123");
I.click(PageLogin.LOGIN_BUTTON);
```

##### **Web Automation Commands**

###### **Browser Actions**

| Command               | Description                                          |
| --------------------- | ---------------------------------------------------- |
| openBrowser           | Opens Web Browser                                    |
| openTab               | Opens Tab                                            |
| goTo                  | Navigate to the Url specified                        |
| switchTabByTitle      | Switch to a Tab based on Page Title                  |
| switchTabByURL        | Switch to a Tab based on Page URL                    |
| switchTabToOriginal   | Switch back to Original Tab                          |
| back                  | Navigate one item back from the browser's history    |
| forward               | Navigate one item forward from the browser's history |
| refresh               | Refresh current page                                 |
| maximizeBrowserWindow | Maximizes Browser Window                             |
| deleteAllCookies      | Deletes all cookies                                  |
| scroll                | Scrolls Page                                         |
| closeTab              | Closes Tab of a Web Browser                          |
| closeBrowser          | Closes Web Browser                                   |

###### **User Actions**

| Command                               | Description                                                                                |
| ------------------------------------- | ----------------------------------------------------------------------------------------------------------------- |
| point                                 | Point mouse to the specified Web Element                                                                          |
| pointJS                               | Point mouse to the specified Web Element (utilizing Javascript)                                                   |
| click                                 | Clicks the specified Web Element. Used for Elements that are clickable                                            |
| clickJS                               | Clicks the specified Web Element (utilizing Javascript). Used for Elements that are clickable                     |
| clickAndHold                          | Clicks and holds the specified Web Element. Used for Elements that are clickable                                  |
| clickFromListBasedOnText              | Clicks the specified Web Element from an Object List based on text value                                          |
| clickFromTableBasedOnText             | Clicks the specified Web Element from a row in a table based on text value from the same row                      |
| doubleClick                           | Double clicks the specified Web Element. Used for Elements that are clickable                                     |
| doubleClickFromListBasedOnText        | Double clicks the specified Web Element from an Object List based on text value                                   |
| doubleClickFromTableBasedOnText       | Clicks the specified Web Element from a row in a table based on text value from the same row                      |
| dragAndDrop                           | Drags a specified Web Element and drops it at target element. Used for Elements that can be dragged               |
| type                                  | Simulates typing into a text box/area Web Element                                                                 |
| typeJS                                | Simulates typing into a text box/area Web Element (utilizing Javascript)                                          |
| typeFromTableBasedOnText              | Type input text at the specified Web Element from a row in a table based on text value from the same row          |
| press                                 | Simulates pressing of characters into a text box/area Web Element                                                 |
| pressFromTableBasedOnText             | Press specified keys at the specified Web Element from a row in a table based on text value from the same row     |
| clear                                 | Clears value of a text box/area Web Element                                                                       |
| clearFromTableBasedOnText             | Clears value of the specified Web Element from a row in a table based on text value from the same row             |
| select                                | Selects a Drop-down/Multi-select List Web Element Option                                                          |
| deselect                              | Deselects a Multi-select Web Element Option                                                                       |
| getText                               | Get the visible innerText of this Web Element, including sub-elements, without any leading or trailing whitespace |
| getTextFromTableBasedOnText           | Get text of the specified Web Element from a row in a table based on text value from the same row                 |
| getValue                              | Gets the value of the INPUT and TEXTAREA Web Element                                                              |
| getValueFromTableBasedOnText          | Get value of the specified Web Element from a row in a table based on text value from the same row                |
| getAttributeValue                     | Get the value of the specified attribute of the Web Element                                                       |
| getAttributeValueFromTableBasedOnText | Get value of the specified Web Element from a row in a table based on text value from the same row                |
| getDropDownListValue                  | Gets the selected option of the Drop-down List Web Element                                                        |
| wait                                  | Waits for a specific time (Seconds)                                                                               |

###### **Verifications**

| Command                 | Description                                                                                |
| ----------------------- | -------------------------------------------------------------------------------------------- |
| verifyUrl               | Verifies Page URL of Web Page if equal to the expected URL                                   |
| verifyTitle             | Verifies Page Title of Web Page if equal to the expected Title                               |
| verifyPartialUrl        | Verifies Page URL of Web Page if partially equal to the expected URL                         |
| verifyClickable         | Verifies if the Web Element is clickable or not                                              |
| verifyValue             | Verifies the value of INPUT or TEXTAREA Web Elements if equal to the expected value          |
| verifyAttributeValue    | Verifies the value of the specified attribute if equal to the expected value                 |
| verifyDropDownListValue | Verifies Drop-down List Web Element Value if equal to expected text value                    |
| verifyText              | Verifies Web Element with text if equal to expected text value                               |
| verifyDisplayed         | Verifies if Web Element is displayed on Web Page                                             |
| verifyNotDisplayed      | Verifies Web Element is not displayed on the Web Page                                        |
| verifyEnabled           | Verifies Web Element is enabled on the Web Page                                              |
| verifyDisabled          | Verifies Web Element is disabled on the Web Page                                             |
| verifySelected          | Verifies Web Element is selected on the Web Page. Used for Check Boxes and Radio Buttons     |
| verifyNotSelected       | Verifies Web Element is not selected on the Web Page. Used for Check Boxes and Radio Buttons |
| verifyAlertMessage      | Verifies Javascript Alert Message displayed if equal to expected message                     |

#### **Excel Data**

```java
Excel excelType = Excel.XLS;
String filePath = "./src/resources/data/excel/staff-accounts.XLS";

Verifico verifico = new Verifico();
ExcelData excelData = verifico.getExcelData(excelType, filePath);
```

#### **SQL Data**

```java
SQL sqlType = "MySQL";
String dbServer = "<IP_ADDRESS>";
String dbName = "northwind";
String user = "abagabagon";
String password = "ABCabc123";

Verifico verifico = new Verifico();
SQLData sqlData = verifico.getSQLData(sqlType, dbServer, dbName, user, password);
```

repository: qakiran/verifico

repo_name: qakiran/verifico


text:
Firefox OS HTML5 Presentation Slides

This is the repository with Mozilla styled presentation templates in HTML5 Presentation Slides for Malaysia Open Source Conference 2013.

Prepared by Muhammad Syafiq Mazli, Mozilla Malaysia Community.

license: MIT

repository: syafiqmazli/FirefoxOS

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: syafiqmazli/FirefoxOS


text:
Title: Inselect v0.1.23 released

You can [download v0.1.23](https://github.com/NaturalHistoryMuseum/inselect/releases/tag/v0.1.23).

- Added [234](https://github.com/NaturalHistoryMuseum/inselect/issues/234) - Metadata template popup (@quicklizard99)
- Added [233](https://github.com/NaturalHistoryMuseum/inselect/issues/233) - Error box should contain traceback (@quicklizard99)
- Fixed [230](https://github.com/NaturalHistoryMuseum/inselect/issues/230) - No way to for the user to specify thumbnail size to the ingest command-line tool (@quicklizard99)
- Fixed [228](https://github.com/NaturalHistoryMuseum/inselect/issues/228) - Closing document can be slow (@quicklizard99)
- Fixed [217](https://github.com/NaturalHistoryMuseum/inselect/issues/217) - Error box appears twice (@quicklizard99)

repository: zyken/BachelorProject

repo_name: zyken/BachelorProject


text:
# matcaffe2caffe
Convert a matcaffe model (column major) to a pycaffe or c++ caffe (row major) model.

In most cases you do not need to do this as you can just transpose the input image to get the same result.
However, in some cases, for example when you need to use [ncnn](https://github.com/Tencent/ncnn), the offical
script to convert a caffe model to ncnn model can only apply on a row major model, so you may need this tool
to convert the matcaffe model first. I write this tool when I need to convert the [MTCNN](https://github.com/kpzhang93/MTCNN_face_detection_alignment) model to a ncnn model. I do not do many tests so
if you meet any problem please open an issue.

# HowTo
```
$ python matcaffe2caffe.py --help
usage: matcaffe2caffe.py [-h] [--proto PROTO] [--model MODEL]
                           [--output OUTPUT]

convert a matcaffe model(column major) to a normal caffe model(row major)

optional arguments:
  -h, --help       show this help message and exit
  --proto PROTO    path to deploy prototxt.
  --model MODEL    path to pretrained weights
  --output OUTPUT  path to output model

$ python matcaffe2caffe.py --proto det1.prototxt --model det1.caffemodel --output det1_py.caffemodel
```

# Dependencies
pycaffe, numpy.


text:
zabbix-mongodb
=========

Ansible role to install scripts for mongodb monitoring in zabbix. Original project: https://github.com/nightw/mikoomi-zabbix-mongodb-monitoring

Requirements
------------

This role requires php, mongo driver for php and git.

Role Variables
--------------

You can see full list of default variables in defaults/main.yml

zabbix_mongodb_centos_packages - additional packages to install. Default: php-devel, php-pecl-mongo

zabbix_mongodb_git_repo - url to git project. Default: https://github.com/nightw/mikoomi-zabbix-mongodb-monitoring.git

zabbix_mongodb_path - path for git clone. Default: /opt/zabbix-mongodb

zabbix_mongodb_git_ref - commit to clone. Default: HEAD

zabbix_mongodb_databases - list of zabbix server. It's an array, every element there is a dictionary. Element variables:

  title - comment in crontab. Default value is based on hostname

  state - state of cron task. Default: present

  user - user to run cron job. Default: root

  interval - interval to check mongodb in minutes. Has cron-like syntax. Default: *

  mongodb_version - version of mongodb server. Available values: 2.2, 2.4, 3.2 . Default : 3.2

  zabbix_server - address of zabbix server. Default: localhost

  zabbix_port - port of zabbix server. Default: 10051

  hostname - name of host. Should be the same as agent name in zabbix server. Default value is based on nodename.

  mongodb_address - address of mongodb server

  mongodb_port - port of mongodb server. Default: 27017

  mongodb_user - mongodb server user.

  mongodb_password - password of mongodb user.

Dependencies
------------

You can use geerlingguy.git ansible role for git installation.

Example Playbook
----------------

An example of playbook with 1 mongodb server.

    - hosts: servers
      roles:
      - role: vladislavtomenko.zabbix-mongodb
        zabbix_mongodb_databases:
        -
          zabbix_server: localhost
          hostname: mongodb.local
          mongodb_address: <IP_ADDRESS>
          mongodb_user: zabbix
          mongodb_password: zabbix

License
-------

BSD

repository: Amixp/ansible-zabbix-mongodb

repo_name: Amixp/ansible-zabbix-mongodb


text:
# Brief
You can find here code I use for my regularization experiments. All described on my blog: www.ai-experiments.com

1. r-dropout.py is dealing with dropout and spatial dropout layers. For experiments results please visit:

https://ai-experiments.com/use-your-spatial-dropout-layers-wisely/

2. r-l2.py - it a simple experiment with l2 regularization value on a very small model. Post is in progress.

https://ai-experiments.com/keras-l2-regularization-machine-learning/


text:
- A CLI for reading [Linda Ikeji's Blog](http://www.lindaikejisblog.com) Stories.

It helps you read awesome Linda Ikeji articles right in your terminal.

![](https://cloud.githubusercontent.com/assets/2946769/15586607/3dc86296-237d-11e6-8875-f859b37ee1a9.png)

## Installation
------------

`$ npm install -g lindaikeji`

## Docs
----
    Usage: lindaikeji [options] [command]

    Commands:

    top [options]         List Linda Ikeji Top Stories
    read <url>            Read the story right in your terminal
    open [options] <url>  Opens it in your browser

    Options:

    -h, --help     output usage information
    -V, --version  output the version number

    top [options]
    n, --number <int>", "specify number of stories

    open [options] <url>
    -a, --app <application>  specify app to open the url. Eg: firefox

## Usage
-----
There are three commands available: `lindaikeji top`, `lindaikeji read`, `lindaikeji open`.

#### top command
`$ lindaikeji top`

List Linda Ikeji Top Stories

`$ lindaikeji top 5`

List only top 5 Linda Ikeji Stories

#### read command
`$ lindaikeji read <url>`

Read the story right in your terminal

#### open command
`$ lindaikeji open <url>`

Opens it in your browser

`$ lindaikeji open -a firefox <url>`

Opens it in the given application, like it opens the url using firefox in above example.

## Contributing
------------

Please feel free to fork this package and contribute by submitting a pull request to add more features or fix bugs.
[Read more on contributing](./CONTRIBUTING.md).

## How can I thank you?

Why not star the github repo? I'd love the attention! Why not share the link for this repository on Twitter or HackerNews? Spread the word!

Don't forget to [follow me on twitter](https://twitter.com/unicodeveloper)!

Thanks!
Prosper Otemuyiwa.

## License
-------

The source code is open-sourced software licensed under the [MIT License](http://opensource.org/licenses/MIT).

repository: unicodeveloper/lindaikeji-cli

gha_language: JavaScript

repo_name: unicodeveloper/lindaikeji-cli


text:
# `offline-plugin` for webpack

[![npm](https://img.shields.io/npm/v/offline-plugin.svg?maxAge=2592000&v4)](https://www.npmjs.com/package/offline-plugin)
[![npm](https://img.shields.io/npm/dm/offline-plugin.svg?maxAge=3600)](https://www.npmjs.com/package/offline-plugin)
[![Join the chat at https://gitter.im/NekR/offline-plugin](https://badges.gitter.im/NekR/offline-plugin.svg)](https://gitter.im/NekR/offline-plugin?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)

This plugin is intended to provide offline experience for **webpack** projects. It uses **ServiceWorker** and **AppCache** as a fallback under the hood.

## Install

`npm install offline-plugin [--save-dev]`

## Setup

First, instantiate the plugin with [options](#options) in your `webpack.config`:

```js
// webpack.config.js example

var OfflinePlugin = require('offline-plugin');

module.exports = {
  // ...

  plugins: [
    // ... other plugins
    // it always better if OfflinePlugin is the last plugin added
    new OfflinePlugin()
  ]
  // ...
}

```

Then, add the [runtime](#runtime) into your entry file (typically main entry):

```js
require('offline-plugin/runtime').install();
```

## Docs

* [Caches](docs/caches.md)
* [Update process](docs/updates.md)

## Options

**All options are optional and `offline-plugin` could be used without specifying them.** Also see full list of default options [here](https://github.com/NekR/offline-plugin/blob/master/src/index.js#L9).

#### `caches: 'all' | Object`

Tells to the plugin what to cache and how.

* `'all'`: means that everything (all the webpack output assets) and URLs listed in `externals` option will be cached on install.
* `Object`: Object with 3 possible `Array<string>` sections (properties): `main`, `additional`, `optional`. All sections are optional and by default are empty (no assets added).

[More details about `caches`](docs/caches.md)

> Default: `'all'`.

#### `publicPath: string`

Same as `publicPath` for `webpack` options, only difference is that absolute paths are not allowed

> __Example:__
Correct value: `/project/`
Incorrect value: `https://example.com/project`

#### `responseStrategy: 'cache-first' | 'network-first'`
Response strategy. Whether to use a cache or network first for responses.
> Default: `'cache-first'`.

#### `updateStrategy: 'changed' | 'all'`
Cache update strategy. [More details about `updateStrategy`](docs/update-strategies.md)
> Default: `'changed'`.

#### `externals: Array<string>`.
Explicitly marks the assets as _external_ assets that you can cache. If cache asset is not one of _webpack's generated assets_ and is not marked explicitly as _external_, you will receive warning about it into console. To cache external assets, add them to the `caches` object, by default `caches: 'all'` doesn't cache `externals`.

> Default: `null`
> **Example value:** `['fonts/roboto.woff']`

#### `excludes: Array<string | globs_pattern>`
Excludes matches assets from being added to caches. Exclusion is performed before _rewrite_ happens.
[Learn more about assets _rewrite_](docs/rewrite.md)

> Default: `['**/.*', '**/*.map']`
> _Excludes all files which start with `.` or end with `.map`_

#### `relativePaths: boolean`
When set to `true`, all cache asset paths are generated relatively to `ServiceWorker` file or `AppCache` folder respectively.
`publicPath` option is ignored when this is set to `true`.
> **Default:** `true`

#### `version: string | (plugin: OfflinePlugin) => void`
Version of the cache. Might be a function, useful in _watch-mode_ when you need to apply dynamic value.

* `Function` is called with plugin instance as first argument
* `string` can be interpolated with `[hash]` token

> Default: _Current date_

#### `rewrites: Function | Object`

Rewrite function or rewrite map (`Object`). Useful when assets are served in a different way from the client perspective, e.g. usually `index.html` is served as `/`.

[See more about `rewrites` option and default function](docs/rewrite.md)

#### `cacheMaps: Array<Object>`

See [documentation of `cacheMaps`](docs/cache-maps.md) for syntax and usage examples

#### `ServiceWorker: Object | null | false`

Settings for the `ServiceWorker` cache. Use `null` or `false` to disable `ServiceWorker` generation.

* `output`: `string`. Relative (from the _webpack_'s config `output.path`) output path for emitted script.
_Default:_ `'sw.js'`

* `entry`: `string`. Relative or absolute path to file which will be used as `ServiceWorker` entry. Useful to implement additional function or handle other SW events.
_Default:_ _empty file_

* `scope`: `string`. Reflects [ServiceWorker.register](https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerContainer/register)'s `scope` option.
_Default:_ `null`

* `cacheName`: `string`. **This option is very dangerous.  Changing it may corrupt the cache and leave old caches on users' devices. This option is useful when you need to run more than one project on _the same domain_.
_Default:_ _`''`_ (empty string)
_Example:_ `'my-project'`

* `navigateFallbackURL`: `string`. The URL being returned from the caches when requested navigation URL isn't available. Similar to `AppCache.FALLBACK` option.
_Example:_ `navigateFallbackURL: '/'`

* `events`: `boolean`. Enables runtime events for ServiceWorker. For supported events see `Runtime`'s `install()` options.
_Default:_ `false`

* `publicPath`: `string`. Provides a way to override `ServiceWorker`'s script file location on the server. Should be exact path to the generated `ServiceWorker` file.
_Default:_ `null`
_Example:_ `'my/new/path/sw.js'`

* `prefetchRequest`: `Object`. Provides a way to specify [request init options](https://developer.mozilla.org/en-US/docs/Web/API/Request/Request) for pre-fetch requests (pre-cache requests on `install` event). Allowed options: `credentials`, `headers`, `mode`, `cache`.
_Default:_ `{ credentials: 'omit', mode: 'cors' }`
_Example:_ `{ credentials: 'same-origin' }`

#### `AppCache: Object | null | false`

Settings for the `AppCache` cache. Use `null` or `false` to disable `AppCache` generation.

* `directory`: `string`. Relative (from the _webpack_'s config `output.path`) output directly path for the `AppCache` emitted files.
_Default:_ `'appcache/'`

* `NETWORK`: `string`. Reflects `AppCache`'s `NETWORK` section.
_Default:_ `'*'`

* `FALLBACK`: `Object`. Reflects `AppCache`'s `FALLBACK` section. Useful for single page applications making use of HTML5 routing or for displaying custom _Offline page_.
_Example 1:_ `{ '/blog': '/' }` will map all requests starting with `/blog` to the domain roboto when request fails.
_Example 2:_ `{ '/': '/offline-page.html' }` will return contents of `/offline-page.html` for any failed request.
_Default:_ `null`

* `events`: `boolean`. Enables runtime events for AppCache. For supported events see `Runtime`'s `install()` options.
_Default:_ `false`

* `publicPath`: `string`. Provides a way to override `AppCache`'s folder location on the server. Should be exact path to the generated `AppCache` folder.
_Default:_ `null`
_Example:_ `'my/new/path/appcache'`

* `disableInstall` :`boolean`. Disable the automatic installation of the `AppCache` when calling to `runtime.install()`. Useful when you to specify `<html manifest="...">` attribute manually (to cache every page user visits).
_Default:_ `false`

* `includeCrossOrigin` :`boolean`. Outputs cross-origin URLs into `AppCache`'s manifest file. **Cross-origin URLs aren't supported in `AppCache` when used on HTTPS.**
_Default:_ `false`

## Runtime

Besides plugin configuration, you also need to initialize it at runtime phase. It's done this way:

```js
require('offline-plugin/runtime').install();
```

### Methods

Runtime has following methods:

#### `install(options: Object)`

Starts installation flow for `ServiceWorker`/`AppCache` it's safe and must be called each time your page loads (i.e. do not wrap it into any conditions).

#### `applyUpdate()`

Used to apply update for existing installation. See `install` options below.

### `install` Options

Runtime `install` accepts 1 optional argument, `options` object. Right now you can use following runtime options:

_**Note:** Events must be explicitly enabled for each tool (`ServiceWorker`/`AppCache`) in their options._

#### `onInstalled`

Event called exactly once when `ServiceWorker` or `AppCache` is installed. Can be useful to display `"App is ready for offline usage"` message.

#### `onUpdating`

_Not supported for `AppCache`_

Event called when update is found and browsers started updating process. At this moment, some assets are downloading.

#### `onUpdateReady`

Event called when `onUpdating` phase finished. All required assets are downloaded at this moment and are ready to be updated. Call `runtime.applyUpdate()` to apply update.

#### `onUpdateFailed`

Event called when `upUpdating` phase failed by some reason. Nothing is downloaded at this moment and current update process in your code should be canceled or ignored.

#### `onUpdated`

Event called when update is applied, either by calling `runtime.applyUpdate()` or some other way by a browser itself.

## Who is using `offline-plugin`

### Projects

* [React Boilerplate](https://github.com/mxstbr/react-boilerplate)
* [Phenomic](https://phenomic.io)
* [Gatsby](https://github.com/gatsbyjs/gatsby)
* [Angular CLI](https://github.com/angular/angular-cli)

### PWAs

* [Offline Kanban](https://offline-kanban.herokuapp.com) ([source](https://github.com/sarmadsangi/offline-kanban))
* [Preact](https://preactjs.com/) ([source](https://github.com/developit/preact-www))
* [Omroep West (_Proof of Concept_)](https://omroep-west.now.sh/)

_If you are using `offline-plugin`, feel free to submit a PR to add your project to this list._

## FAQ

[FAQ](FAQ.md)

## License

[MIT](LICENSE.md)

## CHANGELOG

[CHANGELOG](CHANGELOG.md)


text:
# Android Training App

This App was created to work as a Kotlin palyground with the advantage that it has a command that works like an input prompt. This command will pause the code until the user enter something.

The **main goal** is to **help** to teach **beginners developers** how to develop **simple codes** and at the same time get used to the **Android development environment**.

I created basic commands to **writing** and **reading** value. The commands have the same purpose of the well-known "print" and **"println"**, as well as the **"readLine"**. The names are purposely different to help students not to misplace them.

Use the Training class to create your own study code. The **main()** method will be the first method to run.

# Basic Commands

`write()` - Display on the **TextView** a text passed as parameter to this method in the form of a String.

`writeln()` - Display on the **TextView** a text passed as parameter to this method in the form of a String and break line at the end.

`read()` - Pause the code and wait the user enter some text on the **EditText** until the user press enter. The entered text is returned by this method as a String and the code continues to run from that point. The text passed as parameter will be displayed on the **TextView** before the code pause.

`clear()` - Remove all text from the **TextView** and continue to execute the code.

# Snippet Code

```
fun main() {

    io.write("Hello, World")
    io.writeln("!!!")

    val readName = io.read("Enter your name:")
    val readNumber = io.read("Enter a repeat number:").toIntOrNull() ?: 0

 	for (qty in 1..readNumber) {
        io.writeln("$qty $readName")
    }

    io.writeln("End!")
}
```

# Sample Images

![](https://github.com/diegolana/android_training/blob/main/TrainingSampleImg1.png)
![](https://github.com/diegolana/android_training/blob/main/TrainingSampleImg2.png)

branch_name: refs/heads/main


text:
# Kaholo Kubernetes Plugin
[Kubernetes](https://kubernetes.io/), also known as K8s, is an open-source system for automating deployment, scaling, and management of containerized applications. Many implementation of Kubernetes are widely available, including Minikube and MicroK8s, which run even on notebook computers, and cloud platform implementation such as Amazon Elastic Kubernetes Service (EKS), Google Kubernetes Engine (GKE), and Azure Kubernetes Service (AKS).

Kaholo provides separate plugins for the creation of Kubernetes clusters in the cloud.
* [Kaholo GKE Plugin](https://github.com/Kaholo/kaholo-plugin-google-cloud-kubernetes-engine) - specifically for creating GKE Kubernetes clusters
* [AWS EKS Plugin](https://github.com/Kaholo/kaholo-plugin-aws-eks) - specifically for creating EKS Kuberenetes clusters
* [Azure CLI Plugin](https://github.com/Kaholo/kaholo-plugin-azure-cli), [AWS CLI Plugin](https://github.com/Kaholo/kaholo-plugin-aws-cli), and [GCP CLI Plugin](https://github.com/Kaholo/kaholo-plugin-gcp-cli) - general tools that could also be used to create Kubernetes clusters

Once a cluster has been created in any of these platforms, this Kubernetes plugin can then be used to manage Kubernetes applications on those clusters. There are two types of method in the plugin. Most make use of npm package [@kubernetes/client-node](), and method "Run Kubectl Command" makes use of docker image [bitnami/kubectl](https://hub.docker.com/r/bitnami/kubectl) to run `kubectl` commands.

## Use of Docker
Method "Run Kubectl Command" makes use of docker image [bitnami/kubectl](https://hub.docker.com/r/bitnami/kubectl) to run `kubectl` commands. This has many advantages but a few caveats as well of which the user should be aware.

If running your own Kaholo agents in a custom environment, you will have to ensure docker is installed and running on the agent and has sufficient privilege to retrieve the image and start a container. If the agent is already running in a container (kubernetes or docker) then this means a docker container running within another container.

The first time the plugin is used on each agent, docker may spend a minute or two downloading the image. After that the delay of starting up another docker image each time is quite small, only a second or two.

Next, because the `kubectl` command is running inside a docker container, it will not have access to the complete filesystem on the agent. This can impact certain commands such as `kubectl apply -f configuration.yaml` - because configuration.yaml is a file on the disk of the Kaholo Agent, not inside the docker image running the command. However it DOES mount a volume for the Kaholo Agent's working directory, which is /usr/src/app/workspace. If your files are inside this directory they can be accessed by the `kubectl` command.

For example, using the Kaholo Git plugin, you have cloned a repository named kubeconfigs such that the application configuration is in file `/usr/src/app/workspace/kubeconfigs/myapp/myapp-kube.yaml`. If you then use method "Run Kubectl Command" and provide command `kubectl apply -f kubeconfigs/myapp/myapp-kube.yaml`, then the command will execute properly.

## Access and Authentication
Kubernetes relies on three parameters for Access and Authentication. These are stored in a Kaholo Account, which can then be easily reused for any Kuberenetes plugin Action or related ones such as Helm.

The Kaholo Account contains these parameters:
* Cluster CA Certificate: `LS0tLS1CRUd...very long string...FLS0tLS0K`
* API Server Endpoint: `https://<IP_ADDRESS>`
* Service Account Token: `eyJhbGciOiJ...very long string...JK3RGEpfDA`

Note: Some implementations of Kubernetes will provide the CA certificate in standard multiline PEM format that starts with `-----BEGIN CERTIFICATE-----`. The Kubernetes plugin can make use of either this or the Base64 format normally seen in kubectl output. (`kubectl config view --raw`)

>Careful!
>
>When copying very long Base64 strings, a common problem is for word-wrap features to result in newline characters inserted into the copy. When pasted in this condition authentication will fail. To avoid this, turn word-wrap off before copying or otherwise ensure you have copied a single one-line string. When you then paste into the Kaholo Account or Kaholo Vault it will get word-wrapped again, but this is normal and harmless.

## Namespaces
Kubernetes makes use of namespaces to provide a secure multi-tenant functionality in which accounts can be restricted to work within specific namespaces and have no visibility or access to others. This also provides a convenient way to organize pods in groups, e.g. by product group or organization or to separate test environments from each other.

Some kubernetes objects exist only at cluster level, i.e. they have no namespace - for example namespaces themselves. In this case, you may specify a namespace anyway or leave the parameter empty and it has no effect on the outcome.

It is possible to specify namespace in as many as three different and even conflicting ways. This generally produces no error, however ultimately only one namespace will be used. If no namespace is specified at all, kubernetes uses the "default" namespace, i.e. a namespace named `default`.

## Method Apply
This method applies a kubernetes configuration in the form of a YAML document. This is the equivalent to command `kubectl apply -f filename.yaml`.

Here's an example YAML configuration file that specifies a redis pod named redis-server:

    apiVersion: apps/v1
    kind: Deployment
    metadata:
    name: redis-server
    labels:
        app: redis-server
    spec:
    selector:
        matchLabels:
        app: redis-server
    replicas: 1
    template:
        metadata:
        labels:
            app: redis-server
        spec:
        containers:
            - name: redis-server
            image: redis
            imagePullPolicy: IfNotPresent
            ports:
            - containerPort: 6379

Note that his example contains no specification of namespace.

### Parameter: YAML File Path
This is the path to the YAML file (on the Kaholo Agent) that contains the kubernetes configuration you wish to apply.

### Parameter: Namespace
This is the namespace in which to apply the YAML. If the YAML already contains namespace you may leave the parameter empty. If the parameter has a conflicting namespace, the one specified in the YAML takes precedence. If neither the parameter nor the YAML specify namespace, the `default` namespace will be used.

## Method: Delete Objects
This method deletes any of several classes of kubernetes objects.
### Parameter: Objects Map
This parameter is for `<object_type> <object_name>` space-separated pairs. For example to delete a pod named redis and a service named redis-server, the parameter should contain:

    pod redis
    service redis-server

### Parameter: Namespace
This is the namespace of the objects you wish to delete, if they are objects within a namespace other than `default`. For objects at cluster level, this parameter has no effect.

## Method: Get Service
This method retrieves the details of any one service.

### Parameter: Service
This is the name of the service for which to get the details.

### Parameter: Namespace
This is the namespace in which the service exists. If left empty the `default` namespace is assumed.

## Method: Get All Services
This method retrieves a list of all services, with an optional filter.

### Parameter: Labels Filter
This is for optional key=value pairs. Only services with labels matching the filter will be retrieved. For example if your service is labeled like so:

            "labels": {
                "app": "redis-server"
            },

Then to select this service use Labels Filter `app=redis-server`.

### Parameter: Namespace
This is the namespace in which to list services. If left empty the `default` namespace is assumed.

## Method: Run Kubectl Command
This method runs any `kubectl` command.

### Parameter: Command
The command you wish to run. Only kubectl may be run with this method. To run other types of command, use the Command Line Plugin instead. A few example commands:

    kubectl get namespaces
    kubectl get pods --all-namespaces
    kubectl delete -f filename.yaml
    kubectl config view
    kubectl version

### Parameter: Namespace
The namespace given here is put in the kubectl configuration so that the command doesn't require the `--namespace` option, as a convenience. If the command contains `--namespace` anyway, the namespace specified in the command overrides the namespace in the parameter.

If no namespace is given in the command or the parameter, the `default` namespace will be assumed.

If using `kubectl apply -f` with a YAML file, the namespace in the YAML overrides both `--namespace` in the command or any namespace specified in this parameter.

repository: Kaholo/kaholo-plugin-kubernetes

gha_license_id: MIT

repo_name: Kaholo/kaholo-plugin-kubernetes


text:
# Change Log
All notable changes to this project will be documented in this file.
This project adheres to [Semantic Versioning](http://semver.org/).
## [ 1.3.0]
### [Added]
- Add support for flags changing DPI: `--small` (100 DPI), `--medium` (300 DPI), `--large` (1000 DPI).

### [Changed]
- Default DPI is now 300, instead of 1000.

## [ 1.2.2]
### [Changed]
- Refactored internal code for interfacing command line and program usage as a lib-module.
  Changes do not change how the program is invoked.

## [ 1.2.1]
### [Added]
- Fix DPI of area graphs to 1000.

## [ 1.2.0]
### [Added]
- Add support for exom coverage.

## [1.1.5]
### [Fixed]
- Write transparent png:s instead of empty (which actually where not empty)

## [1.1.4]
### [Added]
- Add option `--chunk / -u` to set Matplotlib chunk size from commandline

## [1.1.3]
### [Changed]
- Exit(0) instead of exit(1) when empty bedfile given as input

## [1.1.2]
### [Fixed]
- Typo bug

## [1.1.1]
### [Fixed]
-Adjust chunksize to stop Matplotlib from throwing OverflowError

## [1.1]
### Added
-Test files of every supported type
## Changed
-Isodisomy to replace homodisomy in code, backwards compatible
### Fixed
-Bug fixed when parsing UPD regions
-Delete tmp files added to repo by mistake

## [1.0.2]
### Fixed
-Better check for 37 vs 38 name convention
-Handle empty string in parsing
-Check for empty dataframe

## [1.0.1]
### Fixed
-Don't crash on empty BED file

## [1.0.0]
### Added
-Add support for autozygosity bed:s.
-Add support for fraction of homozygosity wig:s
### Changed
-Command line arguments name and flags are changed. Not backwards compatible.
-Printed colors daker and uniform
### Fixed
-Bug that wrote over output
-Debug prints removed

## [0.3.6]
### Added
- Region UPD pictures are now split in the middle to visually indicate two
chromosomes.

## [0.3.5]
### Added
- Pixel perfect prints 7750 X 385 px

### [0.3.4]
### Added
- Picture DPI increase from 100 X 100 to 1000 X 1000
### Fixed
- Alignment of BED files was offset

## [0.3.3]
### Fixed
- Coverage plots from Tiddit data was printed strange

## [0.3.2]
### Added
- Add Support for Hetero/Isodisomy of UPD Region Files.

## [0.3.1]
### Fixed
- Bugfix: outd ignored for upd sites

## [0.3.0]
### Added
- Change flag "upd" to "sites
### Fixed
- Refactor code

## [0.2.1]
### Fixed
- When using `euploid` flag written empty png:s did not match correct genome prefix (37 vs 38)

## [0.2.0]
### Added
- Option `--euploid`
- More Pytest tests

### Fixed
- Better follows Pylint (though far from perfect)

## [0.1.3]
### Added
- Support for second guessing ideogram bed file chromosome format (i.e. 1 or chr1)
- Test file `test_chr_utils.py`

### Fixed
- Bug: Sloping graphs
- Bug: use `os.path` instead of concatenating string

## [0.1.2]

### Added
- Improved args handling

### Fixed
- Bug: Remove dependency on X display

## [0.1.1]
### Fixed
- Configured and parameterized WIG step was previously ignored
- Bug when sometimes malplaced linear slopes appeared in coverage pictures

## [0.1]
First version.

repository: mikaell/chromograph

gha_language: Python

repo_name: mikaell/chromograph


text:
# Remote Expert Unity
![Remote Expert](../Docs/Logos/01.jpg)

This is the unity project used for creating Remote Agent applications using the Remote Expert Software.

## Hardware and Software Requirements

The Remote Technician can be run on a Microsoft HoloLens 1 or 2. It can only be compiled on a computer running Windows due to some of the dependencies being not being compatible with Mac or Linux.

## Dependencies
### Install Unity 2017
Ensure that you are installing unity 2017 if you are using the Hololens 1
(Unity Installer)[https://unity3d.com/get-unity/download]
### Install Visual Studio
(Visual Studio)[https://visualstudio.microsoft.com/downloads/]

## Import Remote Expert into Unity
Open unity and import the "unity" folder as a project into it

## Extending the application
### RemoteExpertTemplate.unity
This file is the main scene from which all Remote Expert applications are made
Make a copy of this file, and give it the name that you want

### The router
When a request is received from the Base-station, it is read by the Router and handled in a way determined by you.
To determine what each request does, the router needs to be configured by using the config.json file.

### config.json
The config.json file is where you can customize the functionality of your Remote Expert Application.
At compile time the config.json file is read, and a Router is generated based on its contents.

The contents of this file will be explained

The format is as follows:

```
{
    "rest": [{ // This is the configuration fo the rest handler
        "name" "the name of the resource",
        "prefab": "The filename in the Resources folder of the prefab",
        "verbs": ["An array of strings as a subset of, get, post, put, and delete"],
    }],
    "customHandlers": [{ // This is the configuration for custom handlers
        "name": "an identifying name to call",
        "handler": "The filename of the Handler in the Resources/Handlers folder",
    }]
}
```

### Handlers
When the Hololens receives a message from the base-station, the router reads the name field in the request and sends the message to the specified handler.

Handlers receive the request data, process it in some way and send back a response.

There are two main types of handlers, the Rest Handler, and custom handlers.

### The Rest Handler
Most operations that the Base-station wants to instruct the Hololens to do, involve placeing, modifying, reading the attributes of, and removing holograms from the view of the Hololens. These conveniently correspond with the four most common REST verbs, post, put, get,  delete.

Because of this, Remote expert built in a special handler to create, read, update, and destroy different types of holograms based on simple requests.

This is an example configuration of the rest handler in config.json

```
"rest": [{
    "name": "water",
    "prefab": "H20.unity",
    "verbs": ["get", "post", "patch", "delete"],
    "attributes": {
        "location": "float[]",
        "scale": "float[]",
        "color": "float[]"
    }
}]
```

In this case we have the name water, which will be used by the router to determine which resource should be created. The prefab field points to a specific file containing a unity prefab. In this case we have a model of a water molecule which is the model that will be rendered. The verbs determine which operations are allowed, in this case we can do all 4. Finally the attributes determine which attributes are valid to send, in this case, the location that the hologram should be rendered, the size of the hologram, and the color.

### Rest Example Requests

#### Post
Creating a new blue molecule 1x1x1 meter in the current center of the hololens.

```
{
    "name": "water",
    "verb": "post",
    "attributes:"{
        "location": [0.5, 0.5],
        "scale": [1, 1, 1],
        "color": [0, 255, 0]
    }
}
```

On a success the following will be sent to the server

```
{
    "status": 200,
    "message": "Successfully created a hologram",
    "id": "79a2ab46-6d17-4049-b41f-2ac8874d3d85"
}
```

#### Get
Getting the previously created hologram
```
{
    "name": "water",
    "verb": "get",
    "id": "79a2ab46-6d17-4049-b41f-2ac8874d3d85"
}
```
On a success the following will be sent to the server
```
{
    "status": 200,
    "message": "Successfully retrieved hologram",
    "body": {
        "id": "79a2ab46-6d17-4049-b41f-2ac8874d3d85",
        "location": [0.5, 0.5],
        "scale": [1, 1, 1],
        "color": [0, 255, 0]
    }
}
```
#### Put
Modifying the previously created hologram, doubling the size of the x-axis and turning it green
```
{
    "name": "water",
    "verb": "put",
    "id": "79a2ab46-6d17-4049-b41f-2ac8874d3d85",
    "attributes": {
        "scale": [2, 1, 1],
        "color": [255, 0, 0]
    }
}
```
On a success the following will be sent to the server
```
{
    "status": 200,
    "message": "Successfully modified hologram",
    "body": {
        "id": "79a2ab46-6d17-4049-b41f-2ac8874d3d85",
        "location": [0.5, 0.5],
        "scale": [2, 1, 1],
        "color": [255, 0, 0]
    }
}
```
#### Delete
Removing the previously created hologram
```
{
    "name": "water",
    "verb": "delete",
    "id": "79a2ab46-6d17-4049-b41f-2ac8874d3d85"
}
```
On a success the following will be returned to the server
```
{
    "status": 200,
    "message": "Successfully deleted hologram",
    "id": "79a2ab46-6d17-4049-b41f-2ac8874d3d85",
}
```
### Custom Handlers
If the functionality of placing and modifying holograms is not enough for your application you can use custom handlers

Custom handlers extend the Handler class, and can be made to respond to a specific request, and do any action possible within the HoloLens environment.

One example of a custom handler would be to retrieve the current spatial mesh, and send it to the base-station

### Making a Custom Handler
The handler is a unity game object, and consists of a single method, "handle".

Extend the Handler class and name it whatever you would like, placing the handler file in the Handlers folder.
We will create a file named SpatialMeshHandler.cs and place it in the Handlers folder.

Override the handle function,
- It must take, a string: message as an argument, this is the request, that is routed to it.
- Add any functionality you would like. In this fetch the current spatial mesh.
- The function must then return a string which will be the response to the requester. In this return the serialized spatial mesh

### Registering a custom handler
Once you have made your custom handler. You must register it using the config.json file. this is done in the customHandlers field.

```
"customHandlers": [{
    "name": "get spatial mesh",
    "handler": "SpatialMeshHandler.cs",
}]
```
Any request that has the field "name" with a value of "get spatial mesh", will now be routed to the handler we just created

An example request is simply this:
```
{
    "name": "get spatial mesh"
}
``

repository: xmaayy/RemoteExpert

gha_language: ShaderLab

repo_name: xmaayy/RemoteExpert


text:
# 💰unison-money

A Small library for working with Money in Unison

## Install

### Status: 🏗 Pre-release
This library is currently very much in the development and exploration phase.

Install latest (pre-release):

```
.> pull https://github.com/hojberg/unison-money:.releases._latest external.money
```

## Design

The design of the library is built after a couple of principles.
1) We want to ensure Money is handled correctly and that money math is sound. The amount is stored as an Int in "cents" (as a term meaning to any minor part of a currency).
2) It should not be possible to do any math operations of Money of different currencies. This is done by a type variable in the constructor. Currently any type can be added as a currency, though the library does come with a set of currencies. Typeclasses might help tighting up this API in the future.
3) Regular division of Money is tough and doesn't quite make sense because you can't have half a penny. Instead we allow splitting Money where whole remainder is added to one of the chunks: 10 split into 3, results in 3 new Money types, 2 where the amount is 3 and 1 where the amount is 4. _Note that there are cases where fractional pennies make sense, but that has not been the focus here._

## API

* `Money` Constructor: Create a `Money` value with `Money USD +499` for an amount representing `$ 4.99`
* `Money.toText`: Simply formats the `Money` as a `Text` (in the format of `USD 4.99` with any regard for localized formatting (this will be added later): `Money.toText : Money a -> Text`
* `Money.+` (aliased as `plus`)
* `Money.-` (aliased as `minus`)
* `Money.*` (aliased as `multiply`)
* `Money.split`: Take 1 `Money` and split into `Nat` chunks. Returns a list of the possible splits with whole remainders added to the `Money` values at the end of the list: `Money.split 3 (Money USD +10)` (10 cents) results in `[Money USD +3, Money USD +3, Money USD +4]`

## Planned API
* Formatting function that allows localized formatting of Money
* Percents, for instance for adding 20% tip at a Restaurant.
* Tax

repository: hojberg/unison-money

repo_name: hojberg/unison-money


text:
# Security Policy

## Reporting a Vulnerability

We're very happy to have vulnerabilities reported.

If possible, it would be great if they could come with a suggested
solution as this will make fixing them easier and faster.

You can email them to<EMAIL_ADDRESS>and we will do our best
to fix them as soon as possible.

repository: refinery/refinerycms

gha_language: Ruby

repo_name: refinery/refinerycms


text:
I will start by posting a little bit of
a challenge the challenge of dealing
with data data that we have to deal with
in medical situations it's really a huge
challenge for us and this is our beast
of burden this is a computer tomography
machine CT machine it's a fantastic
device it uses x-rays x-ray beams that
are rotating very fast around the human
body it takes about 30 seconds to go
through the whole machine and is
generating enormous amounts of
information that comes out of the
machine so this is a fantastic machine
that we can use for improving healthcare
but as I said it's also a challenge for
us and the challenge is really found in
this picture here it's the medical data
explosion that we're having right now
we're facing this problem and let me
step back in time let's just go back a
few years in time and see what happened
back then these machines that came out
they started coming in the 1970s they
would scan off human bodies and they
would generate about a hundred images of
the human body and I've taken the
liberty just for clarity to translate
that to data sizes that would correspond
to about 15 megabytes of data which is
small when you think about the data that
we can handle today just on normal
mobile devices if you translate that to
phone books it's about one litre of
phone books in the pile looking at what
we're doing today with these machines
that we have we can just in a few
seconds get 24,000 images out of the
body and that will correspond to about
20 gigabytes of data or 800 phone books
and the pod will then be 200 meters of
phone books what's about to happen and
we're seeing this it's beginning a
technology trend that's happening right
now is that we're starting to look at
time-resolved situations as well so
we're getting the dynamics out of the
body as well and just assume that we
will be collecting data during five
seconds and that will correspond to
about one terabyte of data that's
800,000 books and 16 kilometres of phone
books there's one patient one data set
and this is what we have to deal with so
this is really the enormous challenge
that we have
today this is 25,000 images you know
imagine that the days when we had
radiologists
doing this they would put up 25,000
images that would go like this 25 there
there is the problem right they can't do
that anymore that's impossible so we
have to do something that's a little bit
more intelligent than doing this okay so
what we do is that we put all these
slices together
imagine that you slice your body in all
these directions and then you try to put
the slices back together again into a
pile of data into a block of data so
this is really what we're doing so this
gigabyte a terabyte of data we're
putting it into this block but of course
the block of data just contains the
amount of x-ray that's been absorbed in
each point in the human body so what we
need to do is to figure out a way of
looking at the things that we do want to
look at and make things transparent that
we don't want to look at so transforming
the data set into something that looks
like this
and this is a challenge this is a huge
challenge for us to do that using
computers even though they're getting
faster and better all the time it's a
challenge to deal with gigabytes of data
or terabytes of data and extracting the
relevant information I want to look at
the heart I want to look at the blood
vessels I want to look at the liver
maybe even finally the tumor in some
cases okay so this is where this little
dude comes into play this is my daughter

this is a as of 9:00 a.m. this morning
she's playing a computer game she's only
2 years old and she's having a blast so
she's really the the driving force
behind the development of graphics
processing units as long as kids are
playing computer games graphics is
getting better and better and better so
please go back home tell your kids to
play more games because that's what I
need so what's inside of this machine is
what enables me to do the things that
I'm doing with the medical data so
really what I'm doing is using these
fantastic little devices and you know
going back maybe 10 years in time when I
got the funding to buy my first graphics
computer
it was a huge machine it was cabinets of
processors and storage and everything I
paid about 1 million dollars for that
machine that machine is today about as
fast as my iPhone
so every month there are new graphics
cards coming out and here's a few of the
latest ones from the vendors and Nvidia
ATI Intel is out there as well and you
know for a few hundred bucks you can get
these things and put them into your
computer and you can do fantastic things
with these graphics cards so this is
really what's enabling us to deal with
the explosion of data in medicine
together with some really nifty work in
terms of algorithms compressing data
extracting the relevant information that
people are doing research on so I'm
going to show you a few examples of what
we can do this is the data set that was
captured using a CT scanner you can see
this is a full data it's a it's a woman
you can see the hair you can see the
individual structures and of the woman
you can see that there is scattering or
x-rays on the teeth the metal in the
teeth that's that's what those artifacts
are coming from but fully interactively
on standard graphics cards I on a normal
computer I can just put in a clip plane
and of course all the data is inside so
I can start rotating I can look at it
from different angles and I can see that
this woman had a problem there was a she
had a bleeding up in the brain and
that's been fixed with a little stent a
metal clamp that's tightening up the
vessel and just by changing the
functions and I can decide what's going
to be transparent and what's going to be
visible I can look at the skull
structure and I can see that okay this
is where they open up the skull on this
woman and that's where they went in so
these are fantastic images they're
really high resolution and they're
really showing us what we can do with
with standard graphics cards today
now we have really made use of this and
we have tried to squeeze a lot of data
into the system and one of the
applications that we've been working on
and this has gotten a little bit of
traction worldwide is the application of
virtual autopsies so again looking at
very very large datasets and you saw
those full-body scans that we can do
we're just pushing the body through the
whole CT scanner and just in a few
seconds we can get a full-body data set
so so this is from a virtual autopsy and
you can see how I'm gradually peeling
off first you saw the body bag that the
body came in that I'm peeling off the
skin you can see the muscles and
eventually
you can see the bone structure of this
woman now at this point I would also
like to emphasize that with the greatest
respect for the people that I'm now
going to show I'm going to show you a
few cases of virtual autopsies so it's a
great respect for the people that have
died under violent circumstances that
I'm showing these pictures to you in the
forensic case and this is something that
there's been approximately 400 cases so
far just in the part of Sweden that I
come from that has been undergoing
virtual autopsies in the past four years
so this will be the typical workflow
situation that police would decide in
the evening when there's a case coming
in they would decide okay this is the
case where we need to do an autopsy so

in the morning between 6:00 and 7:00 in
the morning the board is then
transported inside of the body bag to
our Center and is being scanned through
one of the CT scanners and then the
radiologist together with the
pathologist and sometimes the forensic
scientist looks at the data that's
coming out and they have a joint session
and then they decide what to do in the
real physical autopsy after that now
looking at a few cases here's one of the
first cases that we had you can really
see the details of the data set it's
very high resolution and it's our
algorithms that allow us to zoom in on
all the details
and again it's fully interactive so you
can rotate and you can look at things in
real time all these systems here without
saying too much about this case this is
a traffic accident and a drunk driver
that hit a woman and it's very very easy
to see the damages on the bone structure
and the course of death is the broken
neck and this woman also ended up under
the car so she's quite badly beaten up
by by this injury here's another case a
knifing and this is also again showing
us what we can do it's very easy to look
at metal artifacts that we can show
inside of the body you can also see some
of the some of the artifacts from from
the teeth that's actually the feeling in
the teeth but because I've set the
functions to show me metal and make
everything else transparent here's
another violin case this really didn't
kill the person the person was killed by
stabs in the heart but they just
deposited the knife by putting it
through one of the eyeballs here's
another case it's very very interesting
for us to
be able to look at things like knife
stabbings here you can see that knife
went through the heart it's very easy to
see how air has been leaking from one
part to another part which it's
difficult to do in a normal standard
physical autopsy so it really really
helps the the criminal investigation to
establish the cause of death and in some
cases also directing investigation in
the right direction to find out who the
killer really wasn't
here's another case that I think is
interesting here we you can see a bullet
that has lodged just next to the spine
on this person and what we've done is
that we've turned the bullet into a
light source so the the bullet is
actually shining and it makes it really
easy to find these fragments during a
physical autopsy if you have to dig
through the body to find these fragments
that's actually quite hard to do one of
the things that I'm really really happy
to be able to show you here today is our
virtual autopsy table it's a touch
device that we have developed based on
these algorithms using standard graphics
GPUs it actually looks like this just to
give you a feeling for what it looks
like it's really an it really just works
like a huge iPhone so we've implemented
all the gestures that you can do on the
table
and you can think of it as an enormous
touch interface so if you were thinking
of buying an iPad forget about it this
is what you want instead Steve I hope
you're listening to this way okay so
it's a very nice little device so if you
have the opportunity please try it out
it's it's really a hands-on experience
so it gained some traction and we're
trying to roll this out and trying to
use it for educational purposes but also
perhaps in the future in a more clinical
situation that's a YouTube video that
you can download and look at this if you
want to convey the information to other
people about virtual autopsies okay now
we're talking about touch let's let me
move on to really touching data and this
is a bit of science fiction now so so
we're moving into the really the future
this is not really what the medical
doctors are using right now but I hope
they will in the future so what you're
seeing on the left is a touch device
it's a it's a little mechanical pen that
has very very fast depth motors inside
of the tongue so I can generate a force
feedback so when I perch
we touched data it will generate forces
independent so I get a feedback okay so
in this particular situation is it's a
scan or the living person I have this
pen and I look at the data and I moved
the pen towards the head and all of a
sudden my feet of assistance okay so I
can feel the skin if I push a little bit
harder I'll go through the skin and I
can feel the bone structure inside if I
push even harder I'll go through the
bone structure especially close to the
ear where the bone is very soft and then
I can feel the brain inside and this
will be a slushie weightless so this is
really nice and you know to take that
even further this is at heart and this
is also due to these fantastic new
scanners that justing in 0.3 seconds I
can scan the whole heart and I can do
that with time resolution so just
looking at this heart I can playback a
video here and this is Collier on one of
my graduate students is been working on
this project and he's sitting there in
front of the haptic device the force
feedback system and he's moving his pen
towards the heart and the heart is not
beating in front of him so you can see
how the heart's beating he's taking the
pen and he's moving it towards the heart
and he's putting it on the heart and
then he feels the heartbeats from the
real living patient and he can examine
how the heart is moving they can go
inside push inside of the heart and
really feel how the valves are moving
and this I think is really the future
for for heart surgeons so I mean it's
probably the wet dream for a heart
surgeon to be able to go inside of the
patients heart before we actually do
surgery and do that with high quality
resolution data so this is really neat
now we're going even further into
science fiction and we heard a little
bit about functional MRI now this is
really really an interesting project MRI
is using magnetic fields and radio
frequencies to scan off the brain or any
part of the body so what we're really
getting out of this is information of
the structure of the brain but we can
also measure the difference in magnetic
properties of blood that's oxygenated
and blood as depleted of oxygen that
means that it's possible to map out the
activity of the brain so this is
something that we've been working on and
you just saw Matt's the research
engineer they're going into the MRI
system and he was wearing goggles
they could actually see things in the
goggle so I could present things to him
while he's in the scanner and this is a
little bit freaky
because what Matt's is seeing is
actually this he's seeing his own brain
so much is doing something here probably
he's going like this with his right hand
because the left side is is activated
with the motor cortex and then you can
see that at the same time these
visualizations are brand new and this is
something that we've been researching
for a little while this is another
sequence of Matz's brain and here we
asked much to go to calculate backwards
from 100 so he's going 100 97 94 and
then he's going backwards and you can
see how little math processor is working
up here in his brain and is lighting up
the whole brain this is fantastic we can
do this in real time we can investigate
things we can tell him to do things you
can also see that his visual cortex is
activated in the back of the head
because that's where he's seeing he's
seeing his own brain and it's also
hearing our instructions when we tell
him to do things the signal is really
deep inside of the brain as well and
it's shining through because all of the
data is inside of this volume and in
just a second here you will see ok here
mots ok now move your left foot okay so
it's going like this ok but for 20
seconds it's going like that and all of
a sudden it lights up up here so we get
motor cortex activation up there so this
is really really nice and and I think
this is a great tool and connecting also
to the previous talk here this is
something that we could use as a tool to
really understand how the neurons are
working how the brain is working and we
can do this was a very very high visual
quality and very fast resolution now
we're also having a bit of fun at the
center so this is a cat scan computed
tomography so this is a lion from the
local Zoo outside of norrkoping called
Morden Elsa so she came to the center
and they sedated her and then put it
straight into the scanner and of course
I get the whole data set from the lion
and I can do very nice images like this
I can peel off the layer of the lion I
can look inside of it and you know we've
been experimenting with this and I think
this is a great application for the
future of this technology because
there's very little known about the
animal Anatomy what's known out there
for veterinarians it's kind of basic
information now we can scan all sorts of
things all sorts of animals
the only problem is to fit it into the
machine okay so here's a bear it was
kind of hard to get it in and you know
the bear is a cuddly friendly animal and
here it is here's the nose of the bear
and you know you might want to cuddle
this one until you've changed the
functions look at this so be aware of
the bear alright so with that I'd like
to to thank all the people that have
helped me to generate these images it's
a huge effort that goes into doing this
gathering the data and developing the
algorithms writing all the software so
some very talented people my motto is
always I only hire people that are
smarter than I am and most of these are
smarter than I am so thank you very much

repository: prewittdavon/TEDVis

repo_name: prewittdavon/TEDVis


text:
# booking saas

The repo for the booking system as a service

# design notes

## flexibility

Each customer will have different needs.  There is a compromise between:

 * being picky of who our customer is and not writing code for each one
 * having generic enough code that we make good money for not much work

To solve the tension between these two, we need to combine the following tools:

 * config driven components (yaml files)
 * libraries of code drivers - can be controlled from yaml files
 * specialised per customer code snippets that can be 'slotted' into a small part

The system needs to try and offer as many **hooks** as possible.

For example - the calendar is a config driven part where we say:

> given this YAML - make a list of days with attributes

We could design our system so the calendar module loaded the YAML and based on
what the YAML contained - produce the list of days.  This is pretty much what V1
is doing.

### config driven components

This is the most basic tool in that it means given some YAML:

```yaml
price: 20
fields:
  - type: checkbox
    title: include ice-cream
```

Generate some useful thing (either GUI components or config for another part of the system).

The YAML files are split up across each section  - copy and paste the YAML into a text editor
if you want to change anything.

Over time, we can develop GUIs to allow the user to edit this YAML without knowing but to start with,
a SaaS platform consists of users-configuration being managed.

### drivers

By using the `driver` concept - we can make a `default` calendar driver.  It's
job is to turn our basic calendar format into an actual list of days within a range.

If the calendar config does not name a driver - `default` is assumed and the behaviour
is like we already have,

If the calendar config names `multiple_slots` as the driver - it can be a codebase
that understands a common requirement (having a day with multiple parallel bookable things).

A customer appears and they want the `multiple_slots` type calendar config - they can have
their own variables and each customer can use a different driver.

Apply this concept to every part of a booking system:

 * calendar
 * day schedule
 * options form
 * price calculation
 * info form
 * payment configuration
 * messaging

And each part can have drivers for the key steps - the more driver hooks the better, there is a very low
cost to adding a hook and it will give us unknown flexibility down the road.

### specialised code snippets

This is for when an existing driver will not cut the mustard and we need to have custom code written for a customer.

Specialised code should always be written as a driver - even if only used once it means we don't need another mechanism
for loading library code.

# data structures

## calendar

One of the main components of the system - this decides how to render the calendar view for booking forms.

### product

A thing that can be booked - a single calendar can display multiple products to book.

### schedule

Schedule data represents a single day shcedule for a product

 * date (date)
 * tracks ([]track)
   * title (string)
   * name (string)
   * slots ([]slot)
     * title (string)
     * name (string)
     * time_start (time)
     * duration (int)
     * bookings ([]booking)

# developing

## build

```bash
$ make build
```

## start

```bash
$ make dev
$ make api.cli
$ node src/index.js
$ make frontend.cli
$ yarn run watch
```

## initial boot

After the first initial boot - there are no database tables, create them:

```bash
$ make schema
```

## database ops

#### get psql CLI

```bash
$ bash scripts/postgres.sh psql
```

#### drop tables

```bash
$ cat scripts/sql/drop.sql | bash scripts/postgres.sh psql
```

#### create tables

```bash
$ make api.cli
$ yarn run knex -- migrate:latest
```

#### create new migration for app

```bash
$ make api.cli
$ yarn run knex -- migrate:make mymigration
```

#### reset database

stop docker

```bash
$ rm -rf .data
```

repository: binocarlos/templatestack

repo_name: binocarlos/templatestack


text:
![Precisely](/precisely_logo_purple.jpg)

# Precisely APIs

### Description
[Precisely APIs ](https://developer.precisely.com/) Enrich your data, and enhance your applications, business processes and workflows with dozens of powerful location & identity APIs.

### Precisely APIs:

* [Geocode](https://developer.precisely.com/apis/geocode): Accurate Geocoding. Convert individual or batch collections of addresses to latitude & longitude coordinates and vice versa. Useful for enhancing & enriching your customer addresses.

* [Typeahead](https://developer.precisely.com/apis/typeahead): Address Autocomplete. Build Address typeahead into your websites. The Typeahead API returns an autocompleted list of addresses based on the input of a partial address. Useful for any local search, checkout, shipping, or billing experiences on your website. Increase e-commerce conversion by 3-6%!

* [Maps](https://developer.precisely.com/apis/maps): Beautiful Visualization. Add your data and/or Precisely data atop beautiful maps for visualizations. Choose from three map styles - Bronze, Iron, and Steel.

* [Zones](https://developer.precisely.com/apis/zones): Smart Zones. The Zones API returns geographic zones by Radius, Drive Distance, Drive Time and highly localized geofence zones with the input of Location Coordinates or Addresses. Useful for anyone wanting to create smarter geofence zones for Local Engagement and Analysis.

* [Routing](https://developer.precisely.com/apis/routing): Accurate Routing. The Routing API returns Point-to-Point and Multi-Point Travel Directions by Various Travel Modes. Critical for any Simple or Complex Routing Requirement.

* [Streets](https://developer.precisely.com/apis/streets): Global Street Information. Enrich your applications, business processes, and workflows with global street information including nearest intersections and speed limits. The Streets API accepts an address or location and returns nearest intersection information. The speed limit method accepts a series of locations and returns speed limits along a street segment.

* [Places](https://developer.precisely.com/apis/places) : Global Place Data. Enrich your applications, business processes, and workflows with over 180 million of global retail businesses and landmark points-of-interest. The Places API accepts multiple powerful inputs & filtering options and returns thousands of records in a single API request. The Places API also supports global typeahead place search. Useful for enriching your data and/or analytics processes with rich commercial business information and place names.

* [Risks](https://developer.precisely.com/apis/risks): Risks Insights. Capture Crime, Earthquake, Flood, Fire, Fire Station and Distance-to-Flood-Hazard risk data for Analysis, Planning, Claims, and Mitigation. The Risks API returns risk intelligence with the input of Location Coordinates or Addresses. Critical for any impact analysis involving threats to lives or property.

* [911/PSAP](https://developer.precisely.com/apis/911): Emergency call handling. Integrate Public Safety Answering Point (PSAP) administrative call routing information plus Authority Having Jurisdiction (AHJ) phone numbers into your emergency services products and services. The 911/PSAP API retrieves 10-digit phone numbers and local contact info with the input of a location coordinate. Useful for emergency services administrators, call handlers, and dispatchers.

* [Demographics](https://developer.precisely.com/apis/demographics) : Audience Enrichment. Add local demographics and lifestyle segmentation to your people profiles. The Demographics & Lifestyle API returns household demographics and lifestyle characteristics with the input of an address or location coordinate. Know more about your customers and their customers.

* [Local Tax](https://developer.precisely.com/apis/localtax): Local Tax. Add hyperlocal tax rates to your applications, business processes, and workflows. The Local Tax API returns local tax rates with the input of location coordinates or addresses. Critical for any billing, commerce, payment, or payroll application or service.

* [Telecomm Info](https://developer.precisely.com/apis/telecomm): Service Provider Intelligence. Identify Local Exchange Carrier presence, area codes, exchanges, and more within a Rate Center area. The Telecomm Info API retrieves Incumbent Local Exchange Carrier (ILEC) doing-business-as names along with NPA/NXX, LATA, and phone number ranges with the input of an address or location coordinates. Useful for local telecommunications competitive intelligence, partnerships, and provisioning subscribers.

* [Time Zone](https://developer.precisely.com/apis/timezone): Local time. The Time Zone API returns time zones and UTC offsets with the input of a location coordinate or address. Useful for do-not-call, logistics, and customer engagement applications, business processes and workflows.

* [Geolocation](https://developer.precisely.com/apis/geolocation): Device Location. The Geolocation API returns location coordinates based on the input of an IP Address or Wi-Fi Access point MAC address. Useful for a variety of applications, business processes and workflows in eCommerce, Fraud Detection, Physical-Digital interactions, Field Service and more.

* [Identity Profiles](https://developer.precisely.com/apis/identityprofiles): Rich Identity Profiles. Powerful, local socio-economic & affinity insights about your customer. Enrich shipping addresses with rich, localized Identity profiles, demographics, lifestyle segmentations, neighborhood names, property ownership & values, and social affinity insights. The Identity Profiles API returns all these data with the input of a Physical Address, Email Address, or Twitter handle. Useful for enhancing & enriching a wide variety of applications, business processes, or workflows.

* [Schools](https://developer.precisely.com/apis/schools): School Listings. Gather local multiple school listings, types, districts and education levels for your applications. The Schools API accepts multiple powerful inputs & geographic filtering options and returns nearby school listings and additional data a single API request. Useful for enriching your applications and websites.

* [Neighborhoods](https://developer.precisely.com/apis/neighborhoods): Neighborhood Insights. Integrate global neighborhood names and classification information into your applications and enrich other data. The Neighborhood API accepts latitude & longitude coordinates and returns the corresponding neighborhood name & type. Useful for a wide range of data enrichment use cases.

* [Property Information](https://developer.precisely.com/apis/property): Property Insights. Integrate extensive residential & commercial property information into your applications. The Property Information API returns property parcel boundaries and hundreds of property attributes for millions of US properties with the input of Location Coordinates or Addresses. Useful for Real Estate use cases or those involving risk assessments.

* [Address Verification](https://developer.precisely.com/apis/addressverification): Real, accurate and complete address. Eliminate errors in address data, improve customer experience. The Address Verification API makes communication easier, faster and effortless by enriching customer details, keeping it up-to-date and maintaining its accuracy and consistency. It eliminates redundancy in reaching out to customers and makes it easy for distinct functional areas to work seamlessly in improving customer relationship.

* [Email Verification](https://developer.precisely.com/apis/emailverification): Email address validation and protection. The Email Verification API corrects and validates your email addresses to protect your database from invalid, toxic and undesirable email addresses. We help you avoid a damaged sender reputations by flagging those bouncing emails, spam trap hits, honeypots, stale lists and do-not-contact list before you have a chance to use them.

* [Addresses](https://developer.precisely.com/apis/addresses): Gather multiple Addresses if you don’t have them and use these to query all other Precisely APIs. The Addresses API accepts names of a boundary such as zip code, neighborhood, county, and city—as well as your custom geographic boundaries or drivetimes & drive distances—and returns all known & valid Addresses associated with these names, or Addresses contained with the supplied or chosen geographic boundary.

* [Phone Verification](https://developer.precisely.com/apis/phoneverification): The Phone Verification API accepts any phone number as input and returns verification information, Service Provider name, and more. Useful to verify if phone numbers exist to reduce fraud and improve communications.

The following platforms are supported by Precisely SDKs:
*	[Android](https://developer.precisely.com/apis/docs/index.html#Android%20SDK/android_intro.html)
*	[NodeJS]()
*	[iOS](https://developer.precisely.com/apis/docs/index.html#iOS%20SDK/ios_intro.html)
*	[Java](https://developer.precisely.com/apis/docs/index.html#Java%20SDK/java_intro.html)
*	[C#](https://developer.precisely.com/apis/docs/index.html#C_sdk/java_intro.html)

[Click here](https://developer.precisely.com/apis/docs/index.html) for detailed Documentation on Precisely APIs

# PreciselyAPIs NodeJS SDK
### Description
PreciselyAPIs NodeJS SDK facilitates you to build NodeJS applications using Precisely APIs.
### Getting Started
To get started with NodeJS SDK, you must first register at [Precisely APIs Home Page](https://developer.precisely.com/) and obtain your API Key and Secret to get started with the NodeJS SDK and call Precisely APIs.
For more information refer to [‘Getting Started with NodeJS SDK’](https://developer.precisely.com/apis/docs/index.html#NodeJS/node.js_sdk.html) section in documentation.

# PreciselyAPIsSDK-NodeJS

## Building Project

To build the project locally by downloading from GitHub

``` shell

npm install

npm run build

```
## Requirements

Building the API client library requires latest [NodeJS](https://nodejs.org/en/) to be installed.

## Installation

To install the API client library to your local project, simply execute:

```shell
npm install preciselyapis-client
```

To deploy it globally, simply execute:

```shell
npm install -g preciselyapis-client
```

## Getting Started

Please follow the [installation](#installation) instruction and execute the following NodeJS code:

```js
//We are getting refrence to the installed preciselyapis-client package
const PreciselyAPINodeJS = require('preciselyapis-client');

try     {
    // Configure OAuth2 API_KEY and SECRET for authorization
    const oAuth = new PreciselyAPINodeJS.OAuth();
    oAuth.oAuthApiKey="API_KEY";
    oAuth.oAuthSecret="SECRET";

    oAuth.getOAuthCredentials().then((data) => {

        var _911PSAPServiceApi = new PreciselyAPINodeJS._911PSAPServiceApi(data.body);

        _911PSAPServiceApi.getAHJPlusPSAPByAddress("950 Josephine Street Denver CO 80204").then((response) => {
            console.log("Result " + JSON.stringify(response.body));
        }).catch((response) => {
            console.log("Error " + JSON.stringify(response.body));
        });
 }).catch((error) => {
        console.log("Error" + JSON.stringify(error))
    });
}
catch (error1) {
    console.log("Exception raised"+ error1);
}
```

repository: rexhomes/PreciselyAPIsSDK-NodeJS

repo_name: rexhomes/PreciselyAPIsSDK-NodeJS


text:
# RTL

Windi CSS has out-of-box RTL support with zero configuration from `v2.5.4`.

By prefixing the `rtl:` variant to utilities, they will only apply when RTL is enabled.

<!-- With the following example, the `Preview` text will be `text-right` and `text-red-400` on the RTL. Try play with it: -->

<!-- <InlinePlayground :input="'text-green-400 rtl:(text-right text-red-400)'" :showCSS="true" :showPreview="true" /> -->

It's easy to enable RTL, you just need to apply `dir="rtl"` on the `html` element.

```html
<html>
<body>
  <!-- RTL disabled -->
</body>
</html>

<html dir="rtl">
<body>
  <!-- RTL enabled -->
</body>
</html>
```

repository: kevinkhill/docs

repo_name: kevinkhill/docs


text:
# Duple

[![Code Climate](https://codeclimate.com/badge.png)](https://codeclimate.com/github/subakva/duple)
[![Build Status](https://secure.travis-ci.org/subakva/duple.png)](http://travis-ci.org/subakva/duple)

Duple makes it easy to move PostgreSQL data around between your deployment
environments. Duple knows how to move data from one heroku environment to
another and how to load it into your local database. It can execute rake or
Heroku commands before and after your loading data into your target
environment. This is great for scrubbing, replacing, trimming or generating
data for your test environments.

## Installation

Install the gem:

    $ gem install duple

Generate a config file:

    $ duple init

## Configuration

The generated config file contains samples of all the different ways you can
figure the application. Read and modify it, or clear it out and write your own.

## Usage

    # Resets the stage database
    # Loads the latest production snapshot into the stage database
    $ duple refresh -s production -t stage

    # Downloads the latest full snapshot from production
    # Resets the development database
    # Loads the snapshot into the development database
    $ duple refresh -s production -t development

    # Captures a new production database snapshot
    # Downloads the latest full snapshot from production
    # Resets the development database
    # Loads the snapshot into the development database
    $ duple refresh -s production -t development --capture

    # Downloads the schema and a subset of data from stage
    # Resets the backstage database
    # Loads the structure and the subset into the backstage database
    $ duple refresh -s stage -t backstage --group minimal

    # Downloads the data from the specified tables from the stage database
    # Loads the data into the backstage database
    $ duple copy -s stage -t backstage --tables products categories

## Future

  * Custom error classes.
  * Improve documentation
  * Support non-Heroku remote PostgreSQL servers.
  * Move knowledge of endpoint types out of Thor tasks.

  * Support for skipping pre- and post- refresh steps.
  * Support for running pre- and post- refresh steps by themselves.
  * Support for other data stores.

## Contributing

  1. Fork it
  2. Create your feature branch (`git checkout -b my-new-feature`)
  3. Commit your changes (`git commit -am 'Add some feature'`)
  4. Push to the branch (`git push origin my-new-feature`)
  5. Create new Pull Request

repository: subakva/duple

repo_name: subakva/duple


text:
GTIRB Pretty Printer
====================

A pretty printer from the [GTIRB](https://github.com/grammatech/gtirb)
intermediate representation for binary analysis and reverse
engineering to gas-syntax assembly code.

## Building

The pretty-printer uses C++17, and requires a compiler which supports
that standard such as gcc 7, clang 6, or MSVC 2017.

To build and install the pretty printer, the following requirements
should be installed:

* [GTIRB](https://github.com/grammatech/gtirb).
* [Capstone](http://www.capstone-engine.org/). At the moment
  we require our own fork https://github.com/GrammaTech/capstone/tree/next
  that contains some additional fixes (until new official releases are cut).
* [Boost](https://www.boost.org/), version 1.67.0 or later.
  * Requires the libraries:
    * filesystem
    * program_options
    * system

Note that these versions are newer than what your package manager may provide
by default: This is true on Ubuntu 18, Debian 10, and others. Prefer building
these dependencies from sources to avoid versioning problems.

Use the following options to configure cmake:
- You can tell CMake which compiler to use with
  `-DCMAKE_CXX_COMPILER=<compiler>`.
- Normally CMake will find GTIRB automatically, but if it does not you
  can pass `-Dgtirb_DIR=<path-to-gtirb-build>`.
- gtirb-pprinter can make use of GTIRB in static library form (instead of
  shared library form, the default) if you use the flag
  `-DGTIRB_PPRINTER_BUILD_SHARED_LIBS=OFF`.
- Furthermore, if you want to produce a `gtirb-pprinter` executable that links
  statically, specify `-DGTIRB_PPRINTER_STATIC_DRIVERS=ON`.
- You can configure CMake to use a custom location for Capstone by specifying
  `-DCMAKE_LIBRARY_PATH=<path-to-capstone>`.
- You can use vcpkg on Windows to provide some dependencies by passing
  `-DCMAKE_TOOLCHAIN_FILE=<path-to-vcpkg\scripts\buildsystems\vcpkg.cmake>`.

Once the dependencies are installed, you can configure and build as follows:

```sh
cmake ./ -Bbuild
cd build
make
```

## Installing
See the [GTIRB readme](https://github.com/GrammaTech/gtirb/#installing).

## Usage

### Generate reassembleable assembly code
Pretty print the GTIRB for a simple hello world executable to an
assembly file named `hello.S`, assemble this file with the GNU
assembler to an object file named `hello.o`, and link this object file
into an executable.

```sh
gtirb-pprinter hello.gtirb --asm hello.S
as hello.S -o hello.o
ld hello.o -o hello
./hello
```
### Generate a new binary
The `--binary` flag to gtirb-pprinter generates a new binary by
calling `gcc` directly.

```sh
gtirb-pprinter hello.gtirb --binary hello
```

This option admits an argument `--library-paths` or `-L` to
specify additional paths where libraries might be located.

For example:
```sh
gtirb-pprinter hello.gtirb --binary hello -L . -L /usr/local/lib
```

### Dummy .so
In some cases, it is desirable to rebuild a dynamically linked ELF executable
without any of the libraries to which it is linked (e.g., if rebuilding an
executable from another system).

Normally, the linker needs to have the libraries in order to link with them.
However, the `--dummy-so` option generates fake libraries that contain the
required symbols used by the binary, which is sufficient for running the
linker. An example is shown:

```sh
gtirb-pprinter hello.gtirb --binary hello --dummy-so=yes
```

If the binary requires verisoned symbols (which is likely if it uses a recent
version of glibc), some further arguments may be necessary. Your system's
startfiles may differ from the startfiles that the binary was originally built
with, causing symbol version incompatibilities when gtirb-pprinter removes
startup code and your compiler replaces it with its own. To best work around
this, add the following arguments:

```sh
gtirb-pprinter hello.gtirb --binary hello --dummy-so=yes --keep-all-functions -c -nostartfiles
```

These ensure that startup code (such as functions like `_start` or
`__libc_csu_init`) present in the GTIRB is used as-is, instead of replacing
them with startup code provided by your compiler, preserving the same symbol
versions that the binary originally used.

## AuxData Used by the Pretty Printer

Generating assembly depends on a number of additional pieces of information
beyond the symbols and instruction/data bytes in the IR. The pretty printer
expects this information to be available in a number of
[AuxData](https://github.com/GrammaTech/gtirb/blob/master/README.md#auxiliary-data)
objects stored with the IR. We document the expected keys along with the
associated types and contents in this table.

| Key              | Type                                           | Purpose                                                                                |
|------------------|------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------|
| comments         | `std::map<gtirb::Offset, std::string>`           | Per-instruction or data element comments.                                                                                |
| functionEntries    | `std::map<gtirb::UUID, std::set<gtirb::UUID>>` | UUIDs of the blocks that are entry points of functions.                                                                                |
| symbolForwarding | `std::map<gtirb::UUID, gtirb::UUID>`           | Map from symbols to other symbols. This table is used to forward symbols due to relocations or due to the use of plt and got tables. |
| encodings            | `std::map<gtirb::UUID,std::string>`            | Map from (typed) data objects to the encoding of the data,  expressed as a std::string containing an assembler encoding specifier: "string", "uleb128" or "sleb128".     |
| sectionProperties | `std::map<gtirb::UUID, std::tuple<uint64_t, uint64_t>>` | Map from section UUIDs to tuples with the section types and flags. |
| cfiDirectives   | `std::map<gtirb::Offset, std::vector<std::tuple<std::string, std::vector<int64_t>, gtirb::UUID>>>` | Map from Offsets to  vector of cfi directives. A cfi directive contains: a string describing the directive, a vector  of numeric arguments, and an optional symbolic argument (represented with the UUID of the symbol). |
| elfSymbolInfo | `std::map<gtirb::UUID, std::tuple<uint64_t, std::string, std::string, std::string, uint64_t>>` | On ELF targets only: Map from symbols to their type, binding, and visibility categories. |

## AuxData Used by the Binary Printer

In order to generate new binaries, gtirb-binary-printer also uses the following tables:

| Key              | Type                             | Purpose                                                                          |
|------------------|----------------------------------|----------------------------------------------------------------------------------|
| libraries        | `std::vector<std::string>`       | Names of the libraries that are needed.                                          |
| libraryPaths     | `std::vector<std::string>`       | Paths contained in the rpath of the binary                                       |

repository: GrammaTech/gtirb-pprinter

repo_name: GrammaTech/gtirb-pprinter


text:
# Aws.S3.Sync

Small wrapper script that calls AWS S3 synchronization and emails the results at the end.

## TODO

- [ ] Store encryption key securely.
- [ ] Store email password securely.
- [ ] Sign script
- [ ] Create chocolatey package.

## Preqs

- [AWS PowerShell Tools](http://docs.aws.amazon.com/powershell/latest/userguide/pstools-getting-set-up.html)

## Usage

```powershell
$remote = "s3://bucketname/"
$local = "C:\users\"
$users = @("User1","User2")
$encryptionKey = "0000000-0000-0000-0000-000000000000"
$username =<EMAIL_ADDRESS>$password = "a_secret"
$logsdir = "C:\sync\logs\"
$dryrun = $false

$scriptdir = Split-Path $script:MyInvocation.MyCommand.Path
. "$scriptdir\SyncUsers.ps1" -remote $remote -local $local -users $users -encryptionKey $encryptionKey -logsdir $logsdir -username $username -password $password -dryrun:$dryrun
```

```dos
powershell.exe -executionpolicy bypass C:\example_above.ps1
```


text:
# Hugo Shortcodes

[Hugo][hugo] provides a way to insert template snippets into Markdown to
support "rich content" better than plain markdown. By default, Hugo includes
[shortcodes][sc] for embedding tweets, youtube videos, and other content
without needing to add HTML snippets.

For tweets, you can add `{{< tweet<PHONE_NUMBER>82868480 >}}` into the post and
it'll render the HTML for the embed.

In this repo, I've got a few other shortcodes you can copy into the
`layouts/shortcodes/` directory to reference. For more info, check out
[this post](https://serverlesscode.com/post/hugo-shortcodes-for-tech-blogging/)
to learn more.

## License

This project is released under the MIT license, see the LICENSE file for full
text.

## The Docs

### code.html

Code highlighting through [highlight.js][hl] by adding the right CSS classes.

```
{{< code "python" >}}
import this
{{< /code >}}
```

```
<pre><code class="python">
import this
</code></pre>
```

### github.html

Auto-link to a github project, with the text of the link as the user/name.

```
{{< github "ryansb/hugo-shortcodes" >}}
```

```
<a href="https://github.com/ryansb/hugo-shortcodes">ruansb/hugo-shortcodes</a>
```

### stack.html

This one creates a "launch stack" button like this:
![](https://s3.amazonaws.com/cloudformation-examples/cloudformation-launch-stack.png)
and links it to the template in a region you specify.

```
{{< stack
  name="StackOfCloudBlocks"
  bucket="files.mysite.com"
  key="infrastructure.template"
>}}
```

This code puts together the full URL, and can optionally take an AWS region to
launch templates worldwide. It outputs a button like this:

[hugo]: http://gohugo.io/
[sc]: https://gohugo.io/extras/shortcodes/
[hl]: https://highlightjs.org/


branch_name: refs/heads/develop

gha_language: C#