text:
# Technologies

This has been primarily written in d3.js, but Bootstrap has also been used for the infobox popovers (and Bootstrap requires jQuery).

libraries:
 * lodash - utility functions
 * d3.promise.js - adds promises to d3's file reading functions
 * bootstrap - used for the popover functionality
 * jquery - required for bootstrap.
 * simple-statistics - for the ckmeans clustering algorithm
 * loglevel - for logging

# Design patterns

The d3 components have been written using Mike Bostock's [reusable charts pattern](https://bost.ocks.org/mike/chart/). The non-d3 objects have been written using closure functions with getters and setters i.e.:

	GENEMAP.Person = function(name, age) {
	  var my = {};

	  var privateFn = function() { ... }

	  my.publicFn = function(a, b, c) { ...}

	  my.age = function(value) {
		  if (!arguments.length) return age;
		  age = value;
		  return my;
	  }

	  return my;
	}

This was to keep them similar to the d3 objects. If the number of these objects increase it is recommended to switch using a prototype constructor pattern to avoid the overhead of duplicated function objects.

I've tried to use a global module `var GENEMAP = GENEMAP || {};` and attached all the object to this module but I've not used the module pattern to isolate the dependencies of each object. This is something that may be necessary as the codebase grows.

# Layout

The map is drawn within a contained element, the id of which has to be passed to the .draw() method.

The basic constructed layout is

- The menu markup (menu_bar.js), a `<div>` containing the buttons to control the map
- The SVG container (genemap.js), the map creates its own SVG element to contain the drawing
  - zoom window (genemap.js) - This is a wrapper that has the d3 zoom functionality added to it
    - outline (genemap.js) - This draws the document outline and sets the backgorund color
    - cell containers (chromosome_cell.js) - A list of cell cotnainers to contain each of the chromosomes
    - gene-annotations (gene_annotations.js) - A container for all the gene annotations
    - qtl-annotations (qtl_annotations.js) - A container for all the QTL annotations
    - chromosome (chromosome.js) - A container for the chromosome image
    - chromosome-label (chromosome_cell.js) - A container for the chromosome label

The chromosome container contents is generated by the chromosome.js code and has the following structure:

	g.chromosome - a group for each chromosome defined
		defs
			mask - the mask used for this chromosome
		text - the top label of the chromosome
		background - sets the white background
		bands-container - contains the bands and uses the mask
			bands - a collection of colored rectangular bands
		outline - the black outline to the chromosome

The bands themselves are drawn as a stack of rectangles, to achieve the rounded corners a rounded rectangle mask is defined and applied to the bands container.
To get the black outline another rounded rectangle is drawn over the top of the bands container.
The background is needed to prevent any annotation lines showing through the middle of the chromosome where there are no bands.

Even though the chromosomes and annotations share the same data I decided to draw them using separate components to simplify the individual components.

# Data processing

The data is read from one or two XML files.
It is then processed by the processor, this alters the colors and combines the data into a single genome object.

	genome
		chromosomes
			annotations
				genes
				qtls
			bands

#Layout generation

The layout functions in `auto_layout.js`, `gene_annotation_layout.js` and `gene_bands_layout.js` decorate the genome object
 with computed objects specifying how the chromosome bands and annotations should be displayed.

	genome
	    cellLayout
		chromosomes
            cell
		    layout
		        annotationClusters
		        annotationDisplayClusters
		        annotationNodes

		        geneBandClusters
		        geneBandDisplayClusters
		        geneBandNodeso

## Global Layout
`cellLayout` contains the global properties for the whole layout.
`chromosome.cell` contains the positioning information for a single chromsome cell.

The layout of the cell containers and the elements within them is control by the layout decorator (auto_layout.js).
This 'decorates' the genome data object with some layout properties that are used by the cell containers to position the cells themselves and their contents.

The position of each of the cells is calculated as follows:

 - The number of cells is calculated (number of rows and columns) based on the number of chromosomes and the number of chromosomes to put on each row.
 - Once the number of rows and columns is calculated the space (excluding the margin) is divided into these cells. This means all chromosomes will be initially visible.

The position and size of the gene-annotations, qtl-annotations, chromosome and chromosome label within the cell is calculated by:

 - The top and bottom margins and the height of the cell label is calculated as a percentage of the cell's height, the rest of the cell's height is given to the chromosome.
 - The chromosome's width is then calculated based on the aspect ratio of the chromosome. The left and right margins are calculated as a percentage of the width, the rest of the space is given to the QTL annotations (to the left of the chromosome) and the gene-annotations (to the right of the chromosome) equally.

## Individual annotation layout
`chromsome.layout` contains the computed layout for individual gene bands and annotations.

For xxx = annotation or geneBand:

- `xxxClusters` are groups of several genes which have been merged to make it easier to display them.
- `xxxDisplayClusters` are the clusters currently being displayed (may differ from `Clusters` if a clusters has been expanded).
- `xxxNodes` contain the actual positioning and colouring information (generated by labella in the case of gene annotations).

#infobox

The infoboxes are the popovers that appear when the annotations are clicked. They are twitter bootstrap popovers that are triggered on click (as opposed to hover).
 To dismiss them when something else is clicked there is a click handler on the html element that clears all popovers.

# logging

Logging is handled by the loglevel library:

    log.error( 'An error message' );

Log level can be set in the console window with `setLevel()` and will be persisted between sessions if the second argument is true.
In index.html, `log.setDefaultLevel("info")` applies only if a previously persisted log level is not found.

# icons
Icons come from the O-Collection.
They are downloaded in svg form, then converted to png of the correct size using inkscape. E.g:

    & 'C:\Program Files\Inkscape\inkscape.exe' --export-png=assets\img\information.png --export-width=36 --export-height=36 assets\svg\information.svg

The colours can be edited manually in the svg files:

    gray: #444444
    blue: #21a2ef

Both svg and png files are committed in the repository.

# namespaced bootstrap

To avoid having to use bootstrap's css on the entire site I've generated a customised version of the bootstrap css based on the answer to a question on [Stack Overflow](http://stackoverflow.com/questions/13966259/how-to-namespace-twitter-bootstrap-so-styles-dont-conflict).

This was compiled using [WinLess](http://winless.org/) although any Less compiler should work.

# npm and bower

To manage the development dependencies npm is used and bower is used for the libraries used at runtime. As this is a only a browser based component there should be no non-development dependencies installed by npm.

After checking out a copy of the source code you will need to run in the `GeneMap` directory:

    npm install
    bower install

This should automatically install all the dependancies.

# gulp

To automate development tasks `gulp` is used. This should be installed when `npm install` is run. To get a list of all the tasks run the `gulp` command in the `GeneMap` direcotry.

The main development tasks are:
 * *serve-dev* start the development server on port 8080
 * *optimise* build the combined & minified JavaScript and CSS files placing them into the `dist` folder
 * *watch* watches for changes to the .less files and automatically re-compiles the temporary .css files in the `.tmp` directory.
 * *inject* injects the dependencies into the index.html file (from bower, src/js and .tmp/css), also re-compiles all the CSS and SVG files.

 All of these configurations are controlled by the `gulpfile.js` and `gulp.config.js` files in the `GeneMap` directory.

# tests

There are a number of automated tests written in Jasmine.
These tests aren't comprehensive but do cover several areas (particularly the areas that don't directly interact with the DOM).
To run the tests run the `gulp serve-dev` process and navigate to http://localhost:8080/SpecRunner.html.

repository: AjitPS/KnetMiner

repo_name: AjitPS/KnetMiner


text:
<!--please copy and paste this template into your vXXX folder for the current release and modify there. Do NOT edit this template)-->

![Release Notes](https://github.com/openshift-knative/docs/blob/master/images/release-notes-banner.png)

# Knative Eventing on OpenShift Container Platform

**Release Date:**

This document describes the latest changes, enhancements, bug fixes and known issues for Knative Eventing on OpenShift Container Platform. It incorporates changes to Knative’s Eventing components, and may be adopted for consistency and compatibility on OpenShift.

>**NOTE:** The functionality introduced by Knative Eventing on an OpenShift cluster is developer preview only. Red Hat support is not provided, and this release should not be used in a production environment. Features are still under development and are not fully supported under Red Hat Subscription Level Agreements.

>**NOTE:** The features outlined in this document reflect the selected contributions of the Red Hat team. For complete details of Knative releases, refer to the **Resources and Links** section of this document.
-------------

## General Information

### Release components
The following components tested on the OpenShift 4.x cluster in this release:

|Component|Version
|---------|-------|
| Component | 0.0.0 |
----------------

## What's New

### Eventing
- **Brief:** Description. [(#PR)](link to PR)

-------------

## Fixed Issues

### Eventing
- See the [Knative core Eventing release notes](https://github.com/knative/eventing/releases).
- Description of fix. [(#PR)](link to PR)

-------------

## Known Issues
- **Brief:** Description. [(#PR)](link to PR)
-------------

## Resources and Links
- [OpenShift Serverless](https://docs.openshift.com/container-platform/4.1/serverless/understanding-serverless.html)
- https://github.com/knative/docs/releases
- https://github.com/knative/serving/releases
- https://github.com/knative/eventing/releases

repository: openshift-knative/docs

branch_name: refs/heads/master

extension: md

gha_language: SCSS

license_type: permissive

repo_name: openshift-knative/docs


text:
# Wretch Beauty Clock iOS App

Copyright © 2010 Yen-Shuo Su. All Rights Reserved.

Wretch Beauty Clock iOS App is a simple iOS application for demo or education purpose. It shows the Wretch Beauty Block widget in an UIWebView with some transformations.

## Contact

Feel free to write me a message to michaelsu {at} ecoworkinc {dot} com. I can read and write English an Chinese.

## License

The project is released under New BSD License.

## Acknowledge

The project is supported under "Employee's Casual Project" plan of Ecowork Inc (益科股份有限公司). Ecowork is a software company which provides:
	* iOS application development service.
	* Enterprise iOS application and infrastructure consultant service.
	* AppStore operation and financial service.
	* Large scale web service on Amazon AWS (EC2, S3.. etc).
	* Instance web service on Google App Engine.

repository: webgou/wretch-beauty-clock-ios-app

repo_name: webgou/wretch-beauty-clock-ios-app


text:
Common operations on SCH pipeline
=================================

This tutorial covers some common operations for [StreamSets Control Hub pipelines](https://streamsets.com/documentation/controlhub/latest/help/datacollector/UserGuide/Pipeline_Design/What_isa_Pipeline.html)
like update, duplicate , import.

A pipeline describes the flow of data from the origin system to destination systems and defines how to transform the data along the way.

### Prerequisites
Make sure to complete [Prerequisites for the pipelines tutorial](../preparation-for-tutorial).

### Tutorial environment details
While creating this tutorial following was used:
* Python 3.6
* StreamSets for SDK 3.8.0
* All StreamSets Data Collector with version 3.17.1

### Outline
In [Prerequisites for the pipelines tutorial](../preparation-for-tutorial/README.md), one pipeline was created with name 'SCH Hello World pipeline'.
On the very pipeline, this tutorial shows some operations like
1. to update the pipeline by adding new pipeline parameters
1. add a label to it
1. duplicate the pipeline
1. import and export it

### Workflow
On a terminal, type the following command to open a Python 3 interpreter.

```bash
$ python3
Python 3.6.6 (v3.6.6:4cf1f54eb7, Jun 26 2018, 19:50:54)
[GCC 4.2.1 Compatible Apple LLVM 6.0 (clang-600.0.57)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>>
```

### Step 1 — Connect to StreamSets Control Hub instance

Let’s assume the StreamSets Control Hub is running at http://sch.streamsets.com
Create an object called control_hub which is connected to the above.

```python
from streamsets.sdk import ControlHub

# Replace the argument values according to your setup
control_hub = ControlHub(server_url='http://sch.streamsets.com',
                         username='user@organization1',
                         password='password')
```

### Step 2 — Update pipeline - by adding runtime parameters
Let's update the pipeline by adding new [runtime parameters](https://streamsets.com/documentation/controlhub/latest/help/controlhub/UserGuide/Jobs/RuntimeParameters.html#concept_dwq_33w_vz).

 ```python
pipeline.parameters  = {'USERNAME': 'admin_user', 'PASSWORD': 'admin_password'}
control_hub.publish_pipeline(pipeline)
 ```
At this point, on browser, one can see the pipeline with updated runtime parameters as following:
![image alt text](../images/pipeline_parameters.jpeg)

### Step 3 — Add a label
[A pipeline label](https://streamsets.com/documentation/controlhub/latest/help/controlhub/UserGuide/Pipelines/PipelineLabels.html?hl=pipeline%2Clabel)
identifies similar pipelines or pipeline fragments. Use pipeline labels to easily search and filter pipelines and fragments when viewing them in the pipeline repository.

 ```python
pipeline.add_label('updated_label')
control_hub.publish_pipeline(pipeline)
 ```

### Step 4 — Duplicate the pipeline

 ```python
# Duplicate the pipeline
duplicated_pipeline = control_hub.duplicate_pipeline(pipeline)
 ```

At this point, on browser, one can see the duplicated pipeline with name as 'SCH Hello World pipeline copy':

![image alt text](../images/duplicated_pipeline.jpeg)

### Step 5 — Export and import the pipeline

 ```python
# Export the pipeline
pipeline_zip_data = control_hub.export_pipelines(duplicated_pipeline)

# Write to an archive the exported pipeline
with open('/tmp/sample_imported_pipeline.zip', 'wb') as pipelines_zip_file:
    pipelines_zip_file.write(pipeline_zip_data)

# Import the pipeline from the above archive
with open('/tmp/sample_imported_pipeline.zip', 'rb') as input_file:
    pipelines_imported = control_hub.import_pipelines_from_archive(input_file, 'Import Pipeline using SDK')
 ```

At this point, on browser, one can see the duplicated pipeline with name as 'SCH Hello World pipeline copy':

![image alt text](../images/imported_pipeline.jpeg)

### Step 6 — Delete pipelines
Since now done with the duplicated and imported pipelines, let's delete them.

**Note: Be careful** about delete operation as, this can not be undone.
 ```python
control_hub.delete_pipeline(duplicated_pipeline[0])
control_hub.delete_pipeline(pipelines_imported[0])
```

### Follow-up
To get to know more details about SDK for Python, check the [SDK documentation](https://docs.streamsets.com/sdk/latest/index.html).

If you encounter any problems with this tutorial, please [file an issue in the tutorials project](https://github.com/streamsets/tutorials/issues/new).

gha_language: Java


text:
## Gates

Deathbycaptcha,anti-captcha and 2captcha api support for integration with any software

### Windows

In order to use the gate, check the `scripts/windows` folder. Inside it, you'll find a batch program / file for each service.
Execute the file with the name you want to redirect.

The program will write a redirection rule in your Windows hosts file. In order to disable a gate once activated, remove the entry added by the bat file from: `%SystemRoot%\System32\drivers\etc\hosts`

For more details about the hosts file check [this](https://www.howtogeek.com/howto/27350/beginner-geek-how-to-edit-your-hosts-file/) link

### Linux

In `scripts/linux` you'll find a python script that toggles hosts file redirection
for given IP and domain name

`./linux_hosts.py <IP_ADDRESS> site.com`

### Redirection

The gates are redirection the following method:

- balance
- submit image captcha
- retrieve image captcha
- submit recaptcha
- get recaptcha response

### License
MIT

license: MIT

repository: bestcaptchasolver/gates

repo_name: bestcaptchasolver/gates


text:
# # SubCC

## Properties

Name | Type | Description | Notes
------------ | ------------- | ------------- | -------------
| `role`*_required_ | ```string``` |  Must match an existing CC role in chosen Template(s). Multiple CC recipients cannot share the same CC role.  |  |
| `email_address`*_required_ | ```string``` |  The email address of the CC recipient.  |  |

[[Back to Model list]](../../README.md#models) [[Back to API list]](../../README.md#endpoints) [[Back to README]](../../README.md)

repository: hellosign/dropbox-sign-php

branch_name: refs/heads/main

gha_language: PHP

gha_license_id: MIT

repo_name: hellosign/dropbox-sign-php


text:
# GeoHex

[![Build Status](https://travis-ci.org/teralytics/geohex.svg?branch=master)](https://travis-ci.org/teralytics/geohex)
[![Download](https://api.bintray.com/packages/teralytics/maven/geohex/images/download.svg)](https://bintray.com/teralytics/maven/geohex/_latestVersion)
[![Download](https://img.shields.io/npm/v/terahex.svg)](https://www.npmjs.com/package/terahex)

[GeoHex](http://www.geohex.org) implementation in Scala. Forked from [geohex4j](https://github.com/chsh/geohex4j).

# TeraHex

TeraHex is a geo-hashing scheme inspired by GeoHex with flexible grid sizes and encoders.

# Usage on JVM

Add dependency to `build.sbt`:

    resolvers += Resolver.bintrayRepo("teralytics", "maven")

    libraryDependencies += "net.teralytics" %% "geohex" % "0.1.+"

Use functions of the `net.teralytics.geohex.GeoHex` object:

    def encode(lat: Double, lon: Double, level: Int): String

    def decode(code: String): Zone

    def calcHexSize(level: Int): Double

Use functions of the `net.teralytics.terahex.TeraHex` object:

    def zoneByLocation(loc: LatLon, level: Int): Zone

    def encode(loc: LatLon, level: Int): Long

    def decode(code: Long): Zone

    def size(level: Int): Double

# Usage in JavaScript

Install from NPM registry with:

    $ npm install --save terahex

Or build using SBT with:

    sbt geohexJS/fastOptJS

The resulting JavaScript file will be in `js/target/scala-2.11/geohex-fastopt.js`.

Use the functions of the `terahex` object:

    function decode(code) // Returns Zone object

    function encode(lon, lat, level) // Returns string code

    function zoneByLocation(lon, lat, level) // Returns Zone object

    function size(level) // Returns hexagon side length in degrees at a given level

    function withRootSize(sizeAtLevelZero) // Returns a terahex object with a given root size

    function zonesWithin(fromLon, fromLat, toLon, toLat, level) // Returns an array of Zones within the bounding box

The resulting `Zone` object has properties:

    {
      "level": 3,
      "size": 12.345, // hexagon side length in degrees
      "location": { "lon": 0.00, "lat": 0.00 },
      "innerRadius": 11.222, // hexagon inner radius in degrees
      "geometry": [{"lon": 0.00, "lat": 0.00}, ... ], // locations of hexagon corners
      "wellKnownText": "POLYGON ((0.00 0.00, ...))", // hexagon geometry in WKT format
      "code": "1300251737352" // zone code as string
    }

# LICENSE

The MIT License (MIT)

Copyright (c) 2009 [sa2da](http://www.geohex.org)

Copyright (c) 2010 [CHIKURA Shinsaku](https://github.com/chsh), [Takuma Maruyama](https://github.com/mattak)

Copyright (c) 2015 [Teralytics AG](https://github.com/teralytics)

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

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

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


text:
CommaPropertiesParser
=====================
*A properties parser bundle that separates value by comma*

# Usage
*The CommaPropertiesParser reads java style properties files*

It has support for normal key=value style properties as well as multi-valued properties separated by commas.

## Example
*example.properties*

    # Single value property
    some.property=SomeValue
    # Multi-valued property
    many.valued.property=value1,value2

repository: oconnormi/Parsers

repo_name: oconnormi/Parsers


text:
# Spotify

## Company blurb

"Spotify transformed music listening forever when it launched in 2008. Discover, manage and share over 82 million tracks, including more than 4 million podcast titles, for free, or upgrade to Spotify Premium to access exclusive features for music including improved sound quality and an on-demand, offline, and ad-free music listening experience. Today, Spotify is the world’s most popular audio streaming subscription service with 422m users, including 182m subscribers, across 183 markets."[^1]

[^1]: Source: https://newsroom.spotify.com/company-info/

## Company size

8,230 (March 2022)

## Remote status

"We believe in offering our people the freedom to choose where they work. This means that for the majority of roles you can choose to work from home or in the office. You may even be able to work in a different city or country than your team as long as you’re based in the same region and it makes sense for your role.  In the meantime, you can see a list of our regions [here](https://www.lifeatspotify.com/work-by-region)."[^2]

[^2]: Source: https://www.lifeatspotify.com/being-here/work-from-anywhere

## Region

Worldwide

## Company technologies

- Scala
- Cassandra
- GCP

## Office locations

- Stockholm, Sweden
- New York City, New York, USA
- London, UK
- Amsterdam, The Netherlands
- Milan, Italy
- and [many, many more](https://www.lifeatspotify.com/locations)

## How to apply

Visit https://www.lifeatspotify.com/jobs to see open positions.

repository: remoteintech/remote-jobs

gha_language: JavaScript

repo_name: remoteintech/remote-jobs


text:
This folder contains various documentation for the `operational` package.

Files:

design.md

Describes miscellanous design decisions.

examples/

Extensive code examples.

proofs.md

Proofs that the implementation is correct: monad laws, monad transformer classes.

tutorial-changes.md

Documents changes how the library API and implementation differs from the Operational Monad Tutorial.

repository: HeinrichApfelmus/operational

gha_language: Haskell

gha_license_id: NOASSERTION

repo_name: HeinrichApfelmus/operational


text:
# Contributing Guidelines

There are two main ways to contribute to the project — submitting issues and submitting
fixes/changes/improvements via pull requests.

## Submitting issues

Both bug reports and feature requests are welcome.
Submit issues [here](https://github.com/Kotlin/kotlinx.serialization/issues).

* Search for existing issues to avoid reporting duplicates.
* When submitting a bug report:
  * Use a 'bug report' template when creating a new issue.
  * Test it against the most recently released version. It might have been already fixed.
  * By default, we assume that your problem reproduces in Kotlin/JVM. Please, mention if the problem is
    specific to Kotlin/JS or Kotlin/Native.
  * Include the code that reproduces the problem. Provide the complete reproducer code, yet minimize it as much as possible.
  * However, don't put off reporting any weird or rarely appearing issues just because you cannot consistently
    reproduce them.
  * If the bug is in behavior, then explain what behavior you've expected and what you've got.
* When submitting a feature request:
  * Use a 'feature request' template when creating a new issue.
  * Explain why you need the feature — what's your use-case, what's your domain.

    Even if you don't have a proposed solution, please report your problem.
  * If there is an alternative way to do what you need, then show the code of the alternative.

## Submitting PRs

We love PRs. Submit PRs [here](https://github.com/Kotlin/kotlinx.serialization/pulls).
However, please keep in mind that maintainers will have to support the resulting code of the project,
so do familiarize yourself with the following guidelines.

* All development (both new features and bug fixes) is performed in the `dev` branch.
  * The `master` branch always contains sources of the most recently released version.
  * Base PRs against the `dev` branch.
  * The `dev` branch is pushed to the `master` branch during release.
  * Documentation in markdown files can be updated directly in the `master` branch,
    unless the documentation is in the source code, and the patch changes line numbers.
* If you fix documentation:
  * After fixing/changing code examples in the [`docs`](docs) folder or updating any references in the markdown files
    run the [Knit tool](#running-the-knit-tool) and commit the resulting changes as well.
    Your changes will not pass the tests otherwise.
  * If you plan extensive rewrites/additions to the docs, then please [contact the maintainers](#contacting-maintainers)
    to coordinate the work in advance.
* If you make any code changes:
  * Follow the [Kotlin Coding Conventions](https://kotlinlang.org/docs/reference/coding-conventions.html).
    * Use 4 spaces for indentation.
    * Use imports with '*'.
  * [Build the project](#building) to make sure it all works and passes the tests.
* If you fix a bug:
  * Write the test that reproduces the bug.
  * Fixes without tests are accepted only in exceptional circumstances if it can be shown that writing the
    corresponding test is too hard or otherwise impractical.
  * Follow the style of writing tests that is used in this project:
    name test functions as `testXxx`. Don't use backticks in test names.
* If you introduce any new public APIs:
  * All new APIs must come with documentation and tests.
  * All new APIs are initially released with `@ExperimentalSerializationApi` annotation and are graduated later.
  * [Update the public API dumps](#updating-the-public-api-dump) and commit the resulting changes as well.
    It will not pass the tests otherwise.
  * If you plan large API additions, then please start by submitting an issue with the proposed API design
    to gather community feedback.
  * [Contact the maintainers](#contacting-maintainers) to coordinate any big piece of work in advance.
* If you propose/implement a new serialization format:
  * Follow the general advice on new public APIs above.
  * Note, that you can keep new format implementation in your own repository to be able to perform proper maintenance
    and to have a separate release cycle.
  * You can submit a PR to the [list of community-supported formats](formats/README.md#other-community-supported-formats)
    with a description of your library.
* Comment on the existing issue if you want to work on it. Ensure that the issue not only describes a problem,
  but also describes a solution that has received positive feedback. Propose a solution if there isn't any.

## Building

You can find all the instructions [here](docs/building.md)

### Running the Knit tool

* Use [Knit](https://github.com/Kotlin/kotlinx-knit/blob/master/README.md) for updates to documentation:
  * Run `./gradlew knit` to update example files, links, tables of content.
  * Commit updated documents and examples together with other changes.

### Updating the public API dump

* Use [Binary Compatibility Validator](https://github.com/Kotlin/binary-compatibility-validator/blob/master/README.md) for updates to public API:
  * Run `./gradlew apiDump` to update API index files.
  * Commit updated API indexes together with other changes.

## Releases

* Full release procedure checklist is [here](RELEASING.md).

## Contacting maintainers

* If something cannot be done, not convenient, or does not work — submit an [issue](#submitting-issues).
* "How to do something" questions — [StackOverflow](https://stackoverflow.com).
* Discussions and general inquiries — use `#serialization` channel in [KotlinLang Slack](https://kotl.in/slack).

gha_language: Kotlin


text:
# Bookmarks

### Kali

* [Offensive Security Appliances](https://www.offensive-security.com/kali-linux-vm-vmware-virtualbox-image-download/)
* [Kali Images](https://www.kali.org/downloads/)

### Labs

* [GNS3](https://www.gns3.com/)
* [Practice URLs](https://www.amanhardikar.com/mindmaps/PracticeUrls.html)
* [Vulnerable Apps List](https://www.amanhardikar.com/mindmaps/PracticeUrls.html)
* [Hacker High School](http://www.hackerhighschool.org/)

### VM Sources

* [Windows \(IE\)](https://developer.microsoft.com/en-us/microsoft-edge/tools/vms/)
* [Virtual Box Images](https://www.osboxes.org/virtualbox-images/)
* [OldApps](http://www.oldapps.com/)

### Hardware

* [Hak5](https://shop.hak5.org/)

### Podcasts

* [Darknet Diaries](https://darknetdiaries.com/)
* [Unsupervised Learning](https://danielmiessler.com/podcast/)
* [Security Now!](https://www.grc.com/securitynow.htm)
* [Risky Business](https://risky.biz/netcasts/risky-business/)

### Bounties

* [Intigriti](https://www.intigriti.com/public/)
* [HackerOne](https://www.hackerone.com/)
* [BugCrowd](https://www.bugcrowd.com/)
* [Cobalt](https://boards.greenhouse.io/cobaltio/jobs/4141074002)
* [Awesome Bug Bounty](https://github.com/djadmin/awesome-bug-bounty)
* [Bug Bounty Reference](https://github.com/ngalongc/bug-bounty-reference)

### News

* [Threatpost](https://threatpost.com/)
* [CSO Online](https://www.csoonline.com/news/)
* [Dark Reading](https://www.darkreading.com/)
* [Infosecurity Magazine](https://www.infosecurity-magazine.com/news/)
* [Security Week](https://www.securityweek.com/)
* [SANS](https://www.sans.org/reading-room/)
* [Hackmageddon](https://www.hackmageddon.com/)
* [Breach Level Index](https://breachlevelindex.com/)

### Conferences

* [Blackhat](https://www.blackhat.com/)
* [Defcon](https://www.defcon.org/)
* [Bsides](http://www.securitybsides.com/)
* [Shmoocon](https://shmoocon.org/)

repository: prosecurity/attackbook

repo_name: prosecurity/attackbook


text:
# 5GENESIS Validator

This module validates the correct syntax of the Experiment descriptor and the descriptors of the Network Service (VNFD + NSD). It allows two options: a stand alone validation service that returns whether the descriptor is correct or not and the onboarding option, which, besides the validation, performs the onboard of the descriptor after a successful validation or the launch of the experiment in case the descriptor belongs to an experiment. Also, as part of this last scenario, the experiment descriptor is stored in the *validator* database for later reusage or consultation.

**Note**: the Experiment descriptor validation is based on the latest version of the Experiment descriptor information model defined below. Therefore, older versions are not supported.

## Experiment descriptor definition

![Experiment descriptor](./images/ED.png)

All fields are required except the *Reservation_time* one, that is only required if the experiment is attended.

## Experiment descriptor example

    {
        "Id": 123,
        "Name":"sfafd",
        "User": 123,
        "Platform": "malaga",
        "TestCases": ["TC1", "TC2"],
        "UEs": ["UE1", "UE2"],
        "Slice": "slice id",
        "NS": "ns_id",
        "NS_Placement": "Edge",
        "Limited": true,
        "Type_experiment": false,
        "Scenario": ["scenario1", "scemarop2"],
        "Application": ["app1"],
        "Attended": true,
        "Reservation_time": 123
    }
**Note**: If the experiment is launched/created through the *validator*, the experiment is added to the __experiments database__ and an unique "_id" is automatically generated and added to the model. This field can be used to identify univocally the experiment for later use.

## Network service descriptors

The 5GENESIS Validator also validates VNFD and NSD packages.
For now only OSM descriptors are supported:

[VNFD information model](http://osm-download.etsi.org/ftp/osm-doc/vnfd.html "VNFD IM")

[NSD information model](http://osm-download.etsi.org/ftp/osm-doc/nsd.html "NSD IM")

## Validator configuration

As part of the *Validator* features, it performs not only validation but also onboards VNFDs and NDSs and launches Experiments defined by its Experiment Descriptor. To carry ouf these actions, the *validator* needs to know the destination URLs of those external services: this information is gathered in the file `config.env`.

### config.env example:

    ELCM_ED_POST="http:///localhost:5001/api/v0/run"
    MANO_NSD_POST=http://mano:5101/nsd
    MANO_VNFD_POST=http://mano:5101/vnfd

**NOTE**: MANO_NSD_POST and MANO_VNFD_POST are known URLs, as the *MANO Wrapper* is installed along with the *Validator* and therefore, should not be changed (unless the *Validator* is installed stand-alone).

## NBI REST API

The Validator is available through the Dispatcher port (8082) and using the endpoint `/validator` or, if deployed stand-alone, in port `5100`:

### Validator

| **Method**  | **URI** | **Description** | **Data** | **Parameters** | **Successful result** | **Error result** |
| ------- | --- | ------------| ---- | ---------- | --------- | ------------ |
| POST  | /validate/ed | Validate Experiment descriptor | [ED](experiment_schema.json) | - | [response message](schemas/response_detail.json) | [response message](schemas/response_detail.json) |
| POST  | /create/ed | Validate, launch Experiment descriptor and store it| [ED](experiment_schema.json) | - | [Experiment _id](schemas/_id_schema.json) | [response message](schemas/response_detail.json) |
| GET  | /ed | List of Experiment descriptors | - | - | [ED list](db_experiment_list_schema.json) | [response message](schemas/response_detail.json) |
| GET  | /ed/<exp_id> | Get a single experiment descriptor | - | Experiment _id | [ED db model](db_experiment_schema.json) | [response message](schemas/response_detail.json) |
| DELETE  | /ed/<exp_id> | Delete a single experiment descriptor | - | Experiment _id | - | [response message](schemas/response_detail.json) |
| POST  | /validate/vnfd | Validate VNFD | [VNFD Package](https://osm-download.etsi.org/ftp/osm-6.0-six/7th-hackfest/packages/) | - | [response message](schemas/response_detail.json) | [response message](schemas/response_detail.json) |
| POST  | /onboard/vnfd | Validate VNFD and add it to the NSD catalogue | [VNFD Package](https://osm-download.etsi.org/ftp/osm-6.0-six/7th-hackfest/packages/) | - | [id](schemas/osm_id.json) | [response message](schemas/response_detail.json) |
| POST  | /validate/nsd | Validate NSD | [NSD Package](https://osm-download.etsi.org/ftp/osm-6.0-six/7th-hackfest/packages/) | - | [response message](schemas/response_detail.json) | [response message](schemas/response_detail.json) |
| POST  | /onboard/nsd | Validate NSD and add it to the NSD catalogue | [NSD Package](https://osm-download.etsi.org/ftp/osm-6.0-six/7th-hackfest/packages/) | - | [id](schemas/osm_id.json) | [response message](schemas/response_detail.json) |

### Examples
Depending on how the application was installed (in stand-alone mode or along with the *Dispatcher*), the host, port and base path might change:

- [x] Validator relative path: {validator_host}:5100

- [x]  Dispatcher relative path: {dispatcher_host}:8082/validator

- Validate Experiment descriptor:
`/validate/ed`

Example:
> curl -X POST -d @descriptor.json <http://{relative path}/validate/ed>

- Validate and onboard Experiment descriptor:
`/onboard/ed`

Example:
> curl -X POST -d @descriptor.json <http://{relative path}/onboard/ed>

- Validate VNF descriptor:
`/validate/vnfd`

Example:
> curl -X POST -F<EMAIL_ADDRESS><http://{relative path}/validate/vnfd>

- Validate and onboard VNF descriptor:
`/onboard/vnfd`

Example:
> curl -X POST -F<EMAIL_ADDRESS><http://{relative path}/onboard/vnfd>

- Validate NS descriptor:
`/validate/nsd`

Example:
> curl -X POST -F<EMAIL_ADDRESS><http://{relative path}/validate/nsd>

- Validate and onboard NS descriptor:

`/onboard/nsd`

Example:
> curl -X POST -F<EMAIL_ADDRESS><http://{relative path}/onboard/nsd>

## Responses

The *Validator* issues a [response message](schemas/response_detail.json) in json format along with a status code:

- 200, 201: OK
- 204: Delete OK
- 400: Error during the validation
- 404: Not found
- 409: Conflict with descriptor already present
- 412: Wrong file in the request
- 500: Network error

## Logging

Application logs are available in the application directory as `validator.log`

#### Example

    2019-12-09 12:17:38,704 -VALIDATOR API- INFO Starting app
    2019-12-09 12:23:51,381 -VALIDATOR API- INFO Validating Experiment descriptor
    2019-12-09 12:23:51,400 -VALIDATOR API- DEBUG Experiment descriptor:
    2019-12-09 12:23:51,506 -VALIDATOR API- DEBUG Experiment descriptor sucessfully validated
    2019-12-09 12:24:07,708 -VALIDATOR API- INFO Validating Experiment descriptor
    2019-12-09 12:24:07,721 -VALIDATOR API- DEBUG Experiment descriptor:
    2019-12-09 12:24:07,803 -VALIDATOR API- DEBUG Problem while validating Experiment descriptor: '1234' is not of type 'integer'

## Next steps

- TBD

## Authors

Javier Melian<EMAIL_ADDRESS>
## License

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

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

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

repository: felipevicens/Dispatcher

repo_name: felipevicens/Dispatcher


text:
---
layout: page
title: "Maps Lie Class 3"
order: 3
subtitle: "Maps, Lies, and Storytelling: Class III, Maps & Location"
category: talk
date: 2014-09-26 12:00:00
author: 'Andrew Hill'
length: 2
---

### Maps, Lies, and Storytelling: Class III, Maps & Location

#### Target Audience: novice mappers

#### Objectives:

* Understand Digital vs. Web maps
* Understand Google vs. Openstack

#### Key Learnings:

* What is a tile?
* The anatomy of a webmap
* User privacy concerns

[View Slides Here](https://speakerdeck.com/andrewxhill/maps-lies-and-storytelling-p04-and-p05-maps-and-location)

repository: CartoDB/training

branch_name: refs/heads/gh-pages

gha_language: HTML

repo_name: CartoDB/training


text:
---
title: Auth0 Guardian
description: Links to Guardian documentation for each type of Guardian user role.
topics:
  - mfa
  - guardian
  - push-notifications
contentType:
  - index
useCase:
  - customize-mfa
---

# Auth0 Guardian

Guardian is Auth0's multifactor authentication solution that provides a simple and secure way to implement MFA. When using Guardian with Auth0, users will be prompted for additional authentication from the Guardian mobile application, helping to provide a more secure login.

**To learn more, click the link below that most suits your role:**

[Guardian for Administrators](/multifactor-authentication/administrator) - information on how to enable and configure Guardian.

[Guardian for Developers](/multifactor-authentication/developer) - learn how to customize Guardian to your needs, and use multifactor within your applications.

[Guardian for Users](/multifactor-authentication/guardian/user-guide) - this page is for users logging into your application using Guardian, Google Authenticator or SMS. It also has troubleshooting tips for any issues they may encounter.

repository: mehrdadmms/docs

repo_name: mehrdadmms/docs


text:
# Lesson Plan

We will be building both Python / Tensorflow / ML code, and writing "supporting code" to show good workflow / GitHub practices.

Lined up  : https://github.com/ImageLearning/Learning-TF2-IL/tree/master/Lessons with below, ended up "off by 1"

0. Setup Python & Tensorflow on Mac, Windows, and Windows-GPU : https://youtu.be/vZtfbdmXN_s
> In this lesson we will get setup to write code in Python and TF2, we will also run some existing code and do Q&A
1. Basic Python Programming & GitHub
> In this lesson, we will learn some python and check in our code to github as we go
- Create a new GitHub Repo to work out of
- Check it out locally
- Add a .gitignore file
- Add a ReadMe.md file
- basic Markdown syntax
- Git Commit
- Git Sync
- quick file layout
- Folder layout
    - Docs folder
    - Source folder
- GitHub Pages
- Branch
- Add a file that is too large (our model) and Git Reset to undo our last commit
- Git Add . VS git add * https://gist.github.com/dsernst/ee240ae8cac2c98e7d5d
2. Basic ML & Actions & Your first Image recognizer
> In this lesson we will write our first Tensorflow / ML code. We will setup actions to confirm that the code we check in works and adhere to good principles (python linter). We'll end with a classic Image recognition sample
3. Data Prep Setup & GitHub Pages
> In this lesson, we'll learn to identify if something is an octocat. Then we'll setup our own image recognition dataset with a variety of octocat stickers, and learn GitHub pages to publish our data set to. We'll also adjust our action to package our dataset for easy down by others.
4. Detecting Octocats with Tensorflow 2
> In this lesson, we'll take the data we prepared in lesson 4 and train a model to identify a few different octocats. Depending on if the community is involved and contributing, we may identify a lot. If there is time, and we get fancy, we could set it up as a local actions runner.
5. Polish on our Machine learning project & Pages & Actions
> In this lesson, we'll run Machine Learning a second time on our data set in a different way, to help differentiate between very similar octocats. We will also polish our Pages and Actions projects to make them easier for others to use, and see what is going on. Also advanced troubleshooting steps
6.  Port app to iOS + Actions
> We will port the recognizer to iOS, unclear if this is going to be moving the code, or just the trained model and CoreML. Also need to make sure the model we use in stage 4 or 5 works on iOS
7. Port app to Android + Actions
> We will port the recognizer to Android, unclear if this is going to be moving the code, or just the trained model. Also need to make sure the model we use in stage 4 or 5 works on iOS

**Output : ML**
-

**Output : Supporting tools**
- Action : Resize Images
- Action : Package images for easy download
- GitHub Pages hosting of Images and Downloads
    - Good First Issue : Display bounding rectangles

## Lesson Format

Each Lesson starts with a sample folks can download to follow along
Each Lesson ends with
- A completed sample folks can use in an Open Source repo
- A call to action to extend the Open Source ML sample
- A call to action to extend or enhance the "supporting tools"

### Tooling / Process

#### Windows Machine Prep
(streaming prep / machine learning exploration)

Since a portion of what I'm going to be doing involves a clean machine install of tools, that involve GPU configurations, and re-installing windows over and over again is "lots of fun" I'm using
- WinToUSB Professional : https://www.easyuefi.com/wintousb/comparison.html
- one of these I have laying around, but if it turns out to be too small, i'll upgrade https://www.amazon.com/dp/B079NWJTGG/ref=twister_B079P763J5?_encoding=UTF8&psc=1

this lets me clone my current "bare minimum" windows install to a bootable USB drive, boot from that and work from that at fast speeds (fast as the usb drive will let + data on my SSD raid)
and then blow it away and start over for the next practice run

I clone to the usb drive in .vhdx mode.
- before i start a run i save the .vhdx off to the side
- after the run if i got a good run, i save the before and after .vhdx's along side the video

end result may be a few hundred gigs of windows images, but I can always go back to the environment to re-record if i need to (until I need space)


text:
#Enrichers

Enrichers are Javascript functions that can be used to transform the output of [Resources](Resources) so that they
can be more easily consumed by [Templates](Templates).

SkinnyFE executes Enrichers on the Server Side after it has made the call(s) to resources but before it renders templates.

An enricher has to conform to the following javascript interface :

```
var enrich = function(dataString) { return dataString; }
```

The `dataString` parameter is a string representation of a valid [JSON](http://json.org) object.  Once this object has
been enriched then another string representation of a valid JSON object needs to be passed back.

An example enricher (from [example 4](/Examples#example-4-creating-to-a-resource)) is shown below using the ECMA standard JSON global objects
 `parse` method to deserialise the `dataString` parameter into a JSON object so that it can be manipulated and then
 serialised back using the `stringify` method prior to returning the string representation.

```
var enrich = function(dataString) {
  var data = JSON.parse(dataString);

  data.posts.array.forEach(function(post) {
    post.title = post.title ? post.title.toUpperCase() : "";
    post.author = post.author ? post.author.toUpperCase() : "";
  });

  return JSON.stringify(data);
};
```

##Resource Data

The response to each Resource request is embedded within the dataString, each one is namespaced using the name that
is declared within the Template for that Resource.  So for example, a template with the resource defined as
`<meta property="car" resource="Vehicle" identifier="{{PATH.2}}"/>` will have the response from `Vehicle` placed in a
variable called `car`.

Some metadata about the Resource response, including the response code is also added to the variable under a child
 called `_meta` so our car example would look something like:

```
{
    "car":{
        "make":"FORD",
        "model":"FOCUS",
        "reg":"DN54TRE",
        "_meta":{
            "code":200,
            "reason":""
        }
    }
}
```

##Forcing

Enrichers have a number of functions that they can call to modify the result of the SkinnyFE call.  These are available
through the FORCE global object.

###Response Code
`FORCE.responseCode(number)` changes the response code that is passed back to the caller to be the number parameter.
For example, you may wish to return the same response code as the Resource you are calling serves to you.

```
    force.responseCode(data.car._meta.code);
```

###Template
`FORCE.template(pathToTemplate)` will cause SkinnyFE to load a different Template to render the results to.

!!!NOTE
    This does not load any references to Resources that the new Template will have so you'll need to be careful not
     to force the template to one which requires specific not-loaded values.

The Template's location is resolved using the same rules as when finding a Template based on a URL path.

###Stopping Enrichment
`FORCE.stopEnriching()` will stop SkinnyFE from calling any further Enrichers for that request.  This is useful
when a particular resource has failed that is required by a later Enricher, such as Authentication.

repository: jediq/skinnyFE

repo_name: jediq/skinnyFE


text:
!SLIDE title
# Rack

!SLIDE
# Rack Intro

* ["Rack: a Ruby Webserver Interface"](http://rack.github.io/)
* "...provides a minimal interface between webservers supporting Ruby and Ruby
  frameworks."
* It defines a [protocol](http://rack.rubyforge.org/doc/SPEC.html).
* [Rails on Rack](http://guides.rubyonrails.org/rails_on_rack.html):

> By wrapping HTTP requests and responses in the simplest way possible, it
> unifies and distills the API for web servers, web frameworks, and software in
> between (the so-called middleware) into a single method call.

!SLIDE bullets
# Rack Intro (cont.)

* Most Ruby web frameworks "sit" on Rack.

![request](/images/rack.png)

!SLIDE bullets incremental
# What does Rack get you?

* Request Info
    * Who made the request
    * How the request was made
    * Environment info when the request was made
    * Parsed request headers
    * Request body
* Middleware
* Response Info
    * Status
    * Easy header setting
    * Easy body setting

!SLIDE bullets incremental
# Why should I care?

* It's the core to Rails.

!SLIDE bullets
# In fact, use Rack alone...

* `config.ru`:

    ```ruby
    app = lambda do |env|
      body = "Hello, World!"
      headers = { "Content-Type" => "text/plain", "Content-Length" => body.length.to_s }

      [200, headers, [body]]
    end

    run app
    ```
* Then, run:

    ```bash
    $ rackup --port 3000
    $ curl -v -L http://localhost:3000
    ```

!SLIDE bullets
# Want to define that as a class?

* `config.ru`:

    ```ruby
    class HelloWorld
      def call(env)
        body = "Hello, World!"
        headers = { "Content-Type" => "text/plain", "Content-Length" => body.length.to_s }

        [200, headers, [body]]
      end
    end

    run HelloWorld.new
    ```

!SLIDE bullets
# A Rack App is...

1. A Ruby object (not a class) that responds to `call`.
+ It takes 1 argument: the **environment**.
+ It returns an Array of exactly 3 values:
    * **status**
    * **headers**
    * **body**

!SLIDE incremental
# Notes so far

* "App" can be a method, a block, or a whole lot of anything built on top of
  something that responds to `call`.
* BTW, duck typing here with `call`!
* `Rails::Server` subclasses `Rack::Server` and hooks in to it.
* Using `Rails::Server` is similar to using the `config.ru` file.

!SLIDE bullets
# Multiple Routes/Resources?

* Sure!

    ```ruby
    inspector = proc do |env|
      [200, { 'Content-Type' => 'text/html' }, [env.inspect]]
    end

    noper = proc do |env|
      [404, { 'Content-Type' => 'text/html' }, ['NEWP!!!']]
    end

    builder = Rack::Builder.new do
      map '/' do
        run inspector
      end

      map '/nope' do
        run noper
      end
    end

    run builder
    ```

!SLIDE bullets
# So Far, Summary

* Access environment info.
* Easy-ish to give response status, headers, and body.
* Different functionality per mapped location.

!SLIDE bullets
# Middleware

* Rack-compliant objects that are added into the stack.

    ```ruby
    require 'rack'
    require 'rack/contrib'

    use Rack::Profiler if ENV['RACK_ENV'] == 'development'
    use Rack::Locale
    use Rack::MailExceptions

    class HelloWorld
      def call(env)
        body = "Hello, World!"
        headers = { "Content-Type" => "text/plain", "Content-Length" => body.length.to_s }

        [200, headers, [body]]
      end
    end

    run HelloWorld.new
    ```

!SLIDE bullets
# Our own middleware?

* `cat_checker.rb`

```ruby
require 'open-uri'

class CatChecker
  def initialize(app)
    @app = app
  end

  def call(env)
    status, headers, body = @app.call(env)

    if body.include? 'cat'
      image = open('http://placekitten.com/g/200/300')
      body << image
    end

    [status, headers, body]
  end
end
```

.pull-right ...then...

!SLIDE bullets
# Our own middleware? (cont.)

* `config.ru`

```ruby
require_relative 'cat_checker'

class HelloWorld
  def call(env)
    body = "Hello, World!"
    headers = { "Content-Type" => "text/plain", "Content-Length" => body.length.to_s }

    [200, headers, [body]]
  end
end

use CatChecker

run HelloWorld.new
```

!SLIDE bullets incremental
# Ok, what's all that get me?

* Access to everything in the request.
* Access to everything in the response.
* Ability to do things as a result of attributes of the request.
* Add info to `env` that other middleware or apps can get to.
* Modularity!
    * App does what the app is for.
    * Each middleware has its one responsibility.
* In essence, a tool to build your app around.

!SLIDES bullets incremental
# But...

* It's not geared towards building a web site with, is it?
* Not really--leaves a lot to be desired.
* Can you imagine writing a full-blown web site using this?

!SLIDE center questions
# Questions?

gha_language: Ruby


text:
# creature_text_locale

[<-Back-to:World](database-world.md)

**The \`creature_text_locale\` table**

This table is used to provide to localized clients with localized string for creatures texts.

**Structure**

| Field           | Type       | Attributes | Key | Null | Default | Extra | Comment |
|-----------------|------------|------------|-----|------|---------|-------|---------|
| [CreatureID][1] | MEDIUMINT  | UNSIGNED   | PRI | NO   | 0       |       |         |
| [GroupID][2]    | TINYINT    | UNSIGNED   | PRI | NO   | 0       |       |         |
| [ID][3]         | TINYINT    | UNSIGNED   | PRI | NO   | 0       |       |         |
| [Locale][4]     | VARCHAR(4) |            | PRI | NO   |         |       |         |
| [Text][5]       | TEXT       |            |     | YES  | NULL    |       |         |

[1]: #creatureid
[2]: #groupid
[3]: #id
[4]: #locale
[5]: #text

**Description of the fields**

### CreatureID

This is the [creature\_template.entry](creature_template#entry) to which the script is linked to.

### GroupID

If there is more than one of the same entry (more than one text the creature says), this column is used to choose if it is a random say or an ordered list. If a creature has got more than one say text to be shown in a given order, it must be incremented for each new matching entry (ex. 0, 1, 2, 3...). If there is only one entry or only one group, this value should be 0. If there are multiple groups of texts, this value stays the same within the group while the id increments within the same group.

### ID

Entry for each group of texts. This is the unique identifier when entry (creature) is the same and groupid is unchanged, it must be incremented (ex. 0, 1, 2, 3...). A creature say will be randomly selected from this list based on the groupid it belongs to.

### Locale

It is the language in which you want to make the translation.
You can choose from the following:

| ID | Language |
|----|----------|
| 1  | koKR     |
| 2  | frFR     |
| 3  | deDE     |
| 4  | zhCN     |
| 5  | zhTW     |
| 6  | esES     |
| 7  | esMX     |
| 8  | ruRU     |

### Text

The translated text the creature will say.

repository: azerothcore/wiki

gha_language: CSS

repo_name: azerothcore/wiki


text:
# spotamovie :movie_camera:

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

Connect to the Spotamovie API to get movie recommendations based on your Spotify playlists.

## Spotamovie API

Full documentation available on Apiary: https://jsapi.apiary.io/previews/spotamovie/reference

## :iphone:Spotamovie iOS App

Check out our iOS App

![spotamovie app](./Landing.png)

Github: https://github.com/johnandblue/spotamovieFE

## Tech Stack

**Server**: Node.js / Express

**Databases**: MongoDB, Redis

**Recommendation Engine**: [Raccoon](https://github.com/guymorita/recommendationRaccoon)

**Host**: Heroku

**Testing**: Mocha/Chai/Sinon

**Build Tool**: Travis CI

## APIs consumed

[Spotify](https://developer.spotify.com/web-api/)

[TMDB](https://www.themoviedb.org/documentation/api)

## Recommendation Example

|                     | User 1                   | User 2                   |
| ------------------- | ------------------------ | ------------------------ |
| 📻 **Songs Liked**  | \* "We are the Champions" | \* "We are the Champions" |
|                     | "Imagine"                | "We Built This City"     |
| 🎦 **Movies Liked** | *Star Wars*              | *E.T.*                   |
|                     | *Titanic*                | *Contact*                |
| **Possible Recs**   | *E.T*                    | *Star Wars*              |
|                     | *Contact*                | *Titanic*                |

\* = *Common Liked Song*

## Project Contributors
[Miguel Gimenez](https://github.com/miguelgimenezgimenez)

[Rod Reyes](https://github.com/2rod)

[JC Garcia](https://github.com/johnandblue)

[Varun Agarwal](https://github.com/vavarun)

repository: johnandblue/spotamovie-be

branch_name: refs/heads/development

repo_name: johnandblue/spotamovie-be


text:
# changelog

All notable changes to this project will be documented in this file.

The format is based on [Keep a Changelog][changelog],
and this project adheres to [Semantic Versioning][semver].

## [unreleased]

- configure the project swagger endpoint definition

## [0.4.0] :: 2020-06-24

### added

- add the project deploy job on release workflow

## [0.3.0] :: 2020-06-09

### added

- configure the project definition for distributed tracing

## [0.2.2] :: 2020-05-27

### fixed

- fix release workflow build error

## [0.2.1] :: 2020-05-27

### fixed

- fix release workflow tag error

## [0.2.0] :: 2020-05-26

### added

- configure the project definition for container orchestration

## [0.1.0] :: 2020-05-12

### added

- design and document the project api specification
- configure the project to support containerization

## [0.0.0] :: 2020-04-30

### added

- setup the project webapi and webrpc scaffolding
- configure the project build definition
- design and launch the object model
- design and launch the database context
- design and launch the restful service

[0.4.0]: https://github.com/rvtr/rvtr-svc-booking/tree/0.4.0 '0.4.0'
[0.3.0]: https://github.com/rvtr/rvtr-svc-booking/tree/0.3.0 '0.3.0'
[0.2.2]: https://github.com/rvtr/rvtr-svc-booking/tree/0.2.2 '0.2.2'
[0.2.1]: https://github.com/rvtr/rvtr-svc-booking/tree/0.2.1 '0.2.1'
[0.2.0]: https://github.com/rvtr/rvtr-svc-booking/tree/0.2.0 '0.2.0'
[0.1.0]: https://github.com/rvtr/rvtr-svc-booking/tree/0.1.0 '0.1.0'
[0.0.0]: https://github.com/rvtr/rvtr-svc-booking/tree/0.0.0 '0.0.0'
[changelog]: https://keepachangelog.com/en/1.0.0/ 'keep a changelog'
[semver]: https://semver.org/spec/v2.0.0.html 'semantic versioning'
[unreleased]: https://github.com/rvtr/rvtr-svc-booking/tree/main 'unreleased'

repository: Revature-Squares/rvtrx-api-booking

repo_name: Revature-Squares/rvtrx-api-booking


text:
# cloudinary-watson

## LAB 1
Content Assistant:

A swift mobile app (or TJ Bot) might become a chatbot - a robot content assistant for picture search -
ask verbally the app (or TJ BOT) for a picture - then the chatbot would search the Cloudinary API for images,
and post links to pictures - you can choose the picture for your article:
"Search for San Francisco"  "Add mono filter" "add square transformation"   "Show me a bay bridge in San Francisco."
The app would post the image links to Slack channel to manipulate the links to images.

## LAB 2
Photographer’s Assistant:

smart photography - Watson advising on taking a greater picture thru smart recommendations.
-- Watson Training Models for analysis with Cloudinary
-- the Android Selfie / photo app that provide feedback (on the typical picture mistakes)

Delivered to you by Cloudinary and IBM

Subscribe to our Twitter: @filmfestnow and @blumareks

## Slides
https://www.slideshare.net/DanZeitman/become-a-photo-pro-with-ai-and-deep-learning
Note: You can dive deeper into each slide's topic by following the source links in the upper right corner.

## Upload Widget Example
https://codepen.io/dzeitman/pen/EwgjJV/

## Rules to live by
http://www.techradar.com/how-to/photography-video-capture/cameras/10-rules-of-photo-composition-and-why-they-work-1320770#

repository: blumareks/cloudinary-watson

repo_name: blumareks/cloudinary-watson


text:
# tensorflow-yolo-v3

Implementation of YOLO v3 object detector in Tensorflow (TF-Slim). Full tutorial can be found [here](https://medium.com/@pawekapica_31302/implementing-yolo-v3-in-tensorflow-tf-slim-c3c55ff59dbe).

Tested on Python 3.5, Tensorflow 1.8.0 on Ubuntu 16.04.

## Todo list:
- [x] YOLO v3 architecture
- [x] Basic working demo
- [ ] Weights converter (util for exporting loaded COCO weights as TF checkpoint)
- [ ] Training pipeline
- [ ] More backends


text:
# Calocybe carnea (Bull.) Donk, 1962 SPECIES

#### Status
ACCEPTED

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

#### Published in
Nova Hedwigia, Beih. 5: 42 (1962)

#### Original name
Agaricus carneus Bull., 1792

### Remarks
null

repository: mdoering/backbone

repo_name: mdoering/backbone


text:
# Oncient Language

A Open-source Programming Language written in Python by testingacc333330

# Example Code

In demo.ols, It contains stuff that the language can do. It can't do very much code but its just a example.

# How to use the language

First, You need to open cmd.

There is two ways of doing that, One is doing the Windows key + R and the other is just searching cmd on the search bar.

Once you open cmd, Select a directory with a ols or any type of text file containing stuff that is compatible with Oncient, And Type in: `python3 basic.py [FILENAME]` (replace filename with the script's name. must also include a ols type or text type.

# Known bugs

The last letter in a print gets deleted by a print fix function.

gha_language: Python


text:
# Inform with xMatters for the ServiceNow integration
This is part of the xMatters Labs awesome listing. For others, see [here](https://github.com/xmatters/xMatters-Labs)

The [xMatters integration for ServiceNow](https://store.servicenow.com/sn_appstore_store.do#!/store/application/5950d7444f2231000e9fa88ca310c78c) provides a several find and assign workflows for tracking down responsible parties for an Incident. However, there are cases where the need for informing other people about an Incident or providing updates regarding an Incident are important. This is where Inform with xMatters comes in. It does not target any users and instead relies on [subscriptions](http://help.xmatters.com/OnDemand/user/subscriptions.htm) to determine who wants to be notified.

---------

---------

# Pre-Requisites
* ServiceNow Helsinki, Istanbul or Jakarta
* ServiceNow integration to [xMatters v3.7.11+](https://store.servicenow.com/sn_appstore_store.do#!/store/application/5950d7444f2231000e9fa88ca310c78c/3.7.12)
* xMatters account - If you don't have one, [get one](https://www.xmatters.com)!

# Files
* [ServiceNowInformwithxMatters.zip](ServiceNowInformwithxMatters.zip) - Communications Plan file. This contains all of the out of box ServiceNow forms, in addition to the Inform with xMatters form.
* [Inform with xMatters - for SN 3.7.1.xml](https://raw.githubusercontent.com/xmatters/xm-labs-snow-inform/master/Inform%20with%20xMatters%20-%20for%20SN%203.7.1.xml) - Update set containing the ServiceNow artifacts for enabling the Inform with xMatters functionality. **Note**: Right click > Save As.. the link to download the file as an XML file.

# Installation
Login to ServiceNow and navigate to Retrieved Update Sets. Click the `Import Update Set from XML` link at the bottom and point to the [Inform with xMatters - for SN 3.7.1.xml](https://raw.githubusercontent.com/xmatters/xm-labs-snow-inform/master/Inform%20with%20xMatters%20-%20for%20SN%203.7.1.xml). Preview the update set and commit. This is all net new records so there should not be any files overwritten.

Login to xMatters and import the [ServiceNowInformwithxMatters.zip](ServiceNowInformwithxMatters.zip) file. This contains a new comm plan called `ServiceNow - Inform with xMatters` and contains the Integration Builder script, form and properties for sending these notifications.

## Configure ServiceNow
Login to ServiceNow and expand the "Integration - xMatters" menu item. In the Configuration section, there is a new entry for "Inform Configuration":

| Item | Description |
| ----- | ----- |
| Inform with xMatters Form Endpoint | The **Integration Builder endpoint** for the "Inform with xMatters" inbound integration url |
| Available Locations | Semicolon separated list of locations to make available for selection |
| UUID for affected locations | Not used |
| Available Services | Semicolon separated list of services to make available for selection |
| UUID for affected services | Not used |

The Available Services and Available Locations values in the config page above will need to match what is available in the "affected_services" and "affected_locations" properties in the `ServiceNow - Inform with xMatters` comm plan in xMatters. Here:

## Configure xMatters
Make sure the `affected_locations` and the `affected_services` properties have been updated to contain the same entries as listed in the Inform with xMatters configuration page in ServiceNow.

Create a subscription panel called Inform with xMatters and set the scope to only Inform with xMatters:

Then create the actual subscription records for the users who wish to be notified.

# Testing
Login to ServiceNow and find an open Incident. There will be a new button called "Inform with xMatters". Push it and the Inform dialog will be displayed:

Populate all the relevant info and hit Submit. A helpful message will let you know you've done it successfully.

And the email will come through:

# Troubleshooting
If the events are not making it into xMatters, then check out the System Logs in ServiceNow for any error messages. The Inform with xMatters workflow uses the same logging setting as the Incident workflow, so update the Logging setting in the main xMatters Configuration page to get more or less detail.

If the events are making it into xMatters, review the Event logs to determine if any Subscription criteria were met. If not, make sure the subscription record was created for the appropriate user. If so, make sure the user's devices are all configured correctly.

repository: xmatters/xm-labs-snow-inform

repo_name: xmatters/xm-labs-snow-inform


text:
# Newsletter Deployment Tool

To use the deployment tool with your `@base-cms/marko-newsletters` project, include and modify (as appropriate) the files in the `templates` directory at the root of your project.

## Dockerfile

The `Dockerfile` defines the production build process for your project. No modifications to this file should be necessary.

## .travis.yml

The `.travis.tml` defines how your project should be deployed. Copy this file to your project, and update the deployment commands to deploy each tenant. You **must** include both the `production` and `staging` definition for each tenant, if you would like it to deploy to both stacks.

Ensure that you replace all references to `TENANT_*` with the appropriate values for your tenant.

repository: base-cms/base-cms

repo_name: base-cms/base-cms


text:
# Akkatecture Jobs Sample

The akkatecture job sample is the most "hello world" way of doing a scheduled and persistent job.

# Akkatecture.Examples.Jobs

This is the model of the job same which models a basic repeat trigger using `ScheduleRepeatedly<,>`.

### Model
* **PrintJob** - Command that describes the job of printing to console.
* **PrintJobId** - The identifier for the print job.
* **PrintJobResponses** - Message types that are used to describe scheduler success or failure.
* **PrintJobRunner** - The actor which handles the job (`PrintJob`).
* **PrintJobScheduler** - The actor responsible for persisting and scheduling jobs to be triggered and sent to the job runner.

# Akkatecture.Examples.JobApplication

This is the console application that creates the actor system and interfaces with it. First a job manager is created, this job manager is responsible for supervising and creating the job scheduler and job runner actors beneath it, it is also responsible for routing messages between these two actors. Following that, a job is sent to be scheduled to the job scheduler (via the job manager). And then for every 10 seconds a log will be printed to the console showing the job being triggered.

### Description

This sample shows how to print a log statement every 10 seconds that is scheduled by a persisted scheduled job. As configured by the configuration item `akkatecture.job-scheduler.tick-interval = 500ms`, the scheduler will poll itself for any new jobs to be triggered. If a new job is to be trigger, the scheduler will send the job command to the job runner via the parent (`JobManager`). The job manager receives this message and then processes it like any other akka actor would.

repository: malclear/Akkatecture

branch_name: refs/heads/dev

gha_language: C#

repo_name: malclear/Akkatecture


text:
# Greatlearning AI & ML
Source code, resources and projects as part of Great Learning's PGP - Artificial Intelligence and Machine Learning

## Index
- [Foundations](#foundations)
- [Machine Learning](#machine-learning)
- [Artificial Intelligence](#artificial-intelligence)
- [Additional Modules](#additional-modules)

## Foundations
The Foundations block comprises of two courses where we get our hands dirty with Statistics and Code, head-on. These two courses set our foundations so that we sail through the rest of the journey with minimal hindrance.
| Index | Status |
| :-: | :-: |
| Python for AI & ML | |
| Applied Statistics | |

## Machine Learning
The ML block will teach us Machine Learning techniques and all the popularly used in Classical ML algorithms that fall in each of the categories.
| Index | Status |
| :-: | :-: |
| Supervised Learning | |
| Unsupervised Learning | |
| Ensemble Techniques | |
| Featurization, Model Selection & Tuning | |
| Recommendation Systems | |

## Artificial Intelligence
The AI block will take us beyond the traditional ML into the realm of Neural Nets. From the regular tabular data we move on to training our models with Unstructured Data like Text and Images.
| Index | Status |
| :-: | :-: |
| Neural Networks | |
| Computer Vision | |
| Natural Language Processing | |

## Additional Modules
| Index | Status |
| :-: | :-: |
| EDA | |
| Time Series Forecasting | |
| Pre Work for Deep Learning | |
| Model Deployment | |
| Visualization using Tensor board | |
| GANs (Generative Adversarial Networks) | |
| Reinforcement Learning | |

repository: tejeshreddy/greatlearning-aiml

repo_name: tejeshreddy/greatlearning-aiml


text:
GmailCleaner
============

Script to clean a flooded gmail mailbox

## Background

In order to empty a flooded gmail box, I needed a script that would
connect to Google Gmail API and trigger targets-based deletions.

The best tool for the job would be a server-to-server script but I did not succeed
to use the server-to-server Gmail API ; some issue with an ssl-related lib.

So I made a in-browser web app for that and it works quite cool.

In "API > API" panel enable the Gmail API.

In "API > credentials" panel, create a OAuth Key for web application. It will require
a loading screen configuration, fill it.

__Important__: configure a redirect URL, for example "http://fr.gmail.clean.com/clean.php".

### Get your Google API Key

Download the json key file from the "API > credentials" panel on https://console.developers.google.com.

Copy it in `config/auth/`.

### Install in-browser GmailCleaner app

Install dependencies with composer
```bash
$ php composer.phar install
```

Prepare a `config/parameters.yml` file to configure your GmailCleaner.

```bash
$ cp config/parameters.yml dist config/parameter.yml
```

Fill in the following parameters:
  * google_api_key: the name of your json file
  * from: lower time limit for the messages to delete selection
  * to: upper time limit for the messages to delete selection

Setup a web server to allow local browser usage.
You must configure it to serve the redirect URL you configured (e.g. "http://fr.gmail.clean.com/clean.php").

## Usage

Load the web page clean.php using the path you defined (ex: "http://fr.gmail.clean.com/clean.php"), you should see:

___

___

Click on "connect", select your gmail account and the script will delete 1000
gmail messages which match the given time limits.

repository: matks/GmailCleaner

repo_name: matks/GmailCleaner


text:
# Parthenopeddit-Desktop

<img src="https://github.com/marcosautto/Parthenopeddit-Desktop/blob/master/src/main/resources/img/Parthenopeddit_logo.png" height="100">

Parthenopeddit is a platform where students of Università degli Studi di Napoli Parthenope can meet.
This app uses Esse3 API (Esse3 is a hub from Cineca) so students can login with their credentials
without requiring a registration.

## Getting Started

* Have a running instance of [Parthenopeddit API](https://github.com/GruppoProgettoTMM201920-Parthenopeddit/RESTPlusAPI)
* Clone or download [this repository](https://github.com/marcosautto/Parthenopeddit-Desktop)
* On IntelliJ IDEA, build project

### Prerequisites
```
A server running the Parthenopeddit API
Java 11
IntelliJ IDEA
```
## Built With

* [ControlsFX](https://github.com/controlsfx/controlsfx) - Additional JavaFX components, as RatingBar
* [Maven](https://maven.apache.org/) - Dependency Management
* [JFoenix](https://github.com/jfoenixadmin/JFoenix) - Material Design JavaFX components
* [GSON](https://github.com/google/gson) - Deserializing/Serializing JSON strings

## Authors

* **Marco Sautto**  - [GitHub](https://github.com/MarcoSautto)

## With help of

* **Francesco Bottino**  - [GitHub](https://github.com/FrancescoBottino)

## License

This project is licensed under the Apache License, Version 2.0.

## Google Slides

[Meet Parthenopeddit Desktop](https://docs.google.com/presentation/d/1GT5Si1SHebzKtlW6Tqxi1zTFDo_lzHHsjueMD3hZDTw/edit#slide=id.p)

## Parthenopeddit Android

[Parthenopeddit is also available on Android](https://github.com/GruppoProgettoTMM201920-Parthenopeddit/AndroidAPP)

[Meet Parthenopeddit Android](https://docs.google.com/presentation/d/1dtrFvwjBepCGeagHdioocrLYIhkDcRJfmuVpJrPYFAU/edit#slide=id.p)

repository: marcosautto/Parthenopeddit-Desktop

repo_name: marcosautto/Parthenopeddit-Desktop


text:
# Online Judge Connector

This is a template project to facilitate the implementation of a new Online Judge Connector following the Online Judge Integration Protocol (OJIP)

You will need to implement the following HTTP routes:

**Pay attention for the format of the requests return**

Request:
Returns a list with all the available problems.

```
GET /problems
```

Response:

```json
[{
  "id": "{connectorName}_{problemId}",
  "name": "string",
  "level": "number",
  "topics": ["string"]
}]
```

Request:

Returns the user requested or Not Found and a custom error message if it does not exists.

```
GET /users/:user
```

Response:

```json
{
  "name": "string",
  "level": "number"
}
```

**Note that it is crucial to mantain the problems levels and the users levels in the same scale**

Request:

```
GET /users/:user/submissions
```

Response:

```json
[{
  "problemId": "{connectorName}_{problemId}",
  "momentInSeconds": "long",
  "verdict": "enumeration of (SOLVED, TRIED)"
}]
```

repository: gugabribeiro/online-judge-connector

repo_name: gugabribeiro/online-judge-connector


text:
# ML Volatility
It is a repository with all the code and documentation for the scientific work
related to the volatility modeling using ML methods. The project is under development,
and the documentation will be available later.

#### Installation:

- Download and install Anaconda from the following URL:

https://www.anaconda.com/distribution/

Save the path to the installed Anaconda (_path_to_Anaconda_).

- Clone the repository and switch to the tag <tag_name>, using the following command:

`git clone --progress --branch <tag_name> -v "https://github.com/JacobGrig/ML-volatility" _desired_folder_`

- If you use Windows, open Anaconda Prompt, if Linux, use the following command:

`source _path_to_Anaconda_/bin/activate`

- Install _gcc_ (if you have not got it on your computer, only for Linux).

- Create _volatility_ environment by executing the following command:

`conda create --name volatility python=3.9.1`

- Switch to this environment, using the following command:

`conda activate volatility`

- Then go to _desired_folder/ml_volatility_ and execute the following command,
which installs _ml_volatility_ package and updates _volatility_ environment:

`python python_env_install.py update all`

(instead of the parameter `all` you can also use `packages` to update separately _volatility_ environment,
or `products` to install separately _ml_volatility_ package).

#### Usage:

- You can run the program, using the following command in Anaconda Prompt:

`ml_volatility run`

and the results will be stored in the folder
_desired_folder/ml_volatility/ml_volatility/data_.

repository: JacobGrig/ML-volatility

repo_name: JacobGrig/ML-volatility


text:
# AllenNLP

* what ?
   * An Apache 2.0 NLP research library, built on PyTorch, for developing state-of-the-art deep learning models on a wide variety of linguistic tasks.

* why ?
   * can do a lot of nlp topics: https://allennlp.org/models

# how to install

```
conda create -n allennlp python=3.6
source activate allennlp
pip install allennlp
```

# Demo

* [NER by biLSTM with CRF layer and ELMo embeddingstrained on the CoNLL-2003 NER dataset 2018](ner_basic.py)
* [fact predict by trained decomposable attention model 2017](fact_predict.py)

repository: ybdesire/machinelearning

gha_language: Jupyter Notebook

repo_name: ybdesire/machinelearning


text:
![sitemap](site-map.png)

**What are the 6 Phases of Web Design?**
*Information Gathering,
Planning,
Design,
Development,
Testing and Delivery, and
Maintenance*

**What is your site's primary goal or purpose? What kind of content will your site feature?**
*This will serve as my professional website, a space to display my background/story, blog, projects, employment details, contact information.*

**What is your target audience's interests and how do you see your site addressing them?**
*My target audience would be any interested in software development and design, prospective employers, and my fellow developers!*

**What is the primary "action" the user should take when coming to your site? Do you want them to search for information, contact you, or see your portfolio? It's ok to have several actions at once, or different actions for different kinds of visitors.**
*I think the main function would be to read about me, browse some of my works/display my skillset, provide contact information, provide resume for employers.

**What are the main things someone should know about design and user experience?**
*1. Design is not "One Size Fits All."
2. User experience isn't the same thing as usability.
3. User expereince design can not be quanatatively measured.*

**What is user experience design and why is it valuable?**
*User experience design is all about how someone feels when interfacing with a system. This is usually in reference to some sort of human-computer interaction. User Experience Design is important because it can help you determine the best ways to approach accessability, usability, and navigation.*

**Which parts of the challenge did you find tedious?**
*I didn't find any part of this assignment to be tedious. Every chance at navigating the command line, git, is welcome. Additionally, I learned a bit about markdown in this assigment.*


text:
---
layout: post
title: Inflation
excerpt: "We take inflation for granted. We relate it with growing economies, and..."
tags: [economics, bitcoin, inflation]
comments: true
canonical_url: 'https://www.abhinav.co/inflation'
---
We take inflation for granted. We relate it with growing economies, and we see zero inflation and deflation as a sign of stagnating or shrinking economies.

Inflation in elementary terms is sustained increase in price level of goods over a period of time. For example, last year, if one could buy 1 kg of apples in 100 rupees, and now if they cost 110 rupees, simplistically speaking, inflation in apple prices is around 10%.

Prices are usually decided by demand and supply equilibrium, and it is quite natural to believe that price inflation happens because of increase in demand which also indicates growth.

However, inflation can also increase if currency starts loosing its value. And when does that happen - when government start printing more currency than it really should. It helps in the short term, however in today's globalized world, it has a big negative impact in the longer term.

This is what distinguish money from currency. Money has the ability to preserve its value over the longer term, that is, unlike money, a currency is subject to inflation.

One a related note, this is the reason Satoshi Nakamoto designed Bitcoin to have a cap. I will write more on Bitcoin in later posts.


text:
# προσ-λαμβάνω.

<!-- Status: S2=NeedsReview -->
<!-- Lexica used for edits: BDAG, FFM, LN, A-S -->

## Word data

* Strongs: G43550.

* Alternate spellings:

,

* Principle Parts:

* Part of speech:

[Verb](http://ugg.readthedocs.io/en/latest/verb.html).

* Instances in the New Testament: 12.

* All Scriptures cited: Yes

## Etymology:

* LXX/Hebrew glosses:

in LXX: [Ps 117 (18):16](Psa 18:16) ([משׁה](//en-uhl/H4871) hi.), [Ps 72 (73):24](Psa 73:24) ([לקח](//en-uhl/H3947)), etc.;

* Time Period/Ancient Authors:

* Related words:

* Antonyms for all senses

* Synonyms for all senses:

## Senses:

### Sense  1.0:

#### Definition:

to take or bring along with oneself

#### Glosses:

to take or bring along with oneself

#### Explanation:

#### Citations:

to take in addition. to take to oneself, take, receive; in NT always mid., [-ομαι](); of persons: c. acc., [Mt 16:22](Mat 16:22), [Mk 8:[3](Rom 14:3)2](Mrk 8:32) (v. Swete, in l.), [Ac 17:5](Act 17:5) [18:26](Act 18:26) [28:2](Act 28:2), [Ro 14:1](Rom 14:1), 3 [15:7](Rom 15:7), [Phm 17](Phm 1:17).

### Sense  2.0:

#### Definition:

to accept, welcome, receive (to extend hospitality)

#### Glosses:

to accept, welcome, receive

#### Explanation:

#### Citations:

to take in addition. to take to oneself, take, receive; in NT always mid., [-ομαι](); of persons: c. acc., [Mt 16:22](Mat 16:22), [Mk 8:[3](Rom 14:3)2](Mrk 8:32) (v. Swete, in l.), [Ac 17:5](Act 17:5) [18:26](Act 18:26) [28:2](Act 28:2), [Ro 14:1](Rom 14:1), 3 [15:7](Rom 15:7), [Phm 17](Phm 1:17).

### Sense  3.0:

#### Definition:

to take aside, take hold of, lead aside

#### Glosses:

to take aside, take hold of, lead aside

#### Explanation:

#### Citations:

to take in addition. to take to oneself, take, receive; in NT always mid., [-ομαι](); of persons: c. acc., [Mt 16:22](Mat 16:22), [Mk 8:[3](Rom 14:3)2](Mrk 8:32) (v. Swete, in l.), [Ac 17:5](Act 17:5) [18:26](Act 18:26) [28:2](Act 28:2), [Ro 14:1](Rom 14:1), 3 [15:7](Rom 15:7), [Phm 17](Phm 1:17).

### Sense  4.0:

#### Definition:

to take, partake of

#### Glosses:

to take, partake of

#### Explanation:

#### Citations:

to take in addition. to take to oneself, take, receive; in NT always mid., [-ομαι](); of things: of food, c. acc., [Ac 27:33](Act 27:33); c. gen. part., [Ac 27:36](Act 27:36);†

repository: mandolyte/uw-obsidian

repo_name: mandolyte/uw-obsidian


text:
# Contributing Guidelines

Welcome to the cookbook! Before sending the PRs, please read the guidelines!

## Contributing

Please, take care of the following points:

1. No plagiarism allowed, but
    - You're allowed to take inspiration from other codes
    - You're allowed to refer to sources for knowledge and implementation
2. Your work will be distributed under the [MIT License](LICENSE) as well
3. You should follow the coding guidelines

If you violate any of these, your code will not get merged!

## Coding Style

We primarily follow `C++17` throughout the codebase. Try to stick to it, but, a hiccups here and there are allowed.

More or less, follow these:

```
1. Follow C++17 wherever possible

2. Use 4 spaces for indentation (no tabs vs space wars please)

3. Try to keep 80 characters per line, can be overlooked for readability

4. When using `enum` or `enum class`, last element should be followed by a comma, eg:

    enum class Color {
        red,
        blue,
        black,
    };

5. Prefer `enum class` over `enum`

6. Prefer `struct` over `class`

7. Use constructor instead of designated initialisers for structs

8. Use designated initialisers instead of separate statements in array type objects, eg:

use,

    int dp[MAX_NUM] = { [0] = 1};

instead of

    int dp[MAX_NUM];
    dp[0] = 1;

wherever possible.

9. Use `nullptr` instead of `NULL` or `0`

10. Follow west-style,

use

    const char* name

instead of

    const char *name

11. Use whitespace around operators and keywords, but not inside parentheses and not around functions. So:

    while (condition)
        foo(bar + 1);

not

    while( condition )
        foo (bar+1);

12. Do not explicitly compare an integral value with constant 0 or '\0', or a pointer value with constant NULL. For instance, to validate that counted array <ptr, cnt> is initialized but has no elements, write:

    if (!ptr || cnt)
        cerr << "empty array expected\n";

and not:

    if (ptr == NULL || cnt != 0);
        cerr << "empty array expected\n";

13. Avoid using braces unnecessarily. I.e.

    if (cond) {
        x = 1;
    }

should be avoided, unless it makes code more readable or informative.

14. Explain smart code! Commenting is necessary. Use the following scheme

    // This is a single line comment; use to draw attention to necessary element that may get overlooked often-a-times

    /*
     * Multiline comment to explain a otherwise
     * hard to understand concept or algorithm.
     */

15. Follow Egyptian style brackets!

    if (cond) {
        /*
         * Long lines of code
         */
    }

instead of

    if (cond)
    {
        /*
         * Long lines of code
         */
    }

or other styles.
```

These guidelines are taken from [git](https://github.com/git/git/blob/master/Documentation/CodingGuidelines).


text:
# Ant-Colony
Swarm Intelligence (AI)

Evolutionary algorithms derived from the ant colony algorithm are a subset of the "Swarm Intelligence" methods.
These methods are the field of research and study that studies the algorithms inspired by the concept of "Swarm Behaviors".
Crowded intelligence algorithms consist of a set of simple individual entities that interact with each other through "self-organizing."
Self-organization means the lack of a central control system to control and coordinate the members of a crowded intelligence system.

Applications of the ant colony algorithm:

Optimizing routing in computer networks-

Job-Scheduling Problems Optimization Strategies-

Optimizing vehicle routing-

Image Processing-

Issues of optimizing device size in the physical design of nanoelectronic devices-

Antenna shape optimization (for example in RF-ID tags)-

Classification-

and Data Mining.

In this repository we use ACO to optimize 4 famous problems including TSP, Binary Knapsack, Integer Knapsack and Quadratic Assignment Problem.
comments within codes is been provided line by line.

![ACo gif](https://github.com/HamedMoasses/Ant-Colony/blob/master/Ant-Colony-Optimizatin-Figure-012.gif)

repository: HamedMoasses/Ant-Colony

repo_name: HamedMoasses/Ant-Colony


text:
# passport-firebase-jwt

Based on [passport-jwt](https://github.com/mikenicholson/passport-jwt)

A [Passport](http://passportjs.org/) strategy to authenticate with Firebase Auth.

This module lets you authenticate endpoints when using Firebase Auth in a Node.js application.

## Install

    npm install passport-firebase-jwt

## Usage

NestJS TypeScript usage example:

Strategy name is: `firebase-jwt`.

#### index.ts
Make sure firebase is initialized before starting NestJs
```ts
import { credential, initializeApp } from 'firebase-admin';
import * as express from 'express';
import * as serviceAccount from './serviceAccountKey.json';

const config = {
    apiKey: '***',
    authDomain: '***.firebaseapp.com',
    databaseURL: 'https://***.firebaseio.com',
    projectId: '***',
    storageBucket: '***.appspot.com',
    messagingSenderId: '***',
    credential: credential.cert(***)
};
initializeApp(config);
```

#### firebase-auth.strategy.ts
```ts
import { PassportStrategy } from '@nestjs/passport';
import { Injectable, UnauthorizedException } from '@nestjs/common';
import { Strategy, ExtractJwt } from 'passport-firebase-jwt';
import { auth } from 'firebase-admin';

@Injectable()
export class FirebaseAuthStrategy extends PassportStrategy(Strategy) {

    constructor() {
        super({
            jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken()
        });
    }

    validate(token) {
        return auth()
            .verifyIdToken(token, true)
            .catch((err) => {
                console.log(err);
                throw new UnauthorizedException();
            });
    }
}
```

#### auth.module.ts
```ts
import { Module } from '@nestjs/common';
import { PassportModule } from '@nestjs/passport';
import { FirebaseAuthStrategy } from './firebase-auth.strategy';

@Module({
    imports: [
        PassportModule.register({ defaultStrategy: 'firebase-jwt' })
    ],
    providers: [
        FirebaseAuthStrategy
    ],
    exports: [
        PassportModule
    ]
})
export class AuthModule {}
```

### Extracting the JWT from the request

There are a number of ways the JWT may be included in a request.  In order to remain as flexible as
possible the JWT is parsed from the request by a user-supplied callback passed in as the
`jwtFromRequest` parameter.  This callback, from now on referred to as an extractor,
accepts a request object as an argument and returns the encoded JWT string or *null*.

#### Included extractors

A number of extractor factory functions are provided in passport-jwt.ExtractJwt. These factory
functions return a new extractor configured with the given parameters.

* ```fromHeader(header_name)``` creates a new extractor that looks for the JWT in the given http
  header
* ```fromBodyField(field_name)``` creates a new extractor that looks for the JWT in the given body
  field.  You must have a body parser configured in order to use this method.
* ```fromUrlQueryParameter(param_name)``` creates a new extractor that looks for the JWT in the given
  URL query parameter.
* ```fromAuthHeaderWithScheme(auth_scheme)``` creates a new extractor that looks for the JWT in the
  authorization header, expecting the scheme to match auth_scheme.
* ```fromAuthHeaderAsBearerToken()``` creates a new extractor that looks for the JWT in the authorization header
  with the scheme 'bearer'
* ```fromExtractors([array of extractor functions])``` creates a new extractor using an array of
  extractors provided. Each extractor is attempted in order until one returns a token.


text:
---
layout: post
title: Unpacking Android APK Files
categories: [Programming, Reverse, Engineering]
tags: [Android, APK, OBB, File, Unpacking, Bash]
---

  All Android apps come in one basic format: the *APK*, or *Android Package Kit*. Similar to an *EXE* file on windows, when you press install on the Google Store, the *APK* is downloaded onto your phone, and installed. It follows that, by downloading it instead onto your computer, you could theoretically open it, and be able to look around and see all the files that the creator made.

 To start with, we will need to download the actual *APK* file to our desktop. There are a variety of extensions for doing this that exist for Chrome, and all of them function pretty much exactly the same. For our task, I used [this one.](https://chrome.google.com/webstore/detail/apk-downloader/idkigghdjmipnppaeahkpcoaiphjdccm?hl=en)

 Put in the URL to the Google Store page, generate the link, and download the *APK*. If one exists, choose to also download the *OBB*, or *Opaque Binary Blob*  as well. It typically stores large files such as graphics, models, and sounds.

 Now that you have acquired all the necessary files, we can begin the most enjoyable part of reverse engineering. Thankfully, both *APK* and *OBB* files use standard zip compression, meaning it is a trivial matter to click on them, rename the extension to ".zip", and extract. However--doing so is tedious, and is prone to human error due to the large amount of actions you need to perform each time.

 As such, it becomes necessary to automate the process. Having made a personal working directory in my home folder with the application files in it, I wrote a few bash scripts to help speed up the process of reverse engineering. Feel free to design your own folder layout, and modify the scripts to suit your preferences:

 Reset working directory and create brand new folder structures for revers engineering:
```bash
#!/bin/bash
set -xe
POS=$HOME/<Your_Working_Directory>
rm -r -f $POS/apk
mkdir $POS/apk
mkdir $POS/apk/patch
mkdir $POS/apk/patch/jar
mkdir $POS/apk/patch/java
mkdir $POS/apk/source
mkdir $POS/apk/finished
```

 Copy the *APK* and *OBB* files from the working directory to the source code folder to be unzipped:
```bash
#!/bin/bash
set -xe
POS=$HOME/<Your_Working_Directory>
cp -f $POS/evil-app.apk $POS/apk/source
cp -f $POS/evil-app.obb $POS/apk/source
```

 Fully unpack the *APK* and *OBB* to acquire all application files:
```bash
#!/bin/bash
set -xe
POS=$HOME/<Your_Working_Directory>/apk/source
unzip $POS/evil-app.apk -d $POS
unzip $POS/evil-app.obb -d $POS
rm $POS/evil-app.apk
rm $POS/evil-app.obb
```

 Congratulations!  As an example, you can go into the working directory, and use the `find` command to search for various file extensions:

```bash
$ find apk/source/ -name '*.so'
apk/source/lib/x86/libevil.so
apk/source/lib/x86/libunity.so
apk/source/lib/x86/libmono.so
apk/source/lib/armeabi-v7a/libevil.so
apk/source/lib/armeabi-v7a/libunity.so
apk/source/lib/armeabi-v7a/libmono.so

$ find apk/source/ -name '*.dex'
apk/source/classes.dex
apk/source/classes2.dex

$ find apk/source/ -name '*.dll'
apk/source/assets/bin/Data/Managed/mscorlib.dll
apk/source/assets/bin/Data/Managed/Assembly-Sharp.dll
...

```
 From the results, we can immediately see that our application uses native code (.so), Java (.dex), and C Sharp (.dll). While at first glance the amount of files may seem daunting, the steps needed to reverse engineer each are simple and straightforward, and I will make sure to go over in detail exactly what needs to be done.


text:
---
title: "ZigZag Conversion"
tags: [LeetCode, Python3]
categories: LeetCode
---

## From LeetCode
[problem description](https://leetcode.com/problems/zigzag-conversion/description/)
/
[solution](https://leetcode.com/problems/zigzag-conversion/solution/#approach-2-visit-by-row)

## Solution in Python3
```python
class Solution:
    def convert(self, s, numRows):
        """
        :type s: str
        :type numRows: int
        :rtype: str
        """
        if numRows == 1:
            return s
        zigzag = ''
        cycle_len = 2 * numRows - 2

        # Each cycle has at most 2 characters in row r.
        # i denotes index of the first character and
        # j denotes index of the second one.
        for r in range(numRows):
            for i in range(r, len(s), cycle_len):
                zigzag += s[i]
                if r != 0 and r != numRows - 1:
                    j = i + cycle_len - 2 * r
                    if j < len(s):
                        zigzag += s[j]

        return zigzag
```
I am lucky to get
> Runtime: **100 ms**, faster than **98.97%** of Python3 online submissions for ZigZag Conversion.

This is not staightforward as the variant.

### Time Complexity
$$O(l)$$, where $$l$$ is the length of `s`.

## Variants

### Iterate through `s`
Make a list of strings, one for each row. Append each charater in `s` to proper string. [sample1](https://leetcode.com/problems/zigzag-conversion/solution/#approach-1-sort-by-row) [sample2](https://www.geeksforgeeks.org/print-concatenation-of-zig-zag-string-form-in-n-rows/)


text:
# BuddyPress Security Check

* __Tested up to:__ WordPress 3.7.1
* __Stable version:__ [1.1](http://downloads.wordpress.org/plugin/bp-security-check.latest-stable.zip)
* __License:__ [MIT](http://opensource.org/licenses/MIT)

Help combat spam registrations by forcing the user to answer a simple math sum while registering for your BuddyPress-powered site

## Description

This plugin will add a field to the BuddyPress registration form where the user will need to answer simple math sum before registering. This is an effort to stop spam bots from registering on your site. The math sum will be composed of adding or subtracting two random numbers between 0 and 10 (inclusive).

You can learn more at the [plugin's website](http://bungeshea.com/plugins/bp-security-check/), or on [WordPress.org](http://wordpress.org/plugins/bp-security-check)

## Installation

This plugin extends the functionality of [BuddyPress](http://wordpress.org/extend/plugins/buddypress), which must be installed for this plugin to work

1. Upload `bp-security-check.php` to the `/wp-content/plugins/` directory
2. Activate the plugin through the __(Plugins > Installed Plugins)__ menu in WordPress
3. Done! The plugin has no settings to configure, just install and activate

## Changelog

### 1.0.1
* Remove buggy multiplication and division functionality

### 1.0
* Stable version release

repository: moggedb/bp-security-check

repo_name: moggedb/bp-security-check


text:
# befunge
_A Befunge interpreter for the browser_

## Setup

Run:
```
npm install
npm start
```

## Examples

A lot of example programs can be found in the [`__tests__/cases/programs`](__tests__/cases/programs) folder.

## Other interpreters

http://www.quirkster.com/iano/js/befunge.html
https://rosettacode.org/wiki/Category:Befunge

repository: joeyciechanowicz/befunge

gha_language: TypeScript

repo_name: joeyciechanowicz/befunge


text:
# react-portfolio
[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
built with React and material-ui

## Installation
```
npm install
```

## Contributors
* [David Murdoch](https://github.com/dsm23)