text:
## Node + Stripe + Express

This is a template for you to use in your own project for processing one time charges. Follow the directions below for getting started quickly. You will obviously want to customize this template to meet your needs.

## quick start

1. Clone:

    ```sh
    $ git clone git@github.com:mjhea0/node-stripe-template.git your_app
    ```

2. Install dependencies:

    ```sh
    $ cd your_app
    $ npm install
    ```

3. Rename "config_sample.js" to "config.js" and add your Stripe Keys

4. Add your PublishableKey to "main.js"

5. Rename "users_sample.js" to "users.js" and update the admin user info

6. Make sure to add both "config.js" and "users.js" to your ".gitignore" file

7. Ensure mondodb is running (use `pwd` for current directory or use directory of choice [mongodb docs](http://docs.mongodb.org/manual/tutorial/manage-mongodb-processes/))
```sh
    mongod --dbpath `pwd`
```

8. Run:

    ```sh
    $ node app
    ```

9 Once you get everything working, make sure to update the links within the admin page, depending upon if you're using the test account or live account.

## tests

1. Run `make test` and `make coverage`

## to do

1. unit- FREAKING -tests
2. update admin page. add charts, graphs, sortable table, trim time from dates ..
3. add login error messaging

## screenshots

### main page

![main](https://raw.github.com/mjhea0/node-stripe-charge/master/screenshots/main.png)

### charge page

![charge](https://raw.github.com/mjhea0/node-stripe-charge/master/screenshots/charge.png)

### successful charge

![success](https://raw.github.com/mjhea0/node-stripe-charge/master/screenshots/success.png)

### admin page

![admin](https://raw.github.com/mjhea0/node-stripe-charge/master/screenshots/admin.png)

repository: mikemjharris/node-stripe-charge

repo_name: mikemjharris/node-stripe-charge


text:
# Contributing
You can contribute to this project by [reporting issues](https://github.com/guillermoandrae/php-dynamodb/issues) or submitting [Pull Requests](https://github.com/guillermoandrae/php-dynamodb/pulls).

## Bugs
Submit via [GitHub Issues](https://github.com/guillermoandrae/php-dynamodb/issues).

## Testing
Run the following command to make sure your code is appropriately styled:
```shell script
composer check-style
```

Run the following command to check style, run tests, and generate a Clover report:
```shell script
composer test
```

Run the following command to check style, run tests, and generate an HTML report (access the report at http://localhost:8080):
```shell script
composer test-html
```

license: MIT

repository: guillermoandrae/php-dynamodb

branch_name: refs/heads/master

extension: md

gha_language: PHP

gha_license_id: MIT

license_type: permissive

repo_name: guillermoandrae/php-dynamodb


text:
# redmine_intouch

Plugin is designed by [Centos-admin.ru](http://centos-admin.ru/).

Plugin is designed to send notifications to Redmine’s users by Telegram or E-mail.

## Requirements

**Redmine 3.1.x**

To work with plugin, you must install a [redmine_sidekiq](https://github.com/ogom/redmine_sidekiq) plugin

[Launch Sidekiq as daemon](https://github.com/mperham/sidekiq/wiki/Deployment#daemonization)

* Examples of configuration file and script for `init.d` are in the folder `tools`

# Plugin Setting

## General settings

The required notification protocols are specified in the "Protocols" section. Telegram and email are currently available.

The "Working days" section shall contain:

* the start and the end of the working day
* what days of the week are working days

In the "Urgent issues" section you should specify issue priorities, for which notifications should be **always** sent, regardless of time of day and day of the week.

The plugin contains the functional of periodic notifications about the issues "In work" or with the "Feedback" status. To correctly interpret these statuses by plugin, specify them in the respective sections.

## Telegram

On this tab, you must specify the Telegram bot token.

### Creating a Telegram bot

It is necessary to register a bot and get its token. For this purpose, there is a special bot in Telegram - @BotFather.

We should write for him `/start` and get a list of all its commands.
The first and foremost - `/newbot`  - we send to it and the bot asks to come up with the name for our new bot.
The only restriction on the name - it must be ended with “bot”.
If successful, @BotFather returns a bot token and link to quickly add a bot to contacts;
otherwise you'll have to break your head over the name.

The resulting token must be entered in the plugin settings page.

### Bot launch

Before launching the bot, you must specify in the plugin settings page:

* Telegram’s bot token (how to get it is described below)
* working time - notifications about non-urgent issues are sent during this time
* specify what priorities should be considered as urgent ones
* specify what statuses should be considered _in work_ and _feedback_

After that you need to launch a bot by command:

```shell
bundle exec rake intouch:telegram:bot PID_DIR='/pid/dir'
```

Example of the script for `init.d` in the `tools` folder.

This process adds Telegram’s users in Redmine, as well as creates the Telegram groups in Redmine,
in which the bot was added.

### Adding a Telegram account to the user

Once the bot was launched and the user welcomed it by `/start` command,
it is possible to select the corresponding Telegram account for the user on the user’s editing page.

#### If the bot has been changed

If you have changed the bot, then each user needs to greet it personally.

That is, to find @YourTelegramBot through the search and to write to it `/start`.

### Adding a Telegram Group

The groups will be added automatically in Redmine, if the boat will be added to them.

The name of the group is saved right away when adding.
If some time later you change the name of the group and want to update the name in Redmine,
perform the command `/rename` in the group chat.

## Setting Templates

Setting templates allow you to specify all the required settings for the project only one time
and then to select the desired template in each project.
Read below for more information on the plugin settings within the project.

## Regular Notifications Schedule

The plugin is provided with:

* Notification about issues with the status "In work"
* Notification about issues with the status "Feedback"
* Notifications about unassigned issues
* Notifications about overdue issues

The frequency and recipients of these notifications are set for each project individually or using templates.

Regular notifications schedule regular is set on the plugin settings page, on the **Periodic tasks schedule** tab.

When you set the plugin for the first time, you need to initialize the periodic tasks.

You can then set a periodic notifications schedule convenient to you.

Schedule is set using the CRON syntax.

It is important to note that on this tab you should set how often to check for availability of issues on which
you want to send the notifications.
The frequency of the notifications themselves is indicated in each project individually or using templates.

# Setting the module within the project

You must select the Intouch module in the project settings on the "Modules" tab.
As a result, the "Intouch" tab appears in the settings.

This tab includes three sections:

* Instant notifications when changing the issue status/priority
* Periodic notifications
* Assigner groups

## Instant notifications when changing the issue status/priority

In this section, instant notifications are set for the following recipients:

* Author
* Assigner
* Task watchers
* Telegram groups

**Important note: In order that the Telegram’s user can receive messages,
the user must preliminarily write the `/start` command to the bot**

## Periodic notifications

### General settings

The intervals of periodic notifications for different priorities are specified in general settings.

### In work / Feedback

The recipients of periodic notifications about the issues with the statuses
"In work" and "Feedback" are specified on these tabs.

### Unassigned / Assigned to the group

On this tab, one should specify recipients of periodic notifications about the issues

* without the designated assigner
* assigned to the group

### Overdue / Without a due date

On this tab, one should specify recipients of periodic notifications about the issues

* the due date of which is in the past
* with an unspecified due date

# Author of the Plugin

The plugin is designed by [Centos-admin.ru](http://centos-admin.ru/).


text:
---
title: "Debt"
date: 2021-10-23
tags:
- seed
---

[Source: Debt - the first 5000 years, David Graeber on *Kernel*](https://kernel.community/en/learn/module-2/debt)

Related: [money](thoughts/money.md)

## Human Exchange
On the basis of human exchange: we only have a relationship with the other (as equals) when the exchange is incomplete, i.e. when there is debt.

> Someone will give you something and the expectation is that you will give them something in return, though not something of _exactly the same_ value as that would indicate you no longer wish to relate with them

By this definition then, a community is one where everybody is a *little bit* in debt to everyone else which gives us an excuse to continue seeing each other.

Money then, appears to be a way to have quantified and transferable promises. (An aside, why do we even feel the need to [quantify](thoughts/quantization.md) promises??)

However, **the philosophy of debt as something which cannot be forgiven only ever crops up in situations of structural coercion and extreme inequality.**

## Against the Econ 101 argument
Barter → money → credit is not only wrong, it's backwards.

We have never found any evidence for an entirely barter-based society. In places without money, there are usually rough credit systems instead: "a cow is roughly like a canoe is roughly like a good necklace". Of course, people can shirk this but your reputation is then tarnished and that can be social suicide in small communities.

## Markets and Government
Traditionally, free markets and governments have been seen as opposing principles.

Historically, in fact, markets tend to be created _by_ governments as a side-effect of military operations and to fund armies.

branch_name: refs/heads/hugo

gha_language: SCSS


text:
---
templateKey: way-sections
title: Purpose space
filename: problem.perceive
image: /img/percieve.png
---

Perceiving

Now, we see the challenge more clearly, without bias. We are close to perceiving the problem neutrally. We use specific techniques to de-color perceptions, and look at the problem with more awareness. It is space for prioritising, comparing, reviews on big picture. Understanding the problem right is half the problem solved. We cross the first gate. Deliverables take shape.


text:
# InitCampaignRequestType

## Properties
Name | Type | Description | Notes
------------ | ------------- | ------------- | -------------
**title** | **string** | Title of the campaign. | [optional]
**max_attempts** | **int** | Maximum number of calls to one phone number. | [optional]
**interval** | **int** | Time between attempts to call one phone number. | [optional]
**max_lines** | **int** | Maximum number of calls performed simultaneously | [optional]
**scenario_id** | **int** | Scenario ID. The ID can be retrieved via the **searchScenarios** method. | [optional]
**phone_number_id** | **int** | Phone number ID. The ID сan be retrieved via the **searchNumbers** method. | [optional]
**caller_id** | **int** | Caller ID. The ID сan be retrieved via the **searchCallerIDs** method. | [optional]
**time_start** | **string** | Time when the API starts calling customers. | [optional]
**time_end** | **string** | Time when the calls end. Specify it along with the time_start parameter. | [optional]
**date_start** | **string** | Date when the API starts calling customers. | [optional]
**date_end** | **string** | Date when the calls end. | [optional]
**permanent** | **bool** | Set 'true' to make the campaign permanent. Set 'false' to stop the campaign after the end of the calls. | [optional]
**description** | **string** | Campaign description | [optional]

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

repository: voximplant/kit-apiclient-php

repo_name: voximplant/kit-apiclient-php


text:
# Intended use

This section describes the intended usage of MOVO.

MOVO is a general-purpose mobile manipulation platform.

MOVO is intended to be used for research purposes only in an environmentally-controlled, supervised indoor laboratory or research facility environment.

Make sure you have enough space in the environment to move around freely.

MOVO is not intended for commercial or industrial use.

**Parent topic:** [Personal safety and security of MOVO](../Concepts/c_movo_safety.md)

repository: Kinovarobotics/kinova-movo

gha_language: Python

repo_name: Kinovarobotics/kinova-movo


text:
---
layout: page
subheadline: "Demirbas, Murat, Yavuz Selim Yilmaz, and Muhammed Fatih Bulut (PERCOM WORKSHOPS), IEEE 2013"
title: "Eywa: Crowdsourced and cloudsourced omniscience"
teaser: "Here we present our ubiquitous computing vision, Eywa. Eywa is an open publish-subscribe system that employs crowdsourcing for tasking and social networks & machine learning for identifying relevance. We argue that crowdsourcing (and the social networks and machine learning that enable it) should be a first class citizen in ubiquitous computing. We also observe that cloud computing is a natural platform to host such future ubiquitous computing systems. We discuss about some applications enabled by Eywa, and focus on our CuratedLiving application (which emphasizes “less choice more relevance” approach) as a case study."
categories:
    - researchpaper
tags:
    - crowd
comments: true
show_meta: false
---

For more please follow the [link](http://ieeexplore.ieee.org/xpls/abs_all.jsp?arnumber=6529480)


text:
# copy-listeners [![Build Status](https://travis-ci.org/tjmehta/copy-listeners.svg)](https://travis-ci.org/tjmehta/copy-listeners) [![js-standard-style](https://img.shields.io/badge/code%20style-standard-brightgreen.svg?style=flat)](http://standardjs.com/)
copy (or move) event listeners from one event emitter to another

# Installation
```bash
npm i --save copy-listeners
```

# Usage

### Example: copy all listeners from one event emitter to another
```js
var copyListeners = require('copy-listeners')

var ee = new EventEmitter()
var ee2 = new EventEmitter()

ee.on('foo', function () {
  console.log('FOO!')
})

copyListeners(ee, ee2)

ee.emit('foo') // prints "FOO!".. like normal
ee2.emit('foo') // prints "FOO!".. the listener was copied to ee2
```

### Example: copy select listeners from one event emitter to another
```js
var copyListeners = require('copy-listeners')

var ee = new EventEmitter()
var ee2 = new EventEmitter()

ee.on('foo', function () {
  console.log('FOO!')
})
ee.on('bar', function () {
  console.log('BAR!')
})

copyListeners(ee, ee2, ['bar'])

ee.emit('foo') // prints "FOO!".. like normal
ee2.emit('foo') // does nothing.. was not copied
ee.emit('bar') // prints "BAR!".. like normal
ee2.emit('bar') // prints "BAR!".. the listener was copied to ee2
```

### Example: move all listeners from one event emitter to another (removes listeners from source)
```js
var moveListeners = require('copy-listeners').moveListeners

var ee = new EventEmitter()
var ee2 = new EventEmitter()

ee.on('foo', function () {
  console.log('FOO!')
})
ee.on('bar', function () {
  console.log('BAR!')
})

moveListeners(ee, ee2)

ee.emit('foo') // does nothing.. it was removed
ee2.emit('foo') // prints "FOO!".. the listener was copied to ee2
ee.emit('bar') // does nothing.. it was removed
ee2.emit('bar') // prints "BAR!".. the listener was copied to ee2
```

### Example: move select listeners from one event emitter to another (removes listeners from source)
```js
var moveListeners = require('copy-listeners').moveListeners

var ee = new EventEmitter()
var ee2 = new EventEmitter()

ee.on('foo', function () {
  console.log('FOO!')
})
ee.on('bar', function () {
  console.log('BAR!')
})

moveListeners(ee, ee2, ['bar'])
// to move all listeners don't provide `events`: moveListeners(ee, ee2)

ee.emit('foo') // prints "FOO!".. like normal
ee2.emit('foo') // does nothing.. was not copied
ee.emit('bar') // does nothing.. it was removed
ee2.emit('bar') // prints "BAR!".. the listener was copied to ee2
```

# License
MIT

repository: tjmehta/copy-listeners

gha_language: JavaScript

repo_name: tjmehta/copy-listeners


text:
+++
draft = false
title = "Replacing Sed/Awk With Amber"
date = "2019-01-25T07:52:40Z"
slug = "replacing-awk-sed-with-amber"
tags = ['Rust', 'Bash', 'Awk', 'Sed', 'Amber', 'Code Search', 'Replace', 'Unix']
banner = ""
aliases = []
+++

A couple of weeks ago I introduced the concept of replacing basic Unix equivalents with modern Rust alternatives with the example of [Bat](/post/rust-alternatives-to-command-line-utilites-bat-cat/) - today I want to introduce Amber, a modern alternative to awk and sed.

<!--more -->

repository: arranf/HugoToJSON

gha_language: Rust

repo_name: arranf/HugoToJSON


text:
# Baking App

This app gathers recipe data from a specified json resource on the web. Once the data is received, gson parses it and creates POJOs which are later utilised to show the recipes in a list. Each recipe contains steps and ingredients that are displayed on another activity once the recipe card is clicked. Once on that activity, you can click on the step/ingredients card to go to an activity that shows details on that. However, if the app is run on a tablet, the details will be shown on the right side by side. If a video is present with that specific step, it will be displayed above the instructions.

## Getting Started

These instructions will get you a copy of the project up and running on your local machine for development and testing purposes.

### Prerequisites

What things you need to install the app

```
1. Install Android Studio on your machine. Versions for Linux, Windows and macOS are available from here https://developer.android.com/studio/
2. Create a new emulator for a Google Pixel 2 with SDK version 27 or have a physical device on hand
3. If you are using a physical device, enable ADB debugging on your device. Refer to official documentation on how to install do it
```

### Installing

A step by step series of examples that tell you how to get a development env running

Cloning the project

```
1. Navigate to a location on your machine's file system, where you want to clone the project using a terminal or command line
2. Run this command to clone the master branch https://github.com/TomMichalkevic/Baking-App.git
3. Open your Android Studio and open the project from the project root you have just created by cloning
```

Setting up the project

```
1. Run gradle sync on the build.gradle in the app folder
2. When either an emulator or a physical device is connected, run installDebug task
3. Now you have a working instance the app
```

## Running the tests

To run the tests, you need to go to app/src/androidTest/com.tomasmichalkevic.bakingapp/MainActivityTest.java and run the main class.

### Test Breakdown

These test were created to test basic app functionality such as instantiating the activity, getting the app context and making sure that data was pulled. Please note that for the tests that test actions that potentially can take a long time have to use the IdlingResource as otherwise they will not work.

Test breakdown

```
1. useAppContext - Checks using the context of an application to get the package name
2. instantiateMainActivity - Checks whether it is possible to instantiate the activity
3. checkLoadedRecipes - Checks that the correct recipies are loaded
4. opensDetailsActivity - Checks opening the Details activity for the recipe, which contains the details such as ingredients and steps
```

## Built With

* [Gradle](https://gradle.org) - Dependency management and building

## Contributing

Please read [CONTRIBUTING.md](https://github.com/TomMichalkevic/Baking-App/blob/master/CONTRIBUTING.md) for details on our code of conduct, and the process for submitting pull requests to us.

## Versioning

We use [SemVer](http://semver.org/) for versioning. For the versions available, see the [tags on this repository](https://github.com/TomMichalkevic/Baking-App/tags).

## Authors

* **Tomas Michalkevic** - *Initial work* - [Baking App](https://github.com/TomMichalkevic/Baking-App)

See also the list of [contributors](https://github.com/TomMichalkevic/Baking-App/contributors) who participated in this project.

## License

This project is licensed under the MIT License - see the [official resource](https://opensource.org/licenses/MIT) for details

## Acknowledgments

* Hat tip to anyone whose code was used
* Inspiration
* etc

repository: TomMichalkevic/Baking-App

repo_name: TomMichalkevic/Baking-App


text:
# Dhl-api-wrapper (Deprecated, please read our warning)

### WARNING ###
Provided as-is, but deprecated and no longer supported.

### Installing via Composer
The recommended way to install the wrapper is through
[Composer](http://getcomposer.org).

```bash
# Install Composer
curl -sS https://getcomposer.org/installer | php
```

Next, run the Composer command to install the latest stable version of the wrapper:

```bash
php composer.phar require dhl-plugins/dhl-api-wrapper
```
After installing, you need to require Composer's autoloader:

```php
require __DIR__ . '/vendor/autoload.php';
```

### Frequently asked questions

See [FAQ.md](FAQ.md).

## Getting Started

First you will need to initialise the client like this:

```php
$client = new \Dhl\ApiClient([
    'apiUser' => $apiUser,
    'apiKey' => $apiKey,
    'accountId' => $accountId,
    'organisationId' => $organisationId,
]);
```

Then you can begin making requests like shown below.
Please note that the list of requests below is not complete.

More complete examples are located in the [examples directory](examples/)

### Create Shipping Label
check the [create label example](examples/createLabel.php) for the `$parameters` variable.
```php
// Create a DHL shipping label
$label = $client->createLabel($parameters);
$rawPdf = $labelResult->offsetGet('pdf');
if (!file_put_contents('DHLshippingLabel.pdf', base64_decode($rawPdf))) {
    printf('could not write label.%s', PHP_EOL);
} else {
    printf('Shipping label writen.%s', PHP_EOL);
}
```

### Retrieve Capabilities
```php
// Retrieve the capabilities for your account and shipment information.
// The result can be used as `options` in the createLabel call.
$result = $client->capabilities([
    'fromCountry' => 'NL',
    'fromPostalCode' => '3542 AD',
    'toCountry' => 'NL',
    'toPostalCode' => '3542 AB',
]);
printf('<pre>%s</pre>', print_r($result, true));
```

### Destination Countries
```php
// Get a list of all destination Countries.
$result = $client->destinationCountries(['senderType' => 'business', 'fromCountry' => 'NL']);
printf('<pre>%s</pre>', print_r($result, true));
```

Endpoints which are available, take a look in the [./src/Dhl/resources](src/Dhl/resources) directory for reference.

### Bugs & Issues
We no longer maintain this wrapper.

repository: klongchu/dhl-api-wrapper

repo_name: klongchu/dhl-api-wrapper


text:
---
title: Command Line Options
order: 400
lang: en
---

# Scully Command Line Options

The Scully CLI has the following available options:

[Scully command line options](#scully-command-line-options)

- [Scully Command Line Options](#scully-command-line-options)
  - [Serve](#serve)
  - [Watch](#watch)
  - [showBrowser](#showbrowser)
  - [showGuessError](#showguesserror)
  - [configFile](#configfile)
  - [project](#project)
  - [baseFilter](#basefilter)
  - [routeFilter](#routefilter)
  - [proxyConfig](#proxyconfig)
  - [removeStaticDist](#removestaticdist)
  - [open](#open)
  - [scanRoutes](#scanroutes)
  - [serverTimout](#servertimout)
  - [ssl](#ssl)
  - [ssl-cert](#ssl-cert)
  - [ssl-key](#ssl-key)
  - [tds](#tds)
  - [pluginsError](#pluginserror)
  - [pjFirst](#pjfirst)
  - [404](#404)
  - [prod](#prod)

## Serve

```bash
npx scully serve
```

Starts the scully server. This process does not _build_ the project. It only serves the Angular build files, and the Scully static files.

## Watch

```bash
npx scully --watch
```

By default, Scully has the watchMode in false. You need to add this flag to use Watch Mode.

## showBrowser

```bash
npx scully --showBrowser
```

Alias `--sb`. Chromium browser renders the application.

## showGuessError

```bash
npx scully --showGuessError
```

Alias `--sge`. Displays Guess-Parse's errors in the console.

## configFile

```bash
npx scully --configFile someName
```

Alias `--cf`. Loads a different config file. If it is used at the same time as the `--project` flag, the project flag takes precedence.

## project

```bash
npx scully --project someName
```

Alias `--pr`. It is used to select a different project. Scully uses the default project from generated by the the Angular CLI.

## baseFilter

```bash
npx scully --baseFilter /someRoute
```

Alias `--bf`. Enables Scully to start rendering a specific route. works on the raw routes, extracted from the app, or provided by extraRoutes.

## routeFilter

```bash
npx scully --routeFilter /user/*/post/1,/posts/1/user/*
```

Alias `--rf`. Enables Scully to start rendering a specific route. Uses the handledRoutes. You can use the `*` as a wildcard, and provide multiple routes seprated by a `,`

## proxyConfig

Alias `--proxy`. Takes a relative filename for a proxy config file.

For more details look at [this](https://github.com/chimurai/http-proxy-middleware/blob/main/README.md).

Scully uses the same config format as [webpackDevServer](https://webpack.js.org/configuration/dev-server/#devserverproxy).

## removeStaticDist

```bash
npx scully --removeStaticDist
```

Alias `--RSD`. Removes the static folder generated by Scully from previous renders.

## open

```bash
npx scully serve/watch --open
```

Alias `--o`. Opens the default browser and renders the dist folder generated by Scully.

## scanRoutes

Alias `--sr` or `--scan`. Scans the application again to find unhandled routes. This is normally done just once. When routes in the application are added or changed, use this flag to discover all the new routes.

## serverTimout

alias `--st` Time to wait for the Scully server to become available. Defaults to 10000 (10 seconds). If you experience timeout issues in your CI, you might wat to raise this number. (Scully needs to extract the routes, this might take longer in a CI environment)

## ssl

```bash
npx scully serve/watch --ssl
```

Runs the Scully server with ssl.

## ssl-cert

```bash
npx scully serve/watch --ssl --ssl-cert=./url/to/file
```

Adds a url to the ssl certificate file for a server with SSL.

## ssl-key

```bash
npx scully serve/watch --ssl --ssl-key=./url/to/file
```

Adds a url to an ssl key file for a server with SSL.

## tds

```bash
npx scully --tds
```

Launches the Test Data Server. This is only helpful for demos.

The following APIs are supported on the test data server:

- `/users` - Returns a list of users
- `/users/:id` - Returns just one user by id
- `/posts` - Returns a list of posts
- `/posts/:id` - Returns a post by id
- `/slow/:delay` - Returns 200 code after a delay has gone by. Eg: `/slow/2000` takes 2 seconds.

## pluginsError

```bash
npx scully --pluginsError=false
```

Alias `--pe` Show the error from the plugin, but continue rendering.
If you do not use the flag (by default is true) when you have an error in any plugin, the Scully will terminate.

## pjFirst

```bash
npx scully --pjFirst
```

might
Alias `--pjf`. In an project that has a different setup, you might want to use the location of the main `package.json` instead of the `angular.json` as the homeFolder default. This might be needed in some NX repo's as well.

## 404

```bash
npx scully --404=""  #default, no need to provide this
npx scully --040="index"
npx scully --040="404"
npx scully --040="none"
```

How routes that are not provided in the application are handled.
If the Scully server gets a request for a route(file) that does not exists on the file-system, this option amends ow that is handled. The default option is to render a 404 page, and raise a warning during rendering. the `index` and `404` will render the `index.html` or the `404.html` from the dist root folder. The `none` option will leave it up to the express software layer. And lastly, `baseOnly` will use the unhandled routes only

## prod

```bash
npx scully --prod
```

With the prod flag you can use a different config for your scully config and plugins. [example](https://github.com/scullyio/scully/blob/main/scully.scully-docs.config.ts#L15)

repository: jtcrowson/scully

branch_name: refs/heads/main

repo_name: jtcrowson/scully


text:
# Pip install and save to requirements.txt

Upon installing a package in a Python virtual environment (python3-venv), it doesn't automatically save that package to a requirements file (unlike npm which saves installed packeges in the package.json file). Here is a simple bash script (and a batch script for Windows systems) that will install the package via pip and will save that package name (and other installed packages in that virtual environment) in a requirements.txt file.

For example, to install the [python requests](https://requests.readthedocs.io/en/master/) module -

```bash
sh pi.sh requests
```

Or in Windows systems -

```bash
pi.bat requests
```

repository: farhanmasud/python-code-snippets

repo_name: farhanmasud/python-code-snippets


text:
# Braintree Android Encryption

This library is for use with [Braintree's payment gateway](http://braintreepayments.com/) in concert
with one of [the supported client libraries](http://braintreepayments.com/docs).  It encrypts
sensitive payment information using the public key of an asymmetric key pair.

# :warning: DEPRECATED :warning:
This integration method is deprecated. Please upgrade to the latest version of [braintree-android](https://github.com/braintree/braintree_android)


text:
# Changelog

* v1.20.1:
  * Upgraded dependencies:
    * upgraded version of data-sourcer includes stability and error-handling improvements
* v1.20.0:
  * Can now pass options to [dataSourcer](https://github.com/chill117/data-sourcer#getdata) when calling `getProxies` and `getProxiesFromSource`. Most relevant options:
    * `browser` - Options object passed to [puppeteer.launch(options)](https://pptr.dev/#?product=Puppeteer&version=v1.19.0&show=api-puppeteerlaunchoptions)
    * `sourcesDir` - Directory path where your sources are defined. Default is the "sources" directory included with the ProxyLists project.
  * Calls to `getProxies` and `getProxiesFromSource` will now both clean-up by calling the `dataSourcer.close` method once all the sources have sent their end event. This has the effect of automatically closing any browser instances used by proxy sources.
* v1.19.0:
  * Several new sources, more info scraped from existing sources
  * Close browser tabs used by source when it sends its end event
  * Overall better error handling
  * CLI:
    * `--output-file` and `--log-file` can now accept absolute file paths
* v1.18.0:
  * Fixed more sources
  * CLI tool now exits properly
  * No end event issue should be resolved - see [#90](https://github.com/chill117/proxy-lists/issues/90)
* v1.17.0:
  * Fixed sources
  * Can now use mixed upper/lower casing for filter options - see [#92](https://github.com/chill117/proxy-lists/issues/92) for more details
* v1.16.1:
  * Updated dependencies (vulnerability warnings)
* v1.16.0:
  * Fixed-up several sources, getting anonymityLevel and protocols where possible.
* v1.15.0:
  * Upgraded dependencies
  * Fixed sources: hidemyname (formerly incloak), premproxy, proxydb
  * Now using [data-sourcer](https://github.com/chill117/data-sourcer) for managing sources
  * Cleaner CLI usage: Write log messages to proxy-lists.log file.
* v1.14.1:
  * Fix for regression in CLI
* v1.14.0:
  * Added options: `countriesBlackList`, `filterMode`, `defaultRequestOptions`
* v1.13.0:
  * Added source (premproxy)
  * Fixed source (proxydb)
  * Fix for blackhatworld source when last reply in thread does not contain the proxy list
  * Added another blackhatworld forum thread
* v1.12.0:
  * Added new source (coolproxy)
* v1.11.2:
  * Removed source (hidemyass)
  * Fixed source (blackhatworld)
* v1.11.1:
  * Fixed [#46](https://github.com/chill117/proxy-lists/issues/46)
  * Removed source (maxiproxies) because it no longer exists.
* v1.11.0:
  * Added new source (blackhatworld).
  * Fix for [#43](https://github.com/chill117/proxy-lists/issues/43)
* v1.10.0:
  * Added new source (maxiproxies).
  * Removed source (proxyspy) because it is no longer working.
  * Fix for [#42](https://github.com/chill117/proxy-lists/issues/42)
  * If using your own custom sources:
    * Proxy sources are now only required to provide `ipAddress` and `port`; all other fields are optional and should be provided only if known.
* v1.9.0:
  * Fixes for proxydb.
  * Removed source (proxyocean) because it no longer exists.
  * Added support for ipv6 addresses.
* v1.8.0:
  * Added `--stdout` option to CLI utility.
  * Fixed issues: [#35](https://github.com/chill117/proxy-lists/issues/35), [#37](https://github.com/chill117/proxy-lists/issues/37)
* v1.7.1:
  * Fixed issues: [#28](https://github.com/chill117/proxy-lists/issues/28), [#29](https://github.com/chill117/proxy-lists/issues/29)
* v1.7.0:
  * Now performing geo-ip look-up for all proxies
  * More proxy sources: gatherproxy.com, incloak.com, proxydb.net
* v1.6.0:
  * Added command-line interface.
  * Fixes for source (kingproxies).
* v1.5.1:
  * Fixes for source (hidemyass).
  * Removed geo-ip lookups from source (proxies24).
* v1.5.0:
  * Added `series` option to `ProxyLists.getProxies()` and `ProxyLists.getProxiesFromSource()`.
* v1.4.0:
  * `isValidProxy` no longer checks the `proxy.country` attribute.
  * `ProxyLists.getProxies()`, `ProxyLists.getProxiesFromSource()`, and `getProxies()` for all sources now using event emitter interface.
* v1.3.0:
  * Removed attribute `proxy.protocol` in favor of `proxy.protocols` (an array of all supported protocols).
  * Renamed attribute `proxy.ip_address` to `proxy.ipAddress` for consistency.
  * Added attribute `proxy.source`.


text:
# Random Network Distillation
#### Intrinsic Reward Graph with play
| Venture             |  Montezuma's Revenge |
:-------------------------:|:-------------------------:
![](https://github.com/jcwleo/random-network-distillation-pytorch/blob/master/asset/venture.gif)  |  [![Video Label](https://github.com/jcwleo/random-network-distillation-pytorch/blob/master/asset/montezuma.gif)](https://youtu.be/eEoHnkDUw4k?t=0s)
 ~ | [New model for Montezuma](https://www.youtube.com/watch?v=IxXHQDHvGoE&feature=youtu.be)

- [x] Advantage Actor critic [[1]](#references)
- [x] Parallel Advantage Actor critic [[2]](#references)
- [x] Exploration by Random Network Distillation [[3]](#references)
- [x] Proximal Policy Optimization Algorithms [[4]](#references)

## 1. Setup
####  Requirements

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

- python3.6
- gym
- [OpenCV Python](https://pypi.python.org/pypi/opencv-python)
- [PyTorch](http://pytorch.org/)
- [tensorboardX](https://github.com/lanpa/tensorboardX)

## 2. How to Train
Modify the parameters in `config.conf` as you like.
```
python train.py
```

## 3. How to Eval
```
python eval.py
```

## 4. Loss/Reward Graph
- Montezuma's Revenge Env
![image](https://user-images.githubusercontent.com/23333028/50719328-de9a9400-10dd-11e9-8c8c-29f7709cdf1d.png)
- Venture Env
![image](https://user-images.githubusercontent.com/23333028/48773457-c37cec00-ed0a-11e8-8c20-f9c35effc42d.png)

References
----------

[1] [Actor-Critic Algorithms](https://papers.nips.cc/paper/1786-actor-critic-algorithms.pdf)
[2] [Efficient Parallel Methods for Deep Reinforcement Learning](https://arxiv.org/abs/1705.04862)
[3] [Exploration by Random Network Distillation](https://arxiv.org/abs/1810.12894)
[4] [Proximal Policy Optimization Algorithms](https://arxiv.org/abs/1707.06347)


text:
  Play on itch

Invert

	🚧  Status Prototype Released 🚧

  About   |
  Game Engine   |
  License   |

## :dart: About ##

Invert is a classis 2D puzzle platformer created as a submission for Tri-Annual-Jam #1. The theme for this jam was "You are your enemy" and to adhert to this theme, Invert present you with 1 controller-2 characters mechanics. This means if you press left, one character moves left and the other one moves right. You have to compelete each level without hitting each other. Since this game was created with a limited time frame, it has very limited levels.

## :rocket: Technologies ##

The following tools were used in this project:

- [Godot](https://godotengine.org/)

## :memo: License ##

This project is under license from MIT. For more details, see the [LICENSE](LICENSE.md) file.

Back to top


text:
---
hack_number: 4
date: 2020-06-27

---
### Things people did

- **Mike and Alan** worked on a collaborative podcast listening site, which supports dark mode and is seconds away from being fully VC Funded 💵.

- **Peter** implemented a Rust grpc-based server, supporting multiple games/players for an existing Python game 🦊🌳🏝.

- **Iulian** built an Ubuntu VM and investigated snap packages. He then explained to us how they work and why they're useful 🙇♀.

- **Jane** sewed a _lot_ of face masks, becoming by far the most valuable thing to occur in RemoteHack to date 😷 🙌 [🎵][ep12].

- **Ben and Adam** podcasted[🎵][ep10] and got excited about burritos[🎵][ep13]. **Ben** also unboxed a controller[🎵][ep11].

- **Adam** created a micromaterials site to highlight exemplar code, linking directly to the source in GitHub.

- **James** wrote a backend in python for [a card game](https://en.wikipedia.org/wiki/No_Thanks!_(game)), in a way that it could be extended to other games in the future!

- **Kip** joined a live-coding session, and was part of a bizzare chain of VS-Code → ngrok → webrtc dev servers.

- **Dan, Ben and Ryan** built on Ben's peer-to-peer gRPC code to create the Lobster Lobbing Spacesteroids game. Ryan got far too excited about using emojis as game elements, and Dan showed us how to add support for Xbox/Playstation controllers using the [Gamepad API](https://developer.mozilla.org/en-US/docs/Web/API/Gamepad_API).

- **Ryan** pulled his runs and rides from the Stava API, and [visualised](https://twitter.com/spikeheap/status/1277543399067922432?s=20) how they change over time.

[ep10]: https://remotehack.space/live/audio/episode-10.m4a
[ep11]: https://remotehack.space/live/audio/episode-11.m4a
[ep12]: https://remotehack.space/live/audio/episode-12.m4a
[ep13]: https://remotehack.space/live/audio/episode-13.m4a

gha_language: HTML


text:
# Alpine Elasticsearch Image

![https://www.augustash.com](http://augustash.s3.amazonaws.com/logos/ash-inline-color-500.png)

**This base container is not currently aimed at public consumption. It exists as a starting point for August Ash containers.**

## Versions

- `3.1.0`, `latest` [(Dockerfile)](https://github.com/augustash/docker-alpine-elasticsearch/blob/3.1.0/Dockerfile)
- `3.0.0` [(Dockerfile)](https://github.com/augustash/docker-alpine-elasticsearch/blob/3.0.0/Dockerfile)
- `2.0.0` [(Dockerfile)](https://github.com/augustash/docker-alpine-elasticsearch/blob/2.0.0/Dockerfile)
- `1.1.0` [(Dockerfile)](https://github.com/augustash/docker-alpine-elasticsearch/blob/1.1.0/Dockerfile)
- `1.0.0` [(Dockerfile)](https://github.com/augustash/docker-alpine-elasticsearch/blob/1.0.0/Dockerfile)

[See VERSIONS.md for image contents.](https://github.com/augustash/docker-alpine-elasticsearch/blob/master/VERSIONS.md)

## Usage

Launch a single-use Elasticsearch container:

```bash
docker run --rm \
    -p 9200:9200 \
    -p 9300:9300 \
    augustash/alpine-elasticsearch
```

### Configuration

Dynamic scripting is normally turned off but this image enables it. The best way to alter the configuration of Elasticsearch is to mount an `elasticsearch.yml` file into `/usr/share/elasticsearch/config`.

#### Plugins

The following analysis plugins are installed by default:

- `analysis-icu` which integrates the Lucene ICU module into Elasticsearch.
- `analysis-phonetic` which provides token filters which convert tokens to phonetic representations.

### User/Group Identifiers

To help avoid nasty permissions errors, the container allows you to specify your own `PUID` and `PGID`. This can be a user you've created or even `root` (not recommended).

### Environment Variables

The following variables can be set and will change how the container behaves. You can use the `-e` flag, an environment file, or your Docker Compose file to set your preferred values. The default values are shown:

- `PUID`=501
- `PGID`=1000

repository: augustash/docker-alpine-elasticsearch

repo_name: augustash/docker-alpine-elasticsearch


text:
# gwilym/url

Value object representing a URL. Makes parsing, formatting and handing around
URLs in a PHP app somewhat cleaner in some situations.

Couldn't think of a clever vendor name, so I used my own odd one.

## Installation

Use composer to bring it into your project, then follow the usage examples.

## Usage

It's intended to very simply wrap the components of a URL:

```php
$string = 'http://example.com';
$object = Gwilym\Url::parse($string);
$string = Gwilym\Url::format($object);
```

Additionally:

```php
$object = Gwilym\Url::parse('http://example.com');
echo $object->host; // example.com
```

repository: gwilym/php-url

repo_name: gwilym/php-url


text:
Houses
======

This is a simple app being developed with HTML boilerplate.
The objective is to show highschool students some application of Computer Science concepts in real life problems.
The suggested problem consists of connecting the three services (phone line, electricity and water supply) to all three houses.
However, the lines must not overlap.
This is an example of the K3-3 graph, which is not planar and, therefore, the problem is impossible to be solved in two dimensions.

repository: thiagorcdl/Houses

repo_name: thiagorcdl/Houses


text:
# Object-Detection-with-RANSAC

Object detection with keypoints by using [RANSAC](https://www.mathworks.com/discovery/ransac.html) algorithm.

##### Input Images:

![alt tag](https://github.com/furkanc/Object-Detection-with-RANSAC/blob/master/img1.jpg)

![alt tag](https://github.com/furkanc/Object-Detection-with-RANSAC/blob/master/img2.jpg)

##### Output:

![alt tag](https://github.com/furkanc/Object-Detection-with-RANSAC/blob/master/final_image.png)

repository: furkanc/Object-Detection-with-RANSAC

repo_name: furkanc/Object-Detection-with-RANSAC


text:
# Getting Started

## 🆘 Macrometa Support
If you have any trouble or need help while using SDK please contact [support@macrometa.com](mailto:support@macrometa.com).

## 🔐 Auth - Connect to GDN
The first step to start using GDN is establishing a connection to [gdn.paas.macrometa.io](https://gdn.paas.macrometa.io/). When this code executes, it initializes the server connection to your nearest region. You can access your Macrometa GDN account using several methods, such as [API keys](https://macrometa.com/docs/account-management/api-keys/), [User authentication](https://macrometa.com/docs/account-management/auth/user-auth), [Token-based authentication (JWT)](https://macrometa.com/docs/account-management/auth/jwts). For this example the method used is API key.

```python
from c8 import C8Client
client = C8Client(protocol='https', host='gdn.paas.macrometa.io', port=443, apikey='your api key')
```
## Create a collection
A [Collection](https://macrometa.com/docs/collections/) consists of documents, and they can be local(only stores data in one region) or global(replicates data and maintains consistency across regions). Macrometa offers several types of collections such as [Document Store](https://macrometa.com/docs/collections/documents/), [Key-Value Store](https://macrometa.com/docs/collections/keyvalue/), [Dynamo Table](https://macrometa.com/docs/collections/dynamo/create-dynamo-table) and [Graph-Edge collection](https://macrometa.com/docs/collections/graphs/). For this example we are going to create a [Document Store](https://macrometa.com/docs/collections/documents/).

```python
client.create_collection(name='employees', sync=False, edge=False, local_collection=False, stream=False)
```
# CRUD Operations for Document Store collection
A [document collection](https://macrometa.com/docs/collections/documents/) is a NoSQL database that stores data in JSON format (JavaScript Object Notation). Unlike traditional Relational Database Management Systems, document databases do not require a schema or a pre-defined structure with fixed tables and attributes.

[See the complete example for this section here](./examples/documents/document_store_crud.py)
## Insert Document
Documents are stored in [collections](https://macrometa.com/docs/collections/). Documents with completely different structures can be stored in the same collection.

**Inserting documents in 'employees' collection:**

[Add documents to collection](https://macrometa.com/docs/collections/documents/add-document)
```python
docs = [
    {'_key': 'Han', 'firstname': 'Han', 'lastname': 'Solo', 'email'<EMAIL_ADDRESS>'age': 35,
     'role': 'Manager'},
    {'_key': 'Bruce', 'firstname': 'Bruce', 'lastname': 'Wayne', 'email'<EMAIL_ADDRESS>'age': 40,
     'role': 'Developer', 'phone': '1-999-888-9999'},
    {'_key': 'Jon', 'firstname': 'Jon', 'lastname': 'Doe', 'email'<EMAIL_ADDRESS>'age': 25,
     'role': 'Manager'},
    {'_key': 'Zoe', 'firstname': 'Zoe', 'lastname': 'Hazim', 'email'<EMAIL_ADDRESS>'age': 20,
     'role': 'Director'},
    {'_key': 'Emma', 'firstname': 'Emma', 'lastname': 'Watson', 'email'<EMAIL_ADDRESS>'age': 25,
     'role': 'Director'}
]
client.insert_document(collection_name='employees', document=docs)
```

## Read Document
This example demonstrates how to retrieve a particular document with its *_key*.

**Retreive an specific document with it's _key value:**
```python
client.get_document(collection='employees', document={'_key': 'Han'})
```

## Update Document
The update operation can partially update a document in a collection. The document must contain the attributes and values to be updated and the _key attribute to identify the document to be updated. For this example the email for *Han* will be updated.

```python
client.update_document(collection_name='employees', document={'_key': 'Han', 'email'<EMAIL_ADDRESS>```

## Delete Document
The delete operation is used to remove a document from a collection. For this example *Han* will be removed from the **employees** collection.
```python
client.delete_document(collection_name='employees', document={'_key': 'Han'})
```

## Truncate a collection
All the data records inside the collection can be removed by truncating the collection. In the following example all the data inside **employees** collection is removed.
```python
client.collection(collection_name="employees").truncate()
```

## Delete a collection
In the following example, **employees** collection is deleted.
```python
client.delete_collection(name="employees")
```

## Working with C8QL
Working with data can be complex. CRUD operations usually need more logic or conditions to reach the desired results. At Macrometa the [C8 query language (C8QL)](https://macrometa.com/docs/queryworkers/c8ql/) can be used to create, retrieve, modify and delete data that are stored in the Macrometa geo-distributed fast data platform.
**Check out the [operators](https://macrometa.com/docs/queryworkers/c8ql/) and [examples](https://macrometa.com/docs/queryworkers/c8ql/examples/) in Macrometa**

[See the complete example for this section here](./examples/query/working_with_queries.py)

Let's [FILTER](https://macrometa.com/docs/queryworkers/c8ql/operations/filter) results by **role** and **age** and return a custom object using [ C8QL](https://macrometa.com/docs/queryworkers/c8ql/):
```python
query = "FOR doc IN employees FILTER doc.role == 'Manager' FILTER doc.age > 30 RETURN {'Name':doc.firstname,'Last Name':doc.lastname,'Email':doc.email}"
cursor = client.execute_query(query=query)
docs = [document for document in cursor]
```

It might not always be necessary to return all documents that a FOR loop would normally return. In those cases, you can limit the number of documents with a [LIMIT()](https://macrometa.com/docs/queryworkers/c8ql/operations/limit) operation. For this case, it will be used along with the [SORT()](https://macrometa.com/docs/queryworkers/c8ql/operations/sort) operation.
The first 2 documents are returned with the below query.
```python
query = "FOR doc IN employees SORT doc.age LIMIT 2 RETURN doc"
cursor = client.execute_query(query=query)
docs = [document for document in cursor]
```
Another function usually used with [LIMIT is OFFSET](https://macrometa.com/docs/cep/query-guide/query#limit--offset). The offset value specifies how many elements from the result shall be skipped. It must be 0 or greater. The count value specifies how many elements should be at most included in the result.
```python
query = "FOR doc IN employees SORT doc.age LIMIT 2, 4 RETURN doc"
cursor = client.execute_query(query=query)
docs = [document for document in cursor]
```

[Grouping](https://macrometa.com/docs/queryworkers/c8ql/examples/grouping) results is a common operation when retrieving data. To group results by arbitrary criteria, C8QL provides the [COLLECT](https://macrometa.com/docs/queryworkers/c8ql/operations/collect) keyword. [COLLECT](https://macrometa.com/docs/queryworkers/c8ql/operations/collect) will perform a grouping, but no aggregation. In the following example let's group by **age** and return only the **first name** of the employee using the  expansion operator [*].

```python
query = "FOR doc IN employees COLLECT age = doc.age INTO employeesByAge RETURN {age, employee: employeesByAge[*].doc.firstname}"
cursor = client.execute_query(query=query)
docs = [document for document in cursor]
```

## SQL
Macrometa SQL dialect supports DQL (SELECT statement), DML statements (UPDATE, INSERT and DELETE) and a subset of DDL statements.

Let's create a query using SQL syntax, you need to use the same **execute_query** as above, with the **sql** param as **True**

```python
cursor = client.execute_query(query="SELECT * FROM {}".format('employees'), sql=True)
docs = [doc for doc in cursor]
```

## Returning all data records inside the collection via batches
The Macrometa GDN has a default limit on how many documents can be returned per query. Usually, the default limit is 1,000 documents per query (This default limit is subject to changes).
The following method can be used to retrieve data from a collection in batches despite this default limit of 1,000 documents per query.

>**_Note:_** Please make sure there is more than enough memory available on your system (RAM + Swap(if swap is enabled)) to be able fetch total size of the documents to be returned. This will help avoid any Out-Of-Memory problems.

[See the full example here](./examples/common_use_cases/get_data_in_batches.py)

You need to specify the collection name in the `collection_name` parameter
```python
client.get_all_documents(collection_name="employees")
```

## Returning all data records returned by any query via batches
The Macrometa GDN has a default limit on how many documents can be returned per query. Usually, the default limit is 1,000 documents per query (This default limit is subject to changes).

The following method can be used to retrieve all the data from any query via batches despite this default limit of 1,000 documents per query.

>**_Note:_** Please make sure there is more than enough memory available on your system (RAM + Swap(if swap is enabled)) to be able fetch total size of the documents to be returned. This will help avoid any Out-Of-Memory problems.

[See the full example here](./examples/common_use_cases/get_data_in_batches.py)

You need to specify your query in the `query` parameter
```python
client.get_all_batches(query="FOR doc IN employees FILTER doc.email LIKE '%macrometa.io' RETURN doc")
```

# Query Workers
A query worker is set of named, parameterized C8QL queries stored in GDN that you can run from a dedicated REST endpoint. The query worker will be created automatically globally and is available from the region closest to the user. Refer [Query Workers](https://macrometa.com/docs/queryworkers/query-workers)

## Operations for query workers

[See the full example here](./examples/query_workers/query_workers.py)

### Create a query worker
In the following example a query worker named `insertRecord` is created which inserts documents into the **employees** collection.
```python
# Query to be saved with bind variable `docs`
insert_query = "FOR doc in @docs INSERT {'firstname': doc.firstname, 'lastname': doc.lastname, 'email': doc.email, 'zipcode': doc.zipcode, _key': doc._key} IN employees"

# Query worker object with name insertRecord
insert_data = {
    "query": {
        "name": "insertRecord",
        "value": insert_data_query,
    }
}

# Create query worker `insertRecord`
client.create_restql(data=insert_data)
```

### Import query workers
In the following example query workers named `getRecords` and `updateRecord` are created.
```python
get_data_query = "FOR doc IN employees RETURN doc"
update_data_query = "FOR doc IN employees FILTER doc.firstname == 'James' UPDATE doc with { zipcode: '33333' } IN employees"

# Query worker objects with names, getRecords and updateRecord
get_data = {"name": "getRecords", "value": get_data_query}
update_data = {"name": "updateRecord", "value": update_data_query}
queries = [get_data, update_data]

# Import query workers `getRecords` and `updateRecord`
client.import_restql(queries=queries)
```

### Execute a query worker
In the following example an already created query worker `insertRecord` is executed with bind variable `docs`.
```python
docs = [
    {
        "_key": "James",
        "firstname": "James",
        "lastname": "Kirk",
        "email"<EMAIL_ADDRESS>        "zipcode": "22222",
    },
    {
        "_key": "John",
        "firstname": "John",
        "lastname": "Doe",
        "email"<EMAIL_ADDRESS>        "zipcode": "11111",
    }
]

# Execute query worker `insertRecord` with bind variable `docs`
client.execute_restql(name="insertRecord", data={"bindVars": {"docs": docs}})
```

### Execute query worker in batches and read next batch
Just like queries, query worker can also be executed in batches. In the following example query worker `getRecords` is executed with batch size equal to 2.
```python
# Execute query worker `getRecords` with batch size equal to 2
resp = client.execute_restql(name="getRecords", data={"bindVars": {}, "batchSize": 2})
# Get cursor id
id = resp["id"]
# Read next batch from cursor
client.read_next_batch_restql(id=id)
```

### Retrieve query workers
All existing query workers can be viewed.
```python
client.get_restqls()
```

### Update a query worker
In the following example `insertRecord` query worker is updated with a new query.
```python
updated_insert_query = "INSERT {'_key'<EMAIL_ADDRESS>'firstname': 'Barry', 'lastname': 'Allen'} IN employees"

# Query worker object
updated_insert_data = {
    "query": {
        "value": updated_insert_query,
    }
}

# Update query worker `insertRecord`
client.update_restql(name="insertRecord", data=updated_insert_data)
```

### Delete a query worker
In the following example query worker, `insertRecord` is deleted.
```python
client.delete_restql(name="insertRecord")
```

## Get real-time updates from a collection
Example to get real-time updates from **employees** collection:
>**_Note:_** Enable the 'Stream' parameter within the collection to get real-time updates if not already enabled

[See the complete example here](./examples/common_use_cases/get_realtime_updates_from_collection.py)
```python
def callback_fn(event):
    print(event)

# Get real-time updates from collection
client.on_change(collection="employees", callback=callback_fn)
```

Stream can be enabled for a collection via any of the following:
1. While creating the collection itelf by passing the stream parameter as true:
```python
client.create_collection(name="employees", sync=False, edge=False, local_collection=False, stream=True)
```

Or

2. By updating the collection `properties` with `has_stream` as True after the collection is already created:
```python
client.update_collection_properties(collection_name="employees", has_stream=True)
```

# Streams
Streams are flows of data in GDN to capture data in motion. Messages are sent via streams by publishers to consumers who then do something with the message. Refer [Streams](https://macrometa.com/docs/streams/)

[See the complete example here](./examples/streams/streams.py)
## Basic operations for streams -

### Create a stream
In the following example a stream named `quickStart` is created globally (as local is set to False).
```python
client.create_stream(stream="quickStart", local=False)
```

### Retrieve all streams
All existing streams can be viewed.
```python
client.get_streams()
```

### Create a producer to send a message
In the following example, a [producer](https://macrometa.com/docs/streams/stream-basics/producers) is created for `global` stream named `quickStart`.
```python
# Create producer
producer = client.create_stream_producer(stream="quickStart", local=False)
msg = "Hello from user"
producer.send(msg)
# To close producer connection use `producer.close()`
```

### Create a subscriber to receive message
In the following example, a [subscriber](https://macrometa.com/docs/streams/stream-basics/consumers) with [subscription](https://macrometa.com/docs/streams/stream-basics/subscriptions) name `topic_1` is created for `global` stream named `quickStart`.
```python
# Create subscriber
subscriber = client.subscribe(
    stream="quickStart", local=False, subscription_name="topic_1"
)
# Subscriber reading message
m1 = json.loads(subscriber.recv())
# Decoding the received message
msg1 = base64.b64decode(m1["payload"]).decode("utf-8")
# Acknowledge the received msg.
subscriber.send(
    json.dumps({"messageId": m1["messageId"]})
)
# To close subscriber connection use `subscriber.close()`
```
A complete pub-sub example can be found [here](https://macrometa.com/docs/streams/stream-examples/pub-sub-streams)

### Delete a subscription from a particular stream
In the following example, a [subscription](https://macrometa.com/docs/streams/stream-basics/subscriptions) named `topic_1` is removed from a `global` stream named `quickStart` (set local parameter as false if the stream is local).
>**_Note:_** In case the stream is a local stream:
Append `c8locals.` instead of `c8globals.` to the stream name.
Set local parameter as true.

```python
client.delete_stream_subscription(stream="c8globals.quickStart", subscription="topic_1", local=False)
```

### Delete a subscription from all streams
In the following example, a [subscription](https://macrometa.com/docs/streams/stream-basics/subscriptions) named `topic_1` is removed from all `global` streams (set local parameter as true to remove subscription from all local streams).
```python
client.unsubscribe(subscription="topic_1", local=False)
```

### Delete a stream
In the following example a `global` stream named `quickStart` is deleted.
>**_Note:_** Append `c8locals.` instead of `c8globals.` to the stream name in case the stream is a local stream.

```python
client.delete_stream(stream="c8globals.quickStart")
```

# Stream Workers
Macrometa GDN allows you to integrate streaming data and take appropriate actions. Most stream processing use cases involve collecting, analyzing, and integrating or acting on data generated during business activities by various sources.
Refer [Stream Workers](https://macrometa.com/docs/cep/) and [Stream Worker Query Guide](https://macrometa.com/docs/cep/query-guide/)

## Basic operations for stream workers

[See the complete example here](./examples/stream_workers/stream_workers.py)

### Validate a stream worker
Validate the stream worker for syntax errors before saving.
To understand more about the stream worker definition please refer to the [Stream Worker Query Guide](https://macrometa.com/docs/cep/query-guide/)

In the following example a stream worker named `Sample-Cargo-App` with the following definition is validated.
```python
stream_app_definition = """
    @App:name('Sample-Cargo-App')
    @App:qlVersion("2")
    @App:description('Basic stream application to demonstrate reading data from input stream and store it in the collection. The stream and collections are automatically created if they do not already exist.')
    /**
    Testing the Stream Application:
        1. Open Stream SampleCargoAppDestStream in Console. The output can be monitored here.
        2. Upload following data into SampleCargoAppInputTable C8DB Collection
            {"weight": 1}
            {"weight": 2}
            {"weight": 3}
            {"weight": 4}
            {"weight": 5}
        3. Following messages would be shown on the SampleCargoAppDestStream Stream Console
            [2021-08-27T14:12:15.795Z] {"weight":1}
            [2021-08-27T14:12:15.799Z] {"weight":2}
            [2021-08-27T14:12:15.805Z] {"weight":3}
            [2021-08-27T14:12:15.809Z] {"weight":4}
            [2021-08-27T14:12:15.814Z] {"weight":5}
    */

    -- Create Table SampleCargoAppInputTable to process events.
    CREATE SOURCE SampleCargoAppInputTable WITH (type = 'database', collection = "SampleCargoAppInputTable", collection.type="doc", replication.type="global", map.type='json') (weight int);

    -- Create Stream SampleCargoAppDestStream
    CREATE SINK SampleCargoAppDestStream WITH (type = 'stream', stream = "SampleCargoAppDestStream", replication.type="local") (weight int);

    -- Data Processing
    @info(name='Query')
    INSERT INTO SampleCargoAppDestStream
    SELECT weight
    FROM SampleCargoAppInputTable;
    """
# Validate a stream application
client.validate_stream_app(data=stream_app_definition)
```

### Create a stream worker
Create the stream worker with the specified stream worker defintion on the specified list of regions. If list of regions is not specified then the stream worker is created on the nearest region.

In the following example a stream worker named `Sample-Cargo-App` with the definition specified in the validate stream worker example is created.
```python
regions = []
client.create_stream_app(data=stream_app_definition, dclist=regions)
```

### Enable or Disable a stream worker
Enable/Disable an already created specified stream worker.
In the following example a stream worker named `Sample-Cargo-App` w is first enabled then disabled.
```python
# Activate a stream application
client.activate_stream_app(streamapp_name="Sample-Cargo-App", activate=True)
# Deactivate a stream application
client.activate_stream_app(streamapp_name="Sample-Cargo-App", activate=False)
```

### Retrieve stream workers
Lists all existing stream workers.
```python
client.retrieve_stream_app()
```

### Update a stream worker
An already existing stream worker can be updated with a new definition on the specified list of regions. If list of regions is not specified then the stream worker is created on the nearest region. Once updated you can enable/disbale the stream worker again as you want.

In the following example we update the definition of an existing stream worker `Sample-Cargo-App` with the following and activate it.
```python
# To operate on created apps, you need to create an instance of the app
app = client._fabric.stream_app("Sample-Cargo-App")

# Update the app using
updated_definition = """
@App:name('Sample-Cargo-App')
@App:qlVersion("2")
@App:description('Basic stream application to demonstrate reading data from input stream and store it in the collection. Thestream and collections are automatically created if they do not already exist.')
/**
    Testing the Stream Application:
    1. Open Stream SampleCargoAppDestStream in Console. The output can be monitored here.
    2. Upload following data into SampleCargoAppInputTable C8DB Collection
        {"weight": 1}
        {"weight": 2}
        {"weight": 3}
        {"weight": 4}
        {"weight": 5}
    3. Following messages would be shown on the `SampleCargoAppDestStream` Stream Console.
        [2021-08-27T14:12:15.795Z] {"weight":1}
        [2021-08-27T14:12:15.799Z] {"weight":2}
        [2021-08-27T14:12:15.805Z] {"weight":3}
        [2021-08-27T14:12:15.809Z] {"weight":4}
        [2021-08-27T14:12:15.814Z] {"weight":5}
    4. Following messages would be stored into SampleCargoAppDestTable
        {"weight":1}
        {"weight":2}
        {"weight":3}
        {"weight":4}
        {"weight":5}
*/
-- Defines Table SampleCargoAppInputTable
CREATE SOURCE SampleCargoAppInputTable WITH (type = 'database', collection = "SampleCargoAppInputTable", collection.type="doc",replication.type="global", map.type='json') (weight int);

-- Define Stream SampleCargoAppDestStream
CREATE SINK SampleCargoAppDestStream WITH (type = 'stream', stream = "SampleCargoAppDestStream", replication.type="local") (weight int);
-- Defining a Destination table to dump the data from the stream
CREATE STORE SampleCargoAppDestTable WITH (type = 'database', stream = "SampleCargoAppDestTable") (weight int);

-- Data Processing
@info(name='Query')
INSERT INTO SampleCargoAppDestStream
SELECT weight
FROM SampleCargoAppInputTable;

-- Data Processing
@info(name='Dump')
INSERT INTO SampleCargoAppDestTable
SELECT weight
FROM SampleCargoAppInputTable;
"""

regions = []
app.update(data=updated_definition, dclist=regions)
# Update needs some wait time
time.sleep(5)
# Activate the updated stream worker
app.change_state(active=True)
```

### Get sample stream workers
Get the detailed list of smaple stream workers.
```python
# Get stream application samples
client.get_stream_app_samples()
```

### Delete a stream worker
In the following example, stream worker `Sample-Cargo-App` is deleted.
```python
# Delete a stream application
client.delete_stream_app(streamapp_name="Sample-Cargo-App")
```


text:
# Introduction

Welcome to Accellion's API Guide.

Our RESTful Enterprise API enables you to quickly develop apps that leverage the power of the Accellion Platform. Developers can build custom apps tailored to specific industry and business use cases, and integrate APIs within existing IT infrastructure.

Currently, the project board contains sample code snippets in PHP script which are displayed on the right panel of the board. Snippets in other languages will be added subsequently.

repository: accellionapis/api-guide

repo_name: accellionapis/api-guide


text:
A [GitHub](http://www.github.com) client created for [Code Fellows'](http://codefellows.org) iOS Development Accelerator Week 3.

##Monday:

- Implement a split view controller in your app to control your interface
- Create a network controller and implement a method that fetches repositories based on a search term. Instead of pointing the request at the Actual Github API server, use the node script provided in the class repository and point the request at your own machine. Since our apps aren't authenticated with Github yet we will hit the rate limit after 5 unauthenticated calls from our IP. The node script is called server.js. Just run it with your node command in terminal.
- Create a RepositoryViewController and parse through the JSON returned fromm the server into model objects and display the results in a table view.
- Devise a way to show the master view controller when the app is first launched on iPhone, not the detail view controller.

##Tuesday:

- Implement an OAuth workflow in your app that successfully lets the user authenticate with your app.
- Recreate a NSURLSession with a NSURLSessionConfiguration with the Authorization Header Field matched up with our oath token.
- Implement a UISearchBar on your repo search view controller and modify your repo search fetch method on your network controller to use the search bar’s text. Be sure to only be making authenticated network calls using your oath token!
- Display the repo’s they searched for a in the table view
- Implement user defaults to store the authorization token, so it only does the OAuth process once.

##Wednesday:

- Create a UserSearchViewController that searches for users, similar to how we are already searching for repositories. Instead of a table view, use a collection view to display the users avatar image and their name.
- Upon clicking on a cell, implement a custom transition, and transition the image clicked on to a UserDetailViewController page that has their picture, name, and whatever other info you want pulled from their API.

##Thursday:

- Implement Regex in your app. Use it to validate the characters the user types into the search bar. Extend String with this functionality.
- Implement WKWebView in your app. When a user clicks on a repo, show their repo's web page with WKWebView.

##Friendship Friday:
Done in conjunction with [Reid Weber](https://github.com/Reidweb1)

Challenges:

- Implement the 'My Profile' view controller in your app. This should display info about the currently logged in user (their bio, if they are hirable, their count of public and private repos, etc).
- Implement a way for the logged in user to create a repo from the app. Good luck and god bless.
- Implement a way for the user to update their bio.

repository: willrichman/GithubToGo

repo_name: willrichman/GithubToGo


text:
Krux Standard Java Library
==========================

> *Note* - Version 3.0.0 will be released soon!  For a preview of what's changing, see the
> [3.0 README](https://github.com/krux/java-stdlib/tree/v3)

The Krux Sandard Library is an easily-configurable library that provides a handful of capabilities common across all of Krux' JVM-based applications, including:

* A [Netty](http://netty.io)-based web server for handling HTTP-based status checks and custom URL handlers for app-specific needs
* A standard logging configuration, based on [SLF4J](http://www.slf4j.org), that ensures all logged events with severity >= WARN are writting to STDERR, and those with a severity <= INFO are written to STDOUT, which can be very useful for environments where individual application lifecycles are managed by external tooling that has strong opinions about log handling (such as [supervisord](http://supervisord.org))
* A [Statsd](https://github.com/etsy/statsd) client that automatically collects and submits common JVM statistics to a Statsd server, and a API for collecting and submitting custom application metrics
* A handful of useful tools for command-line parsing, managing a priority-based queue of application shutdown hooks, and other helpful utilities.

(If you're looking for our Python Standard Library, see [here](https://github.com/krux/python-krux-stdlib)).

# Using

To use, add the following dependency to your pom.xml:

```xml
<dependency>
  <groupId>com.krux</groupId>
  <artifactId>krux-stdlib</artifactId>
  <version>1.7.2</version>
</dependency>
```

# Basic Usage

For the simplest use case, simply call `KruxStdLib.initialize(args)` before running your app's main logic...

```java
public class ExampleMain {

		public static void main(String[] args) {
			KruxStdLib.initialize(args);

            //send a simple stat
            KruxStdLib.STATSD.count("my-app-started");

			//...do your stuff...

			//by default, will be written to STDOUT
			LOGGER.info("I've really done something.");

			//by default, will be written to STERR
            LOGGER.warn("I MUST DO MORE!");
	}
}
```

# Setting up the SLA handler

Example from a consumer service sending message timestamps to the `SlaClient` for verification.

```java
import com.krux.stdlib.utils.SlaClient;

public class messageProcessor {

    private static SlaClient _slaClient = SlaClient.getInstance();

    public onMessage(String message) {
       // send the message to the sla client to determine if the sla has been met
       SlaClient.checkTs(GifStreamParserUtil.getTSInMillis(recordParts));
    }
}
```

Testing the SLA endpoint

```bash
curl localhost:8080/__sla
```

This will setup slf4j (via log4j) bindings for stdout and stderr, establish a statsd client for use throughout your app via `KruxStdLib.STATSD`, and parse a standard set of command line options that all Krux apps should support. To see a list of the standard command line options, build an app that uses the stdlib as above, then pass '-h' or '--help' at the command line.  You will see output like...

```
Option                                       Description
------                                       -----------
--app-name                                   Application identifier, used for statsd namespaces, log
                                               file names, etc. If not supplied, will use this app's
                                               entry point classname. (default:
                                               TCPStreamListenerServer)
--base-dir                                   Base directory for app needs. (default: /tmp)
--env                                        Operating environment (default: dev)
-h, --help                                   Prints this helpful message
--heap-stats-interval-ms [Integer]           Interval (ms) for used heap statsd gauge (default: 1000)
--http-port [Integer]                        Accept http connections on this port (0 = web server
                                               will not start) (default: 0)
--log-level                                  Default log4j log level (default: DEBUG)
--stats                                      Enable/disable statsd broadcast
--stats-environment                          IGNORED for backward compatibility
--stats-host                                 Listening statsd host (default: localhost)
--stats-port [Integer]                       Listening statsd port (default: 8125)
--property-file [String]                     Path to an external property file, containing names of external resources
                                             such that vary by environment, such as a database server hostname.
--sla                                        SLA in seconds to return on the /__sla endpoint
```

In more advanced scenarios, you can specifiy custom command line options, set up shutdown hooks, tap into a standard HTTP listener and do other groovy things. See [a detailed example](https://github.com/krux/java-krux-stdlib/blob/master/src/main/java/com/krux/stdlib/sample/ExampleMain.java) for more complex uses.

repository: krux/java-stdlib

gha_language: Java

repo_name: krux/java-stdlib


text:
**Note**

> LibGDX provides [AssetManager](https://github.com/libgdx/libgdx/wiki/Managing-your-assets), which has a fully-fledged API for loading, storing and fetching assets (sounds, music, textures, fonts...). Using `AssetManager` (with maybe some DI framework) might be a more scalable and testable solution as projects grow in complexity. The manager modules (`ImageManager`, `SoundManger`, `MusicManager`...) may eventually become wrappers around `AssetManager`. Until then, they'll remain as singleton-based managers whose simplicity might come in handy for game jams or PoCs.

The [`image`]() extension is split in two classes: [`ImageManager`](https://github.com/ImXico/Cyberpunk/blob/master/image/src/main/kotlin/cyberpunk/image/ImageManager.kt) and [`ImageHelper`](https://github.com/ImXico/Cyberpunk/blob/master/image/src/main/kotlin/cyberpunk/image/ImageHelper.kt).

### ImageManager
This is made to be used with [`TextureAtlas`](https://libgdx.badlogicgames.com/nightlies/docs/api/com/badlogic/gdx/graphics/g2d/TextureAtlas.html). Information on how to use the TexturePacker to pack many smaller images onto larger images can be found [here](https://github.com/libgdx/libgdx/wiki/Texture-packer).

Say we've got `mypack.png` and `mypack.pack` from the Texture Packer inside our `assets` folder.

To load this pack and key it as `mypack`, we'd do the following:
```kotlin
ImageManager.load("mypack", "mypack.pack")
```

Alternatively, if you want the pack being loaded to be your default one, you can do:
```kotlin
ImageManager.load("mypack", "mypack.pack", setAsDefault = true)
```

To fetch a [`TextureRegion`](https://libgdx.badlogicgames.com/ci/nightlies/docs/api/com/badlogic/gdx/graphics/g2d/TextureAtlas.AtlasRegion.html) named `myregion` from the loaded `mypack` pack, you'd call:
```kotlin
ImageManager.take("myregion", "mypack")
```
If you set `mypack` as default, though, you'll be able to call `#take` without passing the atlas name explicitly:

```kotlin
ImageManager.take("myregion") // Implicit second argument: default pack key
```

Finally, you can dispose any atlas at any time:
```kotlin
ImageManager.disposeAtlas("mypack")
```

### ImageHelper
The [`ImageHelper`](https://github.com/ImXico/Cyberpunk/blob/master/image/src/main/kotlin/cyberpunk/image/ImageHelper.kt) grants a bunch of positioning utilities for your images. All functions of this mini extension return [`Vector2`](https://github.com/ImXico/Cyberpunk/blob/master/image/src/main/kotlin/cyberpunk/image/ImageHelper.kt) objects.

To center an image on the screen, you'd call:
```kotlin
ImageHelper.center(imageWidth, imageHeight, WORLD_WIDTH, WORLD_HEIGHT)
```

You can also choose to center only horizontally or vertically:
```kotlin
ImageHelper.centerX(imageWidth, WORLD_WIDTH, targetY)
ImageHelper.centerY(imageHeight, WORLD_HEIGHT, targetX)
```

Or even inside another image:
```kotlin
ImageHelper.centerOnImage(imageWidth, imageHeight, otherWidth, otherHeight, otherPosition)
```

![img](https://i.gyazo.com/b2b826b4cd321b6aa03a3cf97c36aa6b.png)

repository: androsparks/Cyberpunk

repo_name: androsparks/Cyberpunk


text:
# OpenBazaar + Zeronet

We are actively working to add OpenBazaar in [Zeronet](https://github.com/HelloZeroNet/ZeroNet).

## Reclaiming Darkmarket Project

[Darkmarket](https://www.youtube.com/watch?v=lHVqH8XO1Pk#t=86)

The original project share a vision of a community based uncensored freemarket. Openbazaar team fork the original project and after getting a [fund](https://blog.openbazaar.org/openbazaar-is-entering-a-new-phase-with-funding/) they seemed to missed the point. Openbazaar does not share the same vision and after mainnet version was released the only thing they share is disappointment among the bitcoin and opensource [communities](https://www.reddit.com/r/Buttcoin/comments/4f18b5/openbizarre_developer_gets_very_sad_locks_grammar/). It is [clearly] (https://www.youtube.com/watch?v=NXszuDQwGHw) that privacy and anonymization its not projects priority and the whole project was build in a protocol (rudp) that does not support tor or any other anonymization utilities. A freemarket cannot exist with a visible ip and indentities/activities easily associated with personnal info.

This projects aims to reclaim a community based project driven by community needs.

###Zeronet vs Openbazaar

*  Network stability / Not stable yet
*  Offers anonymity via tor hidden services / Ip is not hidden
*  Seeding shop/pages(no single point of failure) / If you close app your store goes offline (ipfs still in pre-alpha)
*  Running offline (browsing) / Running only with internet connection

###Donation

Sorry we missed the 1 M funding. Support this project:

Bitcoin address 182ADPcoAsLHowUUAMkmfChDSvnmXkE7tW

## License

>"Privacy: I know who you are, I don't know what you do. Anonymity: I know what you do, I don't know who you are. Don't confuse these two!"
>
> -- <cite>klaus j zimmermann</cite>

...but we want both.

repository: msgpo/OpenBazaar-Server

repo_name: msgpo/OpenBazaar-Server


text:
# paste-comma-separated

This is a Visual Studio Code extension that provides a command to paste your clipboard as a comma-separated list

Example:
```
Lorem ipsum dolor sit amet => Lorem,ipsum,dolor,sit,amet
```

Useful when copying with multi cursor

## Commands

`"paste-comma-separated.pasteCommaSeparated"`

By default, the shortcut is

Windows/Linux: `ctrl+alt+v`
Mac: `shift+cmd+v`

You can set your own shortcut, eg:

```
{
  "key": "ctrl+shift+alt+v",
  "command": "paste-comma-separated.pasteCommaSeparated",
}
```

## Release Notes

Check [CHANGELOG.md](CHANGELOG.md) for more this


text:
# Quizzy
Quizzy is an android application that aims to provide the teacher with a tool to evaluate his students.

[![License](https://img.shields.io/hexpm/l/plug.svg)](http://doge.mit-license.org)[![HitCount](http://hits.dwyl.io/MahmoudMabrok/Quizzy_app.svg)](http://hits.dwyl.io/MahmoudMabrok/Quizzy_app)

## Table of Contents
* [Synopsis](#Synopsis)
* [Recognition of Need](#Recognition-of-Need)
* [Related work](#Related-work)
* [Our Solution](#Our-Solution)
* [Inspiration](#Inspiration)
* [Technologies](#Technologies)
* [Features](#Features)
* [Screenshots](#Screenshots)
* [Video](#Video)
* [Required Info](#Required-Info)

## Synopsis
Software engineering is not only coding. In fact it is understanding society problems, gathering requirements, Designing solutions and lastly coding shows up as a single stage in the entire process. And to be able to recognize society problems and innovate a solution for them you must have a deep understanding of the society in which the problems appear. Based on that, we have decided to solve one of the problems in our educational system in Egypt in particular and in most developing countries in general because it is the system that we understand most as we are involved in it and suffer from its problems.

## Recognition of Need
One of the most important activities in the process of education is evaluation. Any professor, teacher or instructor needs to evaluate his students many times throughout the entire course period. Traditionally in developing countries like Egypt in order for this activity to be carried out, the instructor has to quiz his students many times. In each time the instructor has to print quizzes on papers, receive his students’ answers, evaluate them manually, and record their grades manually as well. This process may occur once a week and recall that in developing countries the number of students in a class may exceed a hundred or more. This process takes from 6 to 10 hours weekly for a given course and the instructor most frequently is in charge of more than one course. This process may take much time than what the process of teaching itself takes so it is a waste of time, effort and money.

## Related work
There are many tools that are dedicated to provide a powerful and collaborative learning environment which are known as LMSs (Learning Management Systems) . Here, we investigate only one of these systems which is **Moodle**.

#### Moodle
**Features**
* Provides a full-fledged, collaborative learning environment.
* Provides a smart android app for student.
* Can import quizzes or entire courses from Blackboard or WebCT.
* Student can download course contents, quizzes and access them offline but with less functionality of online access.

**Limitations**
* Administration is overwhelming and not user-friendly.
* Technical skills are needed to use the system.

## Our Solution
Quizzy provides a simple solution for the evaluation problem through a mobile application. Quizzy has been built with simplicity as one of the main requirements to fit developing countries. For the teacher, he/she simply renders the quiz and provides correct answers of the questions and let Quizzy evaluates students' answers automatically for him. For the student, he/she opens the quiz, solve the questions, submit, and let Quizzy tells him his grade on this quiz immediately after submitting.

## Inspiration
There have been two things inspired us to build Quizzy:
1. to compete in "IEEEmadc 2018" competition. "IEEEmadc" is a world-wide mobile application development competition organized by IEEE.
1. the egyptian government recently started to improve the educational process by providing each student a ‘Tablet’ device. That event has provided a fertilized environment for a digital solution like Quizzy.

## Technologies
Quizzy is built using:

Technology | Version
---------- | -------
Java | 8
Kotlin | 1.2.50
XML | 1.0
Firebase Services | 11.8.0
Facebook Login | [4,5)
Play Services Auth | 11.8.0
RxJava | 1.3.0
RxAndroid | 1.2.1
RxFirebase | 1.5.0
Dagger | 2.4
Butter Knife | 8.8.1
Crash Reporter | 1.0.9
Event Bus | 3.1.1
MP Android Chart | 3.0.3
Plain Pie | 0.2.9
LeonidsLib | 1.3.2
Fancy Walkthrough | 2.1
SpinKit | 1.2.0
Circular Progress Bar | 1.0.1

## Features
Quizzy provides several features including:
* User(Teacher/Student) can register/login using one of three methods:
  * Email/Password
  * Facebook account
  * Google account
* Teacher can render quizzes.
* Teacher can publish any quiz any time he wishes. Once a quiz is published, students can access and submit it.
* Teacher can specify a duration for a quiz. Once a student opens the quiz, a timer starts and once the time is over the student can not submit his/her answers.
* Till now, only multiple-choice questions are supported.
* Teacher can see reports on:
  * Individual quizzes.
  * Individual students.
* Student can access and submit any quiz once it is published by his/her teacher.
* Student can see his grade immediately after submitting the quiz.
* Student can see report on his performance in all quizzes.
* App rewards (and publish) students with high marks in each quiz as a motivation for students to do their best

## Screenshots
* Walkthrough

![Walkthrough GIF](https://github.com/MahmoudMabrok/Quizzy_app/blob/master/20181215_163439.gif)
* Login/Register
* Teacher Home

![ScreenShot 1](https://github.com/MahmoudMabrok/Quizzy_app/blob/master/Screenshots/Screenshot_20181215-223603.png)
* Student Home

* Creating Quiz by Teacher
* Accessing Quiz by Student

![ScreenShot 1](https://github.com/MahmoudMabrok/Quizzy_app/blob/master/Screenshots/Screenshot_20181215-224606.png)
* Reports for Teacher

![ScreenShot 1](https://github.com/MahmoudMabrok/Quizzy_app/blob/master/Screenshots/Screenshot_20181215-223541.png)
* Reports for Student
* Rewards

## Video
* Explanation

(https://youtu.be/mZVigv-Taz0)

## Required Info
Key | Value
--- | -----
App File Name | https://github.com/MahmoudMabrok/Quizzy_app/tree/master/APK
Short Description | Quizzy is an android application that aims to provide the teacher with a tool to evaluate his students.
Licence | Apache 2
Country | Egypt
Authors | Mahmoud Mabrouk https://github.com/MahmoudMabrok
 Hossam Abdelnaser https://github.com/hossamnasser938


text:
# xkcd-dl
Download all xkcd comics

## Installation
* Clone the [Git Repository](https://github.com/ninenine/xkcd-dl) and edit with your favorite editor. e.g. Visual Studio, Visual Studio Code
* Launch with `F5` or `Ctrl+F5` (The usual way)

## License
Released under the [MIT License](https://github.com/ninenine/xkcd-dl/blob/master/LICENSE).

[YOUR<EMAIL_ADDRESS>| [FOLLOW ME](https://twitter.com/davisknuckles)

repository: ninenine/xkcd-dl

repo_name: ninenine/xkcd-dl


text:
# Useful tips for Python

Some useful tips and concepts I learnt throught the time. This repo is organized
in folders. In each folder there are numbered Jupyter Notebooks. The numbers
are just an optional/personal order.

The code snippets and examples are from many sources: books, courses,
StackOverflow...

- [code_snippets folder](code_snippets): code snippets that are useful to
understand some topics

- [study_notes folder](study_notes): some personal study notes


text:
# How to configure EntityInfo components

> EntityInfo is a collection of data visualization components that allows an entity’s information to display by opening the side panel and loading its data inside. It assigns that flow to the "click" event of whatever tag element you define. The default is a DIV, but you can configure this to a button or any other element. (Note: This requires programming knowledge.)

EntityInfo allows you to create any HTML element (and HTML children) in a custom page. That element is assigned an _onClick_ event. That click opens the side panel and displays that entity’s info on the panel. It mimics the behavior of clicking a Card in the library: the entity’s info is shown on the side panel.

This component allows you to leave the design to the page coder, so there are no styles applied. You can turn this into a button, it could be an entire section of the page, or even an area inside a graph. You decide where to use it and Uwazi provides the "click" functionality.

```jsx
<EntityInfo entity="entitySharedId" tag="div" classname="classes">More Info</EntityInfo>
```

Creates an HTML element of the type described in tag ("div" is default and can be omitted) bound to a "click" event that will load and display in the side panel, the info of the entity described in the "entity" property. The element allows further HTML structure inside, which allows you to tailor the 'button' look however you want.

## Query component

This component allows you to do API request to fetch data you may need and expose it in a react [context](https://reactjs.org/docs/context.html) ([https://reactjs.org/docs/context.html](https://reactjs.org/docs/context.html)) for that page, for example:

```jsx
<Query name="entities" url="search?limit=10&order=desc&sort=creationDate"/>
```

Will search for the last 10 entities created and will store them in the "entities" dataset to be consumed. You can access this dataset with Value or Repeat for example.

## Value component

This component prints the value in a given path of the context . For example:

```jsx
<Query name="entities" url="search?limit=10&order=desc&sort=creationDate"/>
<Value path="entities.rows.0.title"/>
```

This example will request 10 entities and then print the title of the first one.

Repeat component

The purpose of this component is to iterate over data in the context and print its contents for each entry, for example:

```jsx
<Query name="entities" url="search?limit=10&order=desc&sort=creationDate"/>

<ul>
<Repeat path="entities.rows">
     <li><Value path="title"/></li>
</Repeat>
</ul>
```

## EntityLink component

This component will generate a link to the correct entity viewer based on a given entity property.

```jsx
<Query name="entities" url="search?limit=10&order=desc&sort=creationDate"/>

<ul>
<Repeat path="entities.rows">
    <li>
         <EntityLink><Value path="title"/></EntityLink>
    </li>
</Repeat>
</ul>
```

## EntityLink implementation

Right now EntityLink is a very basic component that expects an Entity object in the property key "entity" to generate a Link to that Entity. Because of this reason, when used in the Pages it needs to be wrapped in a Value component that is connected to the context and passes the entity down, like in the example:

```jsx
<Value propkey="entity"><EntityLink>Some text</EntityLink></Value>
```

repository: rempkay/uwazi-documentation

repo_name: rempkay/uwazi-documentation


text:
# Workspaces

Pre-defined arrangements of panels.

# Panels

A Panel is an `electron.BrowserWindow`

Panels may have background or child processes they are dependent on to show their content.

In development this could take the form of waiting for webpack development server, in production it
might take the form of spawning a child process and wanting to update the UI based on what happens.

repository: stylish/stylish

repo_name: stylish/stylish


text:
# InstaClone

#### This is a clone of the social media app Instagram ,Tuesday May 21, 2019
![Screenshot](Screenshot.png)

#### By **Mark Agimba**
## Description
This is an application that is similar the instagram application that lets a user like, comment on an photo, follow users and upload photos.
## BDD
The program lets the admin upload photos
* Example input: Upload photos
* Example output: Image is shown on timeline and profile

The program lets the user search for other users
* Example input: User keys in search term
* Example output: displays results based on search term

The program lets the user like photo
* Example input: User clicks on like icon
* Example output: likes increases by one

## Live Site
https://iclone1.herokuapp.com/

## Prerequisites
* Python
* Pip
* Django
* Postgres

## Setup/Installation Requirements
* https://github.com/MarkAgimba/InstaClone
* download the zip file
* unzip it on your documents folder
* open the folder on your preferred text/code editor
* -install dependancies in requirements.txt file pip install -r requirements.txt

* -Create a virtual environment ($ python3.6 -m venv virtual)

* -Activate Virtual Environmrnt. ($ source virtual/bin/activate)

* -Run The Project-: ($ python manage.py runserver)

## Known Bugs
None

## Technologies used
* Python3.7
* Django
* PostgreSQL
* HTML5
* CSS
* Bootstrap

## Support and contact details
Contact me on github :https://github.com/MarkAgimba

### License
Mark Agimba - ([MIT License](https://github.com/MarkAgimba/InstaClone/blob/master/LICENSE))

repository: MarkAgimba/InstaClone

repo_name: MarkAgimba/InstaClone


text:
# Reference Material
## For DataSet:
Link to problem statement: https://pan.webis.de/clef17/pan17-web/author-clustering.html

Link to published Paper: https://dl.acm.org/doi/abs/10.1145/3368567.3368572

# Usage

* Please use Quick_main.py to quickly run the project using the saved vectors for the documents in each problem folder.
* You can also take the benefit of the Quick_main.ipynb.
* Note: You may set the path according to your diretory of the access. If there is Error because of the path for the required files.
---
For Training you may peek into main.py

# Requirements
## Pretrained Models ( Easily available on Internet )
* GoogleNews-vectors-negative300.bin.gz
* wiki.nl.bin
* wiki.el.bin

repository: luckyagarwal/author-clustering

repo_name: luckyagarwal/author-clustering


text:
# Gloeocystidium triste var. deviatum S. Lundell, 1950 VARIETY

#### Status
SYNONYM

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

#### Published in
Fungi Exsiccati Suecici 38: 27 (1950)

#### Original name
Gloeocystidium triste var. deviatum S. Lundell, 1950

### Remarks
null

repository: mdoering/backbone

path: /life/Fungi/Basidiomycota/Agaricomycetes/Polyporales/Meruliaceae/Hyphoderma/Hyphoderma deviatum/ Syn. Gloeocystidium triste deviatum/README.md

repo_name: mdoering/backbone