text:
# Contactually-Ruby

[![Code Climate](https://codeclimate.com/github/revaluate/contactually-ruby/badges/gpa.svg)](https://codeclimate.com/github/revaluate/contactually-ruby)
[![Build
Status](https://travis-ci.org/revaluate/contactually-ruby.svg?branch=master)](https://travis-ci.org/revaluate/contactually-ruby)

This is a simple API Wrapper for the Contactually API. It is not feature complete, as it does not support all available API endpoints yet, but should work for most use cases this will be fine. Feel free to contribute!

## Installation

Add this line to your application's Gemfile:

    gem 'contactually-ruby'

And then execute:

    $ bundle

Or install it yourself as:

    $ gem install contactually-ruby

## Usage

### Configuration

As `contactually-ruby` is shipped with sensible defaults, that will allow you
to start right away, there are a couple of settings you may want to adjust,
depending on your applications requirements.

The available configuration options are:

* access_token (your contactually access_token)
* contactually_url (Default: "https://api.contactually.com/v2/")

#### Get an access_token:
1. [Register a new app](https://www.contactually.com/developer/applications).
Permission scopes are [here](https://developers.contactually.com/docs/auth/#oauth2-authorize)
`all:manage` is full access

2. put in a junk (but valid) url in the redirect URL - aka https://test.my-app-url-is-fake.com
3. click the 'authorize' link under the callback url - copy the `code` in the URL string
you'll also need the `application id` & `secret` from your application page you just created

4. `curl -H "Content-Type: application/json" -X POST -d '{"grant_type": "authorization_code", "client_id": "your_application_id", "client_secret": "secret_from_application_page", "code": "code_from_auth_url", "redirect_uri": "your_callback_url"}' https://auth.contactually.com/oauth2/token`

5. The response to that (assuming you did it all correctly) will be your access_token

Configuration goes as follows:

```ruby
    Contactually.configure do |c|
      c.access_token         = "TOKEN FROM OAUTH"
    end
```

#### How to use the gem

```ruby
    contactually = Contactually::API.new
    contacts = contactually.contacts.index
    # => [#<Contactually::Contact id=1234, ...>, #<Contactually::Contact id=1235, ...>, ...]
    notes = contactually.notes.index
    # => [#<Contactually::Note id=2345, ...>, #<Contactually::Note id=2346, ...>, ...]
    groupings = contactually.groupings.index
    # => [#<Contactually::Grouping id=3456, ...>, #<Contactually::Grouping id=3457, ...>, ...]

    contact = { contact: { first_name: 'Jane', last_name: 'Doe', ... } }
    contactually.contacts.create(contact)
    # => #<Contactually::Contact id=9876, first_name='Jane', last_name='Doe', ...>
```

Implemented endpoints are:

* Accounts
* Buckets
* Contact Groupings
* Contacts
* Contents
* Groupings
* Interactions
* Notes
* Tasks

The API is documented here: [Contactually API Docs](http://developers.contactually.com/docs/)

## Contributing

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

repository: revaluate/contactually-ruby

gha_language: Ruby

repo_name: revaluate/contactually-ruby


text:
# FrontYAML

An implementation of YAML Front matter for PHP. It can parse both YAML **and** Markdown.

[![Total Downloads](https://poser.pugx.org/mnapoli/front-yaml/downloads.svg)](https://packagist.org/packages/mnapoli/front-yaml)

## Installation

Require the project with Composer:

```
composer require mnapoli/front-yaml
```

## Usage

```php
$parser = new Mni\FrontYAML\Parser;

$document = $parser->parse($str);

$yaml = $document->getYAML();
$html = $document->getContent();
```

If you don't want the Markdown to be parsed (maybe because it is not Markdown):

```php
$document = $parser->parse($str, false);
```

## Example

The following file:

```markdown
---
foo: bar
---
This is **strong**.
```

Will give:

```php
var_export($document->getYAML());
// array("foo" => "bar")

var_export($document->getContent());
// "<p>This is <strong>strong</strong></p>"
```

## YAML and Markdown parsers

```php
$parser = new Mni\FrontYAML\Parser($yamlParser, $markdownParser);
```

This library uses dependency injection and abstraction to allow you to provide your own YAML or Markdown parser.

```php
interface YAMLParser
{
    public function parse($yaml);
}
```

FrontYAML uses by default [Symfony's YAML parser](http://symfony.com/doc/current/components/yaml/introduction.html).

```php
interface MarkdownParser
{
    public function parse($markdown);
}
```

FrontYAML uses by default the [League CommonMark parser](https://github.com/thephpleague/commonmark).

license: MIT

repository: mnapoli/FrontYAML

branch_name: refs/heads/master

extension: md

gha_language: PHP

gha_license_id: NOASSERTION

license_type: permissive

repo_name: mnapoli/FrontYAML


text:
+++

date = "2020-04-14"

title = "Illustrator - symbols"

draft = false

categories = ["illustrator"]

tags = ["vector", "lists", "illustrator"]

+++

**introduction to creating and using Symbols in Adobe Illustrator**

<!--more-->

Symbols are a way to save and store elements so they can be reused. You can alter the main symbol element and it updates across all instances or you can make variations on individual instances. Even better, there are Symbol Spray tools that allow you to alter and randomize entire groups of symbols.

- [Symbols from Adobe Help](https://helpx.adobe.com/illustrator/using/symbols.html) - a good introduction directly from the source

- [Illustrator tutorial: What are symbols and how do I use them? video from lynda.com](https://youtu.be/E9B8p6t7MZM) - good intro tutorial video

- [Design more efficiently with Dynamic Symbols from Adobe Help](https://helpx.adobe.com/illustrator/how-to/dynamic-symbols.html) - tutorial showing how to add and edit symbols for variations

- [Symbol sprayer tool in Illustrator with Dansky](https://youtu.be/AZnGrjFQeXI) - video tutorial on how to get started with spraying variations of your symbols

- [Illustrator: Using the Symbol Sprayer Tool from Erik Bernskiold](https://youtu.be/uvN_iHuJ-cc) - video tutorial showing application of symbol sprayer tools

I would like for you to create your own symbols for this project because it is good to make your own art. When you are stuck for time, however, you will find there are tons of premade symbols you can download from the internet.

## GRAPHIC STYLES

Graphic Styles are a way to save special effects that have been applied to an element so that the same effects can be added to multiple elements. This is especially powerful when you want visual consistency across many elements or sets.

- [Graphic styles from Adobe Help](https://helpx.adobe.com/illustrator/using/graphic-styles.html) - good introduction directly from Adobe

- [Get to Know Graphic Styles in Illustrator from Adobe Blog](https://theblog.adobe.com/get-know-graphic-styles-illustrator/) - a more visual introduction

- [How to Create Your Own Graphic Styles In Illustrator video from RetroSupply](https://youtu.be/NmbC9b77niA) - perfect little demo video

- [42 Awesome Graphic Styles and Appearance Panel Tutorials on Tuts+](https://design.tutsplus.com/articles/42-awesome-graphic-styles-and-appearance-panel-tutorials-on-tuts--cms-20833) - great collection of different effects and how to build them

I would like for you to create your own graphic styles for this project because it is good to make your own art. When you are stuck for time, however, you will find there are tons of premade styles can download from the internet.

## BLENDS

Blends are a good way to create a progressive rhythm that transitions from one state to another. They are also a quick and easy way to find variations on a spectrum between two extremes.

- [Illustrator's Blend Tool: A Comprehensive Guide from design tuts](https://design.tutsplus.com/tutorials/illustrators-blend-tool-a-comprehensive-guide--vector-551) - nice guide with lots of visual examples

- [How To Use The Blend Tool in Adobe Illustrator CC from vectortwist](https://vectortwist.com/illustrator-blend-tool-tips/) - outstanding list of variations and applications

- [How to Create Color Transition with Blend Tool in Adobe Illustrator from designmodo](https://designmodo.com/color-transition-blend-tool/) - great examples of cool blend effects

- [How To Make Minimalistic Line Drawings from Adobe Create](https://create.adobe.com/2017/3/22/simple_yet_stunning_how_to_create_artwork_with_illustrator_s_blend_tool.html) - really cool effect using Blends

repository: chad-bennett/start

repo_name: chad-bennett/start


text:
---
meta:
  - name: description
    content: Use AuthenticationClient
---

# Use AuthenticationClient

<LastUpdated/>

`AuthenticationClient` includes methods such as registering and logging in, resetting mobile phone number email, modifying account information, etc. It is requested as your end user, suitable for use in **browsers** and backend environments.

If you need to use basic login registration, modify user information, etc., please use:

::: page-ref /en/reference/sdk-for-node/authentication/AuthenticationClient.md
:::

If you need to use the WeChat Mini Program QR code login or other APP QR code login, please use:

::: page-ref /en/reference/sdk-for-node/authentication/QrCodeAuthenticationClient.md
:::

If you need multi-factor authentication, please use:

::: page-ref /en/reference/sdk-for-node/authentication/MfaAuthenticationClient.md
:::

If you need to use social authentication, please use:

::: page-ref /en/reference/sdk-for-node/authentication/SocialAuthenticationClient.md
:::

repository: Authing/docs

branch_name: refs/heads/main

gha_language: JavaScript

gha_license_id: MIT

repo_name: Authing/docs


text:
# Dx Flash Message

Fixed tile notification message, slides in from side or top of viewport.

**Note:** The show/hide state of the message is determined by the parent component.

## Usage
```
{props.showFlashMessage
  ? <FlashMessage
    type='error'
    messageHeader='Oops!'
    messageText='That didn\'t quite go as we had hoped.'
    closeFlash={this.toggleFlashMsg}
  />
  :
}
```

## FlashMessage props
### `type: string ('error' | 'warning' | 'success')`
Theme for the flash message. Can be one of the three above themes.

### `messageHeader: string`
Header text of the flash message.

### `messageText: string`
Content / body of the flash message.

### `closeFlash: function`
Action triggered by the `X` in the flash message, to toggle top level `showFlash` boolean.

license: ISC,MIT

repository: chrismllr/dx-component-kit-react

detected_licenses: ISC MIT

repo_name: chrismllr/dx-component-kit-react


text:
# Meta-Learning & Computer Vision

This directory contains meta-learning examples and reproductions for common computer vision benchmarks.

## maml_omniglot.py

This file reproduces MAML on the Omniglot dataset.
The CNN results can be obtained by swapping `OmniglotFC` with `OmniglotCNN`.
As far as we know, the hyper-parameters should also replicate the 5-ways 5-shots setting.

Note that the original MAML paper trains with 1 fast adaptation step, but tests with 3 steps.
This implementation only provides the training code.

**Results**

| Setup                         | Original      | learn2learn  |
| ----------------------------- | ------------- | ------------ |
| FC, 1 shot, 5 ways, 1 step    | 89.7%         | 88.9%        |
| CNN, 1 shot, 5 ways, 1 step   | 98.7%         | 99.1%        |

**Usage**

~~~shell
python examples/vision/maml_omniglot.py
~~~

**Colab** Follow [this link](https://colab.research.google.com/drive/1N1vtHAPJBaJO1wD30b_fnwPOWDorm_gP) to see this example live on Google Colab.

## maml_miniimagenet.py

This file reproduces MAML on the *mini*-ImageNet dataset.
The FOMAML results can be obtained by setting `first_order=True` in the `MAML` wrapper.

Note that the original MAML paper trains with 5 fast adaptation step, but tests with 10 steps.
This implementation only provides the training code.

**Results**

| Setup                         | Original      | learn2learn  |
| ----------------------------- | ------------- | ------------ |
| CNN, 1 shot, 5 ways, 5 step   | 48.7%         | 48.3%        |
| CNN, 5 shot, 5 ways, 5 step   | 63.1%         | 64.8%        |

**Usage**

~~~shell
python examples/vision/maml_miniimagenet.py
~~~

**Colab** Follow [this link](https://colab.research.google.com/drive/1NIWbMYM3CercnoNMmlhre7hsJ8wMtAry) to see this example live on Google Colab.

## protonet_miniimagenet.py

This file reproduces protonet on the *mini*-ImageNet dataset.

This implementation provides training and testing code.

**Results**

| Setup                         | Original      | learn2learn  |
| ----------------------------- | ------------- | ------------ |
| CNN, 1 shot, 5 ways           | 49.4%         | 49.1%        |
| CNN, 5 shot, 5 ways           | 68.2%         | 66.5%        |

**Usage**

For 1 shot 5 ways
~~~shell
python examples/vision/protonet_miniimagenet.py
~~~

For 5 shot 5 ways
~~~shell
python examples/vision/protonet_miniimagenet.py --shot 5 --train-way 20
~~~


text:
---
layout: default
---

# 1994-05-29 - WNSTORM on ftp.wimsey.bc.ca

## Header Data

From<EMAIL_ADDRESS>(Arsen Ray Arachelian)

To<EMAIL_ADDRESS>Message Hash: ee825b1e9ae022a9d041bb802361c38fe2e7c82c08b42967c93718869c080d89

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1994-05-29 17:59:55 UTC

Raw Date: Sun, 29 May 94 10:59:55 PDT

## Raw message

```
{% raw  %}From<EMAIL_ADDRESS>(Arsen Ray Arachelian)
Date: Sun, 29 May 94 10:59:55 PDT
To<EMAIL_ADDRESS>Subject: WNSTORM on ftp.wimsey.bc.ca
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text

I've just ftp'ed this to ftp.wimsey.bc.ca...  it's in the /uploads/WNS210
directory.

{% endraw %}
```

## Thread

+ Return to [May 1994](/archive/1994/05)

+ Return to<EMAIL_ADDRESS>(Arsen Ray Arachelian)](/authors/rarachel_at_prism_poly_edu_arsen_ray_arachelian_)"

+ 1994-05-29 (Sun, 29 May 94 10:59:55 PDT) - WNSTORM on ftp.wimsey.bc.ca -<EMAIL_ADDRESS>(Arsen Ray Arachelian)_


text:
## THUIAR Multimodal Emotion Recognization in Conversation

### Content

- Introduction.
- Baseline Classifications And Implement (Public).
- Updates And Timeline.

### Introduction

**Emotion Recognization in Conversation(ERC)** is one of the most popular subtasks of utterance-level dialogue

 understanding. The task is to predict the emotion labels (happy, sad, neutral, angry, excited, frustrated,

disgust, and fear) of the constituent utterance, where each utterance is uttered by one specific speaker.

### Classification of existing methods

All existing model can be classified into 4 classes:

1. Context Modeling Methods;
2. Methods Transfered from **Multimodal Sentiment Analysis(MSA)** ;
3.  Memory Network Methods;
4. Graph Neural Network Methods;

#### Context Modeling Methods

This kind of Methods focus on Modeling **CONTROLLING VARIABLES IN CONVERSATIONS** (proposed in

 the survey "Emotion Recognition in Conversation: Research Challenges, Datasets, and Recent Advances")

  and **build complex context control module**.

Typical Methods：

1. bc-lstm: Context-Dependent Sentiment Analysis in User-Generated Videos [2017 02]
2. DialogueRnn: DialogueRNN: An Attentive RNN for Emotion Detection in Conversations [2019 05]

Our Code Base: **NOW SUPPORT bc-lstm & dialogueRnn on IEMOCAP & MELD**

																	TO BE CONTINUE …

#### Methods Transfered from MSA

This kind of Methods focus on how to use multimodal information on different multimodal datasets.

 But failed to take different speaker & speaker's history utterance into account. They are usually used

 to verify proposed multimodal methods having the ability of modeling context & speakers' info.

Typical Methods:

1. TFN :Tensor Fusion Network for Multimodal Sentiment Analysis [2017 07]
2. MFN: Memory Fusion Network for Multi-view Sequential Learning [2018 02]

Our Code Base: **NOW DEVELOPING**

																	TO BE CONTINUE …

#### Memory Network Methods

In the literature, memory networks have been successfully applied in many areas, including

question-answering, machine translation, speech recognition, and others. Inspired by its capabilities of

context modeling, Multi-hops  Memory Network is proposed in ERC Tasks, and verified to be effective.

Typical Methods:

1. CMN: CMN-Interactive conversational memory network for multimodal emotion detection [2018 06]
2. ICON: ICON Interactive conversational memory network for multimodal emotion detection [2018 xx]

Our Code Base: **NOW DEVELOPING**

																	TO BE CONTINUE …

#### Graph Neural Network Methods

This kind of Methods use different Graph Neural Network to make improvements in ERC tasks.

Typical Methods:

1. Congcn: Modeling both Context-and Speaker-Sensitive Dependence for Emotion Detect-

   ion in Multi-speaker Conversations [2019 01]

2. DialogueGCN: Dialoguegcn- A graph convolutional neural network for emotion recognition

    in conversation [2019 08]

Our Code Base: **NOW DEVELOPING**

																	TO BE CONTINUE …


text:
### Simple Authentication Token

A simple example that shows how to use the JWT authentication library with a REST API. This example uses an in memory
user for testing.

To login, you send an HTTP request passing in the username and credentials like te following:

```http
POST http://localhost:8080/api/v1/login
Content-type: application/json

{"username":"john","password":"pass"}
```

As the response you get the JWT authentication token:

```json
{
  "token":"eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJqb2huIiwicm9sZXMiOlsiVVNFUiJdLCJleHAiOjE1MzI4MDYyNjYsImlhdCI6MTUzMjc3NzQ2Nn0.r0ufzALuuvlz6Lwdmnv4NymPNia2FQGv0ClOfA87Xfc"
}
```

This JWT token can be used to make a secure request like the following:
```http
GET http://localhost:8080/api/v1/secure
Authorization:  Bearer eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJqb2huIiwicm9sZXMiOlsiVVNFUiJdLCJleHAiOjE1MzI4MDYyNjYsImlhdCI6MTUzMjc3NzQ2Nn0.r0ufzALuuvlz6Lwdmnv4NymPNia2FQGv0ClOfA87Xfc
```

which gets the following response:
```json
{"message":"Hello John!"}
```


text:
# Install-OpenCV-Jetson-Xavier (NX, AGX)
![output image]( https://qengineering.eu/images/LogoOpenJetsonGitHub.webp )

*This is the fork of Install-OpenCV-Jetson-Nano from [Q-engineering](https://github.com/Qengineering/Install-OpenCV-Jetson-Nano)*

## OpenCV installation script for a Jetson Xavier

[![License](https://img.shields.io/badge/License-BSD%203--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)

This is the full setup of OpenCV with CUDA and cuDNN support for the Jetson Xavier.

For reference information see [Q-engineering - Install OpenCV Jetson Nano](https://qengineering.eu/install-opencv-4.5-on-jetson-nano.html)

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

# Attention!
>This script will not work on Jetson Nano!

> Even if it will build, your OpenCV will fail with SEGV on imread, imshow etc.

For Jetson Nano script look [here](https://github.com/Qengineering/Install-OpenCV-Jetson-Nano)
# Before installation
* Build can take up to 5 hours, so be prepared to wait for a while.

* Check that you have CUDA and cuDNN installed:
    ```shell
    $ dpkg -l | grep cuda
    ```
* Check your total FREE memory (RAM + swap) first for a fast build. You need at least a total of:
    >OpenCV 4.5.4 -> 8.5 GB!

    OpenCV 4.5.3 -> 8.5 GB!

    OpenCV 4.5.2 -> 8.5 GB!

    OpenCV 4.5.1 -> 6.5 GB

    OpenCV 4.5.0 -> 6.5 GB

    If not, enlarge your swap space as explained in the guide, or only 1 core will be used for the compilation.

* Xavier has enough RAM to build in 8-core way, but for stability reasons, we will use only 6 CPU cores.

Change NO_JOB=8 if you are brave enough (highly NOT recomended).

# Installation
```shell
$ free -m

$ wget https://github.com/Hexerpowers/Install-OpenCV-Jetson-Xavier/raw/main/OpenCV-4-5-x.sh

$ sudo chmod 755 ./OpenCV-4-5-x.sh

$ ./OpenCV-4-5-x.sh
```
:point_right: Don't forget to reset your swap memory afterwards.

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

If you want to beautify OpenCV with the Qt5 GUI you need to
- $ sudo apt-get install qt5-default
- Set the -D WITH_QT=**ON** \ (± line 62) in the script

before running the script on your Xavier

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

OpenCV will be installed to the `/usr` directory, all files will be copied to following locations:

- `/usr/bin` - executable files

- `/usr/lib/aarch64-linux-gnu` - libraries (.so)

- `/usr/lib/aarch64-linux-gnu/cmake/opencv4` - cmake package

- `/usr/include/opencv4` - headers

- `/usr/share/opencv4` - other files (e.g. trained cascades in XML format)


text:
---
layout: leaf-node
title: "Choosing Qualitative Research: A Primer for Technology Education Researchers"
title-url: "http://scholar.lib.vt.edu/ejournals/JTE/v9n1/hoepfl.html"
author: [ "Marie C. Hoepfl" ]
groups: [ "research-principles-and-methodologies" ]
categories: [ "qualitative-research" ]
topics: [ "scholarly-readings" ]
summary: >
  There are compelling reasons for the selection of qualitative methodologies within the educational research arena, yet many people remain unfamiliar with these methods. Researchers trained in the use of quantitative designs face real challenges when called upon to use or teach qualitative research ( Stallings, 1995 ). There is, however, a growing body of literature devoted to qualitative research in education, some of which is synthesized here. The goals of this article are to elaborate on the reasons for choosing qualitative methodologies, and to provide a basic introduction to the features of this type of research.
cite: >
  Hoepfl, M. C. (1997). Choosing qualitative research: A primer for technology education researchers.
pub-date: 1997-01-01
added_date: 2017-04-29
resource-type: external-page
---

gha_language: HTML


text:
# react-local-redux

Manage component-specific state as you would global state via redux

## Table of contents

- [Summary](#summary)
- [Usage](#usage)
- [connectLocal](#connectlocal)
  - [Options](#options)
- [Additional imports](#additional-imports)
  - [createActionCreator](#createactioncreator)
  - [createReducer](#createreducer)

## Summary

The [`redux`](https://github.com/reduxjs/redux) library has changed the way that we manage state within our JavaScript applications, and is a wonderful tool. Like many great tools, though, developers see it as a hammer in a world of nails, using `redux` for all state regardless of whether it should be global or not. The creator of `redux` himself [has even written about how `redux` should be used selectively](https://medium.com/@dan_abramov/you-might-not-need-redux-be46360cf367), because `redux` is meant for global state.

`react-local-redux` tries to strike a balance, leveraging the powers of the `redux` paradigm but keeping state that does not need to be global scoped to the component that it should live in by creating a higher-order component that operates like a local store. It's usage should come naturally to those who have used [`react-redux`](https://github.com/reduxjs/react-redux), you can [use `redux` middlewares and enhancers](#options), and there are even helpers to remove boilerplate related to building [action creators](#createactioncreator) and [reducers](#createreducer).

## Usage

```javascript
import { connectLocal } from "react-local-redux";

const actionCreators = {
  decrement: () => ({ type: "DECREMENT" }),
  increment: () => ({ type: "INCREMENT" })
};

const reducer = (state = { count: 0 }, action) => {
  switch (action.type) {
    case "DECREMENT":
      return {
        ...state,
        count: state.count - 1
      };

    case "INCREMENT":
      return {
        ...state,
        count: state.count + 1
      };

    default:
      return state;
  }
};

@connectLocal(reducer, actionCreators)
class App extends Component {
  render() {
    const {count, decrement, increment} = this.props;

    return (
      <div>
        <div>Count: {count}</div>

        <button onClick={decrement}>Decrement</button>
        <button onClick={increment}>Increment</button>
      </div>
    );
  }
}
```

## connectLocal

`connectLocal(reducer: function[, actionCreators: (function|Object)[, options: Object]]) => (ComponentToWrap: ReactComponent): ReactComponent`

Decorator that accepts a `reducer` function and `actionCreators`, returning a function that accepts a `ReactComponent` and returns a higher-order `ReactComponent`.

If `actionCreators` is an object of functions, it will automatically wrap those functions in `dispatch`, and if it is a function then it will handle the following contract:

`actionCreators(dispatch: function, ownProps: Object): Object`

This should operate the exact same as `mapDispatchToProps` in `react-redux`.

Internally the `reducer` will be used as local state, with each of the `actionCreators` being used to update that state. Both the local state and the wrapped `actionCreators` will be passed to the `ComponentToWrap` as props, very much align the lines of `connect` in the `react-redux` package. If no `actionCreators` are passed, the `dispatch` method itself will be passed as a prop to the `ComponentToWrap`.

#### options

Like `connect` in `react-redux`, you can pass an object of `options` to customize how `connectLocal` will operate:

- `pure: boolean`
  - is the component considered a "pure" component, meaning does it only update when props / state / context has changed based on strict equality
- `areOwnPropsEqual(currentProps: Object, nextProps: Object): boolean`
  - custom props equality comparator
- `areStatesEqual(currentState: Object, nextState: Object): boolean`
  - custom states equality comparator
- `areStatesEqual(mergedProps: Object, nextMergedProps: Object): boolean`
  - custom equality comparator for the merged state, actionCreators, and props passed to the component

Additionally, there are some options specific to `connectLocal` that provide more functionality:

- `enhancer(fn: function): function`
  - store enhancer used in `redux.createStore()`

```javascript
@connectLocal(reducer, actionCreators, {
  enhancer: window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__({
    name: 'MySpecialComponent'
  })
})
```

- `middlewares: Array<function>`
  - array of redux middlewares to be appled to the `dispatch` method

```javascript
@connectLocal(reducer, actionCreators, {middlewares: [reduxThunk]})
```

- `mergeProps(state: Object, actionCreators: Object, props: Object): Object`
  - custom method to merge state, actionCreators, and props into the props passed to the component

## Additional imports

Additional imports are available for handling construction of action creators and reducers. The paradigm will be familiar to those who have used the [`redux-actions`](https://github.com/redux-utilities/redux-actions) library.

#### createActionCreator

`createActionCreator(type: string[, payloadHandler: function = identity[, metaHandler: function = noop]]): function`

Create a Flux Standard Action in the same vein as `redux-actions`.

```javascript
const addStuff = createActionCreator("ADD_STUFF");

addStuff({ added: "stuff" });
// {payload: {added: 'stuff'}, type: 'ADD_STUFF'}
```

By default, the first parameter passed to the action creator will be used as the payload, but you can provide custom handlers for the payload and the meta if desired.

```javascript
const addStuff = createActionCreator(
  "ADD_STUFF",
  ({ added }) => added,
  ({ added }) => added === "stuff"
);

addStuff({ added: "stuff" });
// {meta: true, payload: 'stuff', type: 'ADD_STUFF'}
```

Additionally, if an error is provided as the payload, an `error` property will be automatically set to `true` on the action.

#### createReducer

`createReducer(handlers: Object, initialState: Object): function`

Create a reducer based on a map of handlers, each themselves a reducer.

```javascript
const handlers = {
  SET_THING; (state, {payload}) => ({
    ...state,
    thing: payload,
  }),
};

const initialState = {
  thing: null,
};

const reducer = createReducer(handlers, initialState);

const result = reducer(initialState, {payload: 'new thing', type: 'SET_THING'});
// {thing: 'new thing'}
```

## Development

Standard stuff, clone the repo and `npm install` dependencies. The npm scripts available:

- `build` => run webpack to build development `dist` file with NODE_ENV=development
- `build:minified` => run webpack to build production `dist` file with NODE_ENV=production
- `dev` => run webpack dev server to run example app / playground
- `dist` => runs `build` and `build:minified`
- `lint` => run ESLint against all files in the `src` folder
- `prepublish` => runs `prepublish:compile` when publishing
- `prepublish:compile` => run `lint`, `test:coverage`, `transpile:es`, `transpile:lib`, `dist`
- `test` => run AVA test functions with `NODE_ENV=test`
- `test:coverage` => run `test` but with `nyc` for coverage checker
- `test:watch` => run `test`, but with persistent watcher
- `transpile:lib` => run babel against all files in `src` to create files in `lib`
- `transpile:es` => run babel against all files in `src` to create files in `es`, preserving ES2015 modules (for
  [`pkg.module`](https://github.com/rollup/rollup/wiki/pkg.module))

repository: planttheidea/react-local-redux

repo_name: planttheidea/react-local-redux


text:
Astarte Data Updater Plant
==========================

**astarte_data_updater_plant has been moved to
https://github.com/astarte-platform/astarte/tree/master/apps/astarte_data_updater_plant .**

This repository has been archived, development is no longer happening here.

New [issues](https://github.com/astarte-platform/astarte/issues) or
[pull requests](https://github.com/astarte-platform/astarte/pulls) should be opened against
[astarte](https://github.com/astarte-platform/astarte) main repository.

<img src="data_updater_astarte_overview.svg" align="center" />

gha_language: Elixir


text:
Insolar – Application Layer
==================================================
Proof-Of-Concept, platform for realizations of dApps.

Overview
--------
Application module describes interaction of system components with each other.

Every component of the system is a `SmartContract`. Members of the system are given the opportunity to build their own dApps by publishing smart contracts in `Domain` instances.

Domains define the visibility scope for the child contracts and their interaction policies. Actually, `Domain` is subclass of `SmartContract`.

SmartContract
--------
TODO

Proxy
--------
TODO

Authorization & Certification
---------
TODO

repository: AndreyBronin/insolar

gha_language: Go

repo_name: AndreyBronin/insolar


text:
# CityTravel
Simple web application that uses JSP/Servlet technology

---

# Problem Task

Solve the following problem using the JSP/Servlet technology. State information (between web requests) is always stored in a database;<br/> you may store some state information in cookies/session objects. Write a web application for choosing a transportation route. The database
has a list of cities, each having a list of neighboring cities. The displays a web page with the current station chosen by the user and all    the neighboring cities to which this station is connected. The user can then choose a new destination which becomes the new current   station   and so on... At any time the user can specify that the current station is the final destination and in this case,   the application displays the complete route selected by the user so far. The user should also be able to change his/her mind and   come back to a previously selected station and change it.

----

#  Some specific requirements

All web pages should be accessible only if the user logs in using a username and a password (create a session each time a user logs in,   and destroy the session when the user logs out). Have in mind the user experience when you implement the problem:

- add different validation logic for input fields
- do not force the user to input an ID for an item if he wants to delete/edit/insert it; this should happen automatically (e.g. the user - - clicks an item from a list, and a page/modal prepopulated with the data for that particular item is opened, where the user can edit it)
- add confirmation when the user deletes/cancels an item
do a bare minimum CSS that at least aligns the various input fields

repository: albcristi/CityTravel

repo_name: albcristi/CityTravel


text:
# 3.4.0 - 2021-02-10

Support for resizing TIFF images. Output of such an operation is always a PNG
image.

# 3.3.0 - 2018-04-24

Support for Exif orientation.

Images are rotated and flipped automatically based on Exif data, so that the
generated thumbnails follow the specified orientation.

Support for easy non-scaling operation

By providing `0` for both width and height, the image will not be scaled but
merely re-encoded to the target location. This may be useful in combination with
the above mentioned automatic Exif orientation handling,

# 3.2.0 - 2017-09-08

Check for some error cases in gd calls which might have resulted in null-pointer exceptions and subsequent segfaults.

If the resized image could not be created for any reason, we now raise a `FastImage::ImageFetchFailure` exception.

# 3.1.1 - 2016-06-03

Fix native code structure to work after gem install.

# 3.1.0 - 2016-06-03

Replacing RubyInline with native extension.

# 3.0.1 - 2016-06-02

Updating meta data in gemspec, no code changes.

# 3.0.0 - 2016-06-02

Removing remote image support.


text:
---
layout: default
---

# 1998-03-20 - 9 out of 10 Americans are owed an average of $1,200.00 each!

## Header Data

From<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: 58e46fb8a48366f84db5e98dc13f0be90a32e0cc4a472396cffa8deeec1cf79a

Message ID: \<\>

Reply To: _N/A_

UTC Datetime: 1998-03-20 07:38:31 UTC

Raw Date: Thu, 19 Mar 1998 23:38:31 -0800 (PST)

## Raw message

```
{% raw  %}From<EMAIL_ADDRESS>Date: Thu, 19 Mar 1998 23:38:31 -0800 (PST)
To<EMAIL_ADDRESS>Subject: 9 out of 10 Americans are owed an average of $1,200.00 each!
Message-ID: <>
MIME-Version: 1.0
Content-Type: text/plain

There is over 400 BILLION DOLLARS in unclaimed and
lost money in North America and we want to help people
get their money back!

In a continuing effort to inform the public of this money,
Personal Funds Recovery, Inc. is launching an INFOMERCIAL
to air across North America. This INFOMERCIAL will educate millions
of viewers about the over 400 BILLION DOLLARS that needs to be
returned to it's rightful owners.

We are looking for 300 INDEPENDENT AGENTS who will become
a part of this campaign. Each Agent will own an exclusive territory
and will receive a percentage of every lead generated from the national
informercial!  Your involvement will be very financially rewarding.

Visit our website at <A HREF="http://www.link2web.net/owedmoney/money.html"</A>
to find out more about the opportunity and how you can get involved.

********************************
If you wish to be removed
please hit REPLY
and type REMOVE in the
subject line and your
request will be honored
immediately.
********************************

{% endraw %}
```

## Thread

+ Return to [March 1998](/archive/1998/03)

+ Return to "[thecompanyprez@a-vip.com](/authors/thecompanyprez_at_avip_com)"

+ 1998-03-20 (Thu, 19 Mar 1998 23:38:31 -0800 (PST)) - 9 out of 10 Americans are owed an average of $1,200.00 each! -<EMAIL_ADDRESS>


text:
## LE~PIZZA
#### Kevin Leresi Leparwa
## **Description**
This is a web app that allow users to order for pizza of their choices.

## TECHNOLOGIES USED

|*NO*|Name|
|---------|------------|
| #1 | HTML |
| #2 | CSS |
| #3 | JavaScript |

## **Contributors**
#### The website project was fully done by: **Kevin Leresi Leparwa**
## **Setup/Installation**
#### No installation required.You only need access with a connected device to the internet with working browser(Chrome browser is advisable)
##  **Known Bugs**
#### There are no Bugs on this file but should you experience any difficulties in accessing or getting the information you need, or come across anything kindly share with me via my email<EMAIL_ADDRESS>## My gh-pages link
[gh-page](https://leparwa.github.io/Le-Spicy-pizza-/)
## My contact details
you can find me on twitter @kevin_leresi
## Licence
Licensed under the *[MIT LICENSE](LICENSE.txt)*
Copyright (c) 2021 *Leresi Kevin Leparwa*

repository: Leparwa/Le-Spicy-pizza-

repo_name: Leparwa/Le-Spicy-pizza-


text:
# Shipping zone locations #

The shipping zone locations API allows you to view and batch update locations of a shipping zone.

## Shipping location properties ##

| Attribute | Type   | Description                                                                                |
| --------- | ------ | ----------------------------------------------------------------------------------------------------------- |
| `code`    | string | Shipping zone location code.                                                                                |
| `type`    | string | Shipping zone location type. Options: `postcode`, `state`, `country` and `continent`. Default is `country`. |

## List all locations of a shipping zone ##

This API helps you to view all the locations of a shipping zone.

### HTTP request ###

		GET

/wp-json/wc/v3/shipping/zones/<id>/locations

```shell
curl https://example.com/wp-json/wc/v3/shipping/zones/5/locations \
	-u consumer_key:consumer_secret
```

```javascript
WooCommerce.get("shipping/zones/5/locations")
  .then((response) => {
    console.log(response.data);
  })
  .catch((error) => {
    console.log(error.response.data);
  });
```

```php
<?php print_r($woocommerce->get('shipping/zones/5/locations')); ?>
```

```python
print(wcapi.get("shipping/zones/5/locations").json())
```

```ruby
woocommerce.get("shipping/zones/5/locations").parsed_response
```

> JSON response example:

```json
[
  {
    "code": "BR",
    "type": "country",
    "_links": {
      "collection": [
        {
          "href": "https://example.com/wp-json/wc/v3/shipping/zones/5/locations"
        }
      ],
      "describes": [
        {
          "href": "https://example.com/wp-json/wc/v3/shipping/zones/5"
        }
      ]
    }
  }
]
```

## Update a locations of a shipping zone ##

This API lets you make changes to locations of a shipping zone.

### HTTP request ###

		PUT

/wp-json/wc/v3/shipping/zones/<id>/locations

```shell
curl -X PUT https://example.com/wp-json/wc/v3/shipping/zones/5/locations \
	-u consumer_key:consumer_secret \
	-H "Content-Type: application/json" \
	-d '[
  {
    "code": "BR:SP",
    "type": "state"
  },
  {
    "code": "BR:RJ",
    "type": "state"
  }
]'
```

```javascript
var data = [
  {
    code: 'BR:SP',
    type: 'state'
  },
  {
    code: 'BR:RJ',
    type: 'state'
  }
];

WooCommerce.put("shipping/zones/5/locations", data)
  .then((response) => {
    console.log(response.data);
  })
  .catch((error) => {
    console.log(error.response.data);
  });
```

```php
<?php
$data = [
    [
        'code' => 'BR:SP',
        'type' => 'state'
    ],
    [
        'code' => 'BR:RJ',
        'type' => 'state'
    ]
];

print_r($woocommerce->put('shipping/zones/5/locations', $data));
?>
```

```python
data = [
    {
        "code": "BR:SP",
        "type": "state"
    },
    {
        "code": "BR:RJ",
        "type": "state"
    }
]

print(wcapi.put("shipping/zones/5/locations", data).json())
```

```ruby
data = [
  {
    code: "BR:SP",
    type: "state"
  },
  {
    code: "BR:RJ",
    type: "state"
  }
]

woocommerce.put("shipping/zones/5/locations", data).parsed_response
```

> JSON response example:

```json
[
  {
    "code": "BR:SP",
    "type": "state",
    "_links": {
      "collection": [
        {
          "href": "https://example.com/wp-json/wc/v3/shipping/zones/5/locations"
        }
      ],
      "describes": [
        {
          "href": "https://example.com/wp-json/wc/v3/shipping/zones/5"
        }
      ]
    }
  },
  {
    "code": "BR:RJ",
    "type": "state",
    "_links": {
      "collection": [
        {
          "href": "https://example.com/wp-json/wc/v3/shipping/zones/5/locations"
        }
      ],
      "describes": [
        {
          "href": "https://example.com/wp-json/wc/v3/shipping/zones/5"
        }
      ]
    }
  }
]
```

repository: woocommerce/woocommerce-rest-api-docs

branch_name: refs/heads/trunk

repo_name: woocommerce/woocommerce-rest-api-docs


text:
# gatsby-source-xkcd

A Gatsby source plugin for sourcing data into a Gatsby application from xkcd.com.

The plugin creates `xkcd` nodes from comics retrieved from xkcd.com.

For more information on the XKCD API, see: https://xkcd.com/json.html

## Install

`npm install --save gatsby-source-xkcd`

## How to use

Setting up the `gatsby-source-xkcd` plugin requires only a minor change to your `gatsb-config.js` file.

You have two options:

1. Zero Config
2. With Options

### The Zero-Config Approach

The zero-config will fetch the most recent xkcd comic.

```javascript title="gatsby-config.js"
module.exports = {
  plugins: [
    `gatsby-source-xkcd`
    //...
  ]
};
```

### With Options

Configuring the plugin with options can be done with any combination and order of the following options in your `gatsby-config.js`:

```javascript title="gatsby-config.js"
module.exports = {
  plugins: [
    {
      resolve: `gatsby-source-xkcd`,
      options: {
        // retrieve comic(s) by specified id
        comicIds: [12, 100],
        // retrieve multiple comics - randomly selected at build time
        comicQuantity: 5,
        // retrieve the latest comic
        latest: true
      }
    }
  ]
};
```

## How to query

Once added to the `gatsby-config.js` file, XKCD comics will be available via GraphQL.

The nodes created by this source plugin depend on the configuration provided in `gatsby-config.js`.

By default, this plugin will return the `latest` node.

If you provide specific options, you will have access to:

1. `latest`
2. `comicIds`
3. `comicQuantity`

Each node is the same shape, though `comicIds` and `comicQuantity` are arrays of objects while `latest` is always just one comic and therefore just an object.

```graphql
query QueryXkcd {
  allXkcd {
    nodes {
      comicIds {
        month
        num
        link
        year
        news
        safe_title
        transcript
        alt
        img
        title
        day
      }
      comicQuantity {
        month
        num
        link
        year
        news
        safe_title
        transcript
        alt
        img
        title
        day
      }
      latest {
        month
        num
        link
        year
        news
        safe_title
        transcript
        alt
        img
        title
        day
      }
    }
  }
}
```

## Examples

We have full Gatsby app examples for both the zero config approach and using basic queries.

You can find these in the `example` directory:

1. [Zero-Config](./example/zero-config/README.md)
1. [Basic Query](./example/basic-query/README.md)

## Questions? Suggestions? Contributions?

Yes please! Ask away. Create an issue if you find a bug. Open a PR if you think this can be improved!

We'll be adding some templates soon to make this simple!

In the mean time, if you'd like to pull down this repository to play around please do!

If you want to see how your changes work with one of example apps, modify the `gatsby-config.js` in there to use a [local plugin](https://www.gatsbyjs.org/docs/creating-a-local-plugin/#using-requireresolve-and-a-filepath)

For example:

```diff title="./example/basic-query/gatsby-config.js
module.exports = {
  plugins: [
    {
+        resolve: require.resolve(`../../../gatsby-source-xkcd`),
-        resolve: `gatsby-source-xkcd`,
    },
  ],
}
```

## Contributors ✨

Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/docs/en/emoji-key)):

Stephen Weiss
💻💡

This project follows the [all-contributors](https://allcontributors.org/) specification. Contributions of any kind are welcome!

repository: stephencweiss/gatsby-source-xkcd

gha_language: TypeScript

repo_name: stephencweiss/gatsby-source-xkcd


text:
---
title: Jon Skeet
image: jon-skeet.jpg
elected: true
twitter: jonskeet
company: Google
location: United Kingdom
intro: "I'm Jon Skeet, a board member and enthusiast for .NET open source, technical communities, and C# language details."
---

# .NET Foundation Campaign: Jon Skeet

## Why I'm Running

Firstly, I'm nearly *not* running. At the time I'm typing this, all the candidates are men, and most are white. **That's not good enough**, and I hope it changes significantly before the elections themselves. Elect me to the board of directors, and you can expect to hear me chiming in on diversity frequently. I want to do more than complain, of course. I hope to be able to spend time on the Foundation's behalf working *with* (not on behalf of) the many groups already trying to address tech's diversity problems. My thoughts on diversity can be summarized in three aspects:

- There's a very real problem.
- It's *not* inevitable. I'm not aiming for perfection, but I'm not willing to accept the current status quo.
- It's up to *all* of us to fix this. For many of us, that starts by actively *listening* rather than going into problem-solving mode.

The last bullet is where the Foundation comes in. The board of directors needs to actively engage in listening to those with the most experience of why our part of the tech community isn't as diverse as we'd like it to be, and then seeing where the Foundation can help.

From a more conventional side, I see great potential in the .NET Foundation beyond its current roles.

The aspect I'm most keen on is finding "holes" in the .NET ecosystem, and helping them to get filled, one way or another. My experience on [Noda Time](https://nodatime.org) has taught me that creating a new Open Source project for .NET requires a bunch of code to be written that's far removed from the purpose of the project, and that there are areas that just aren't easily addressed at the moment. For example:

- What's the best way of hosting documentation for a library that covers multiple versions, including diffs between them?
- How can I be confident in the backward compatibility story for my library?
- How can I include interactive examples for my library, or even just static snippets with generated output?
- How can I best review the changes I've made in my library for C# 8's nullable reference types?
- How can I document which parts of my library are available on which platforms?

Those are just some of the examples I've seen personally - I'm sure there are many more out there. Often there are some solutions to these, existing on the side of a project - or even as standalone projects that haven't received enough attention. I believe the Foundation can help to find these holes, discover existing solutions and consider the best way of either unifying them or promoting multiple options, depending on the situation.

In a similar vein, Microsoft is making great progress in terms of providing guidance for library authors - but the Foundation can still add value by both promoting that content and encouraging more feedback such as requests for additional topics to be covered. The Foundation can effectively encourage and amplify voices within the community.

## My .NET Contributions

I'm probably best known in the community for my answers on Stack Overflow, but I'm also active as a conference and user group speaker (whether on C# or less tech-specific topics) and the author of C# in Depth. I'm the convenor of the ECMA technical group for standardizing C# - we released the ECMA standard for C# 5 at the end of 2017. (Yes, I know we're getting behind again...) As a passionate C# developer, I love staying on the bleeding edge of language features, and provide feedback to the C# design team. I'm also the Google representative to the .NET Foundation's Technical Steering Group. (While obviously I would bear Google's interests in mind, I'm running for this post as an individual.)

In terms of code, my day job is to make Google Cloud Platform rock for .NET developers, primarily through the client libraries used to connect *your* code to Google Cloud Platform APIs. My other main passion in terms of .NET client libraries is Noda Time, which is an alternative date/time API.

## Links
* [Stack Overflow profile](https://stackoverflow.com/users/22656/jon-skeet)
* [Noda Time](https://nodatime.org) - ([source](https://github.com/nodatime/nodatime))
* [Google Cloud Client Libraries for .NET](https://github.com/googleapis/google-cloud-dotnet)
* [Code blog](https://codeblog.jonskeet.uk)
* [Personal blog](https://blog.jonskeet.uk) - my politics around diversity **would** affect how I act as a member of the board, and I'm not going to hide or minimize that

## Contact Information
* Twitter: [@jonskeet](https://twitter.com/jonskeet)
* GitHub: [@jskeet](https://github.com/jskeet)

repository: dotnet-foundation/website

repo_name: dotnet-foundation/website


text:
---
layout: post
title: Corporate Comic
published: false
categories:
  - junk
---
This is my first comic strip, inspired by a random spurt of creativity.
I can't take all the credit though. The fantastic 'lettering' was done
by a very good friend ;)

If you can't make it out, here's a blow-by-blow description...

The comic depicts an inspector looking at a tank that is structurally insecure.
During his inspection, the tank falls on him and begins to roll down the hill,
snowballing with the inspector on it.

branch_name: refs/heads/gh-pages


text:
[You are now in a GitHub source code view - click this link to view Read Me file as a web page]( https://ladybug.tools/spider-2021/sandbox/demo/readme.html  "View file as a web page." )

<input type=button onclick=window.top.location.href="https://github.com/pushme-pullyou/tootoo-2021/tree/master/sandbox/demo/";
value='You are now in a GitHub web page view - Click this button to view this read me file as source code' >

# [Spider Demo 2021 Read Me]( https://ladybug.tools/spider-2021/sandbox/demo/readme.html )

### Full Screen: [Spider Demo 2021]( https://ladybug.tools/spider-2021/sandbox/demo/ )

## Concept

* https://www.ladybug.tools/spider/cookbook/design-explorer-very-lite/r13/design-explorer-very-lite.html#littleRedBox

## To Do / Wish List

## Issues

## Links of Interest

* http://www.andrewmarsh.com/software/

## Change Log

### 2021-03-22

* First commit

***

 ❦


text:
# discord-mute-voice-channel-bot
Bot to mute everybody in a voice channel.

## Setup

```
yarn
export DISCORD_BOT_TOKEN=<use your discord bot token here>
```

## Run locally

```
yarn start
```

## Commands

`/shutup`, `/vaymoodu`, `muteall`, `m` to mute server
`/speakup`, `/vaythora`, `unmuteall`, `u` to unmute server

repository: mpndev/discord-mute-unmute

repo_name: mpndev/discord-mute-unmute


text:
+++
author = "Marc Walther"
weight = 142
project = ["Parabolic/RichardsComponentTransport/Padilla/Padilla_NaCl6/Padilla_NaCl6.prj"]
date = "2017-08-25T14:41:09+01:00"
title = "Unsaturated Mass Transport"
image = "RichardsComponentTransport_Padilla.png"
+++

{{< data-link >}}

## Overview

The Richards equation is often used to describe water movement in the unsaturated zone, while the mass transport equation describes solute movement in the liquid phase. Here, we use a monolithic approach to simulate mass transport in an unsaturated medium.

The development of the equation system is given in [this PDF](RichardsComponentTransport_Equations.pdf). In the following, we present a numerical benchmark that uses experimental data as reference.

## Problem description

We use the Padilla et al. (1999) problem which features a series of saturated and unsaturated laboratory column experiments to validate the implementation. In specific, we refer to experiments "NaCl1" (saturated flow) and "NaCl6" (unsaturated flow) - see also table 1 in Padilla et al. (1999) - and use the following parameters as model input.

### Model setup

We use a 1D domain with $0 < x < 0.25 m$, and a spatial resolution of $1.25 mm$ with a total of 200 elements. Top boundary conditions are concentration $c = 1$ (as Dirichlet) for both setups, and a specific flux $q_{NaCl1} = 2.12789E-05$ and $q_{NaCl6} = 6.46004E-06$ (as Neumann) for saturated and unsaturated cases, respectively. Bottom boundary conditions are a free exit boundary for mass transport, and Dirichlet pressure values are chosen so that the saturation in the column follows the respective values according to table 1 in Padilla et al. (1999) as $p_{NaCl1} = 0 Pa$ and $p_{NaCl6} = -4800 Pa$.

Saturated intrinsic permeability is calculated from given flux and pressure gradient information as $\kappa = 1.174E-10 m^2 $; total porosity is $\theta = 0.45$; van-Genuchten-values are $m = 0.789$ (from $n = 4.74$ via $m = 1-1/n$), bubbling pressure $p_d = 3633.33 Pa$ (from $\alpha = 0.027 cm^{-1}$ via $p_c = \rho \cdot g / \alpha$), residual saturation $s_r = 0.1689$. Molecular diffusion coefficient was set to $D_m = 1e-9 m^2/s$; dispersivities were chosen from table 2 in Padilla et al. (1999) and set to $\alpha_{NaCl1} = 3.4173E-04 m$ and $\alpha_{NaCl6} = 4.6916E-03 m$ for saturated and unsaturated conditions, respectively.

Initial conditions are $c = 0$ and hydrostatic pressure conditions with steady state flow for both scenarios.

{{< data-link "The NaCl1 project file" "Parabolic/RichardsComponentTransport/Padilla/Padilla_NaCl1/Padilla_NaCl1.prj" >}}
{{< data-link "The NaCl6 project file" "Parabolic/RichardsComponentTransport/Padilla/Padilla_NaCl6/Padilla_NaCl6.prj" >}}

### Results

The figure below shows breakthrough curves vs experimental result at the bottom of the simulation domain, together with averaged saturation values at the two observation points with distance of 0.075 cm from both ends of the column (as stated in Padilla et al., 1999) over pore volume.

{{< img src="RichardsComponentTransport_Padilla.png" title="Comparison between numerical (lines) and experimental (squares) results for cases 'NaCl1' and 'NaCl6' from Padilla et al. (1999).">}}

It can be seen, that with decreasing saturation, breakthrough curves exhibit stronger dispersion through the decreased angle of the breakthrough curve. Both simulation results follow the experimental observations closely; deviations, especially in the unsaturated case, can be attributed to known tailing effects from secondary porosity.

Here is the [ParaView state file]({{< data-url "Parabolic/RichardsComponentTransport/Padilla/Padilla_state.pvsm" >}}) for comparison.

{{< data-link "" "" >}}

## References

<!-- vale off -->

Padilla, I. Y., T.-C. J. Yeh, and M. H. Conklin (1999), The effect of water content on solute transport in unsaturated porous media, Water Resour. Res., 35(11), 3303–3313, doi:10.1029/1999WR900171.

<!-- vale on -->

repository: ufz/ogs

repo_name: ufz/ogs


text:
```@meta
CurrentModule = DataFlowTasks
```
# DataFlowTasks

*Tasks which automatically respect data-flow dependencies*

## Basic usage

This package defines a [`DataFlowTask`](@ref) type which behaves very much like a
Julia native `Task`, except that it allows the user to specify explicit *data
dependencies*. This information is then be used to automatically infer *task
dependencies* by constructing and analyzing a directed acyclic graph based on
how tasks access the underlying data. The premise is that it is sometimes
simpler to specify how *tasks depend on data* than to specify how *tasks
depend on each other*.

The use of a [`DataFlowTask`](@ref) object is intended to be as similar as
possible to a Julia native `Task`. The API implements three macros :

- [`@dspawn`](@ref)
- [`@dtask`](@ref)
- [`@dasync`](@ref)

which behave like their `Base` counterparts, except they take additional
annotations that declare how each *task* affects the *data* it accesses:

- read-only: `@R` or `@READ`
- write-only: `@W` or `@WRITE`
- read-write: `@RW` or `@READWRITE`

Anywhere in the task body, a `@R(A)` annotation for example implies that *data*
`A` will be accessed in read-only mode by the *task*.

```@example simple-example
using DataFlowTasks # hide

A = ones(5)
B = ones(5)
d = @dspawn begin
    @RW A   # A is accessed in READWRITE mode
    @R  B   # B is accessed in READ mode
    A .= A .+ B
end

fetch(d)
```

This creates (and schedules for execution) a `DataFlowTask` `d`
which accesses `A` in `READWRITE` mode, and `B` in `READ` mode. The benefit of
`DataFlowTasks` comes when you start to compose operations which may mutate the
same data:

```@example simple-example
using DataFlowTasks # hide

n = 100_000
A = ones(n)

d1 = @dspawn begin
    @RW A

    # in-place work on A
    for i in eachindex(A)
        A[i] = log(A[i]) # A[i] = 0
    end
end

# reduce A
d2 = @dspawn sum(@R A)
# The above is a shortcut for:
#   d2 = @dspawn begin
#       @R A
#       sum(A)
#   end

c = fetch(d2) # 0
```

We now have two asynchronous tasks being created, both of which access the array
`A`. Because `d1` writes to `A`, and `d2` reads from it, the outcome `C` is
nondeterministic unless we specify an order of precedence. `DataFlowTasks`
reinforces the **sequential consistency** criterion, which is to say that
executing tasks in parallel must preserve, up to rounding errors, the result
that would have been obtained if they were executed sequentially (i.e. `d1` is
executed before `d2`, `d2` before `d3`, and so on). In this example, this means
`d2` will always wait on `d1` because of an inferred data dependency. The
outcome is thus always zero.

!!! note

    If you replace `@dspawn` by `Threads.@spawn` in the example above (and pick
    an `n` large enough) you will see that you no longer get `0` because `d2`
    may access an element of `A` before it has been replaced by zero!

!!! tip

    In the `d2` example above, a shortcut syntax was introduced, which
    allows putting access mode annotations directly around arguments in a
    function call. This is especially useful when the task body is a one-liner.

    See [`@dspawn`](@ref) for an exhaustive list of supported ways to create
    tasks and specify data dependencies.

No parallelism was allowed in the previous example due to a data conflict. To
see that when parallelism is possible, `DataFlowTasks` will exploit it,
consider this one last example:

```@example simple-example
using DataFlowTasks # hide

n = 100
A = ones(n)

d1 = @dspawn begin
    @W A

    # write to A
    sleep(1)
    fill!(A,0)
end

d2 = @dspawn begin
    @R A

    # some long computation
    sleep(5)
    # reduce A
    sum(A)
end

# another reduction on A
d3 = @dspawn sum(x->sin(x), @R(A))

t = @elapsed c = fetch(d3)

t,c
```

We see that the elapsed time to `fetch` the result from `d3` is on the order of
one second. This is expected since `d3` needs to wait on `d1` but can be
executed concurrently with `d2`. The result is, as expected, `0`.

All examples this far have been simple enough that the dependencies between the
tasks could have been inserted *by hand*. There are certain problems, however,
where the constant reuse of memory (mostly for performance reasons) makes a
data-flow approach to parallelism a rather natural way to implicitly describe
task dependencies. This is the case, for instance, of tiled (also called
blocked) matrix factorization algorithms, where task dependencies can become
rather difficult to describe in an explicit manner. The [tiled factorization section](@ref
tiledcholesky-section) showcases some non-trivial problems for which
`DataFlowTask`s may be useful.

!!! tip
    The main goal of `DataFlowTask`s is to expose parallelism: two tasks `ti`
    and `tj` can be executed concurrently if one does not write to memory that
    the other reads. This data-dependency check is done *dynamically*, and
    therefore is not limited to tasks in the same lexical scope. Of course,
    there is an overhead associated with these checks, so whether performance
    gains can be obtained depend largely on how parallel the algorithm is, as
    well as how long each individual task takes (compared to the overhead).

## Custom types

In order to infer dependencies between `DataFlowTask`s, we must be able to
determine whether two objects `A` and `B` share a common memory space. That is
to say, we must know if *mutating* `A` can affect `B`, or vice-versa.
Obviously, without any further information on the types of `A` and `B`, this is
an impossible question.

To get around this challenge, you must `import` and extend the
[`memory_overlap`](@ref) method to work on any pair of elements `A` and `B` that
you wish to use. The examples in the previous section worked because
these methods have been defined for some basic `AbstractArray`s:

```@example
using DataFlowTasks: memory_overlap

A = rand(10,10)
B = view(A,1:10)
C = view(A,11:20)

memory_overlap(A,B),memory_overlap(A,C),memory_overlap(B,C)
```

By default, `memory_overlap` will return `true` and print a warning if it does
not find a specialized method:

```@repl memory-overlap
using DataFlowTasks: memory_overlap

struct CirculantMatrix
    data::Vector{Float64}
end

v = rand(10);
M = CirculantMatrix(v);

memory_overlap(M,copy(v))
```

Extending the `memory_overlap` will remove the warning, and produce a more
meaningful result:

```@repl memory-overlap
import DataFlowTasks: memory_overlap

# overload the method
memory_overlap(M::CirculantMatrix,v) = memory_overlap(M.data,v)
memory_overlap(v,M::CirculantMatrix) = memory_overlap(M,v)

memory_overlap(M,v), memory_overlap(M,copy(v))
```

You can now `spawn` tasks with your custom type `CirculantMatrix` as a data dependency, and things
should work as expected:

```@repl memory-overlap
using DataFlowTasks

v  = ones(5);
M1 = CirculantMatrix(v);
M2 = CirculantMatrix(copy(v));

Base.sum(M::CirculantMatrix) = length(M.data)*sum(M.data)

d1 = @dspawn begin
    @W v
    sleep(0.5)
    fill!(v,0)
end;
d2 = @dspawn sum(@R M1)
d3 = @dspawn sum(@R M2)

fetch(d3) # 25

fetch(d2) # 0
```

## Scheduler

When loaded, the `DataFlowTasks` package will initialize an internal scheduler
(of type [`JuliaScheduler`](@ref)), running on the background, to handle
implicit dependencies of the spawned `DataFlowTask`s. In order to retrieve the
current scheduler, you may use the [`getscheduler`](@ref) method:

```@example scheduler
using DataFlowTasks # hide
DataFlowTasks.sync() # hide
sch = DataFlowTasks.getscheduler()
```

The default scheduler can be changed through [`setscheduler!`](@ref).

There are two important things to know about the default `JuliaScheduler` type. First,
it contains a buffered DAG that can handle up to `sz_max` nodes: trying to
`spawn` a task when the DAG is full will block. This is done to keep the cost
of analyzing the data dependencies under control, and it means that a
full/static DAG may in practice never be constructed. You can modify the
buffer size as follows:

```@example scheduler
resize!(sch.dag,50)
```

Second, when the computation of a `DataFlowTask` `ti` is completed, it gets
pushed into a `finished` channel, to be eventually processed and `pop`ed from the DAG by
the `dag_worker`. This is done to avoid concurrent access to the DAG: only the
`dag_worker` should modify it. If you want to stop nodes from being removed from the DAG,
you may stop the `dag_worker` using:

```@example scheduler
DataFlowTasks.stop_dag_worker(sch)
```

Finished nodes will now remain in the DAG:

```@example scheduler
using DataFlowTasks: R,W,RW, num_nodes
A = ones(5)
@dspawn begin
    @RW A
    A .= 2 .* A
end
@dspawn sum(@R A)
sch
```

Note that stopping the `dag_worker` means `finished` nodes are no longer removed
from the DAG; since the DAG is a buffered structure, this may cause the
execution to halt if the DAG is at full capacity. You can then either
`resize!` it, or simply start the worker (which will result in the processing of
the `finished` channel):

```@example scheduler
DataFlowTasks.start_dag_worker(sch)
sch
```

!!! tip
    There are situations where you may want to change the scheduler
    temporarily to execute a block of code, and restore the default scheduler
    after. This can be done using the [`with_scheduler`](@ref) method.

## Limitations

Some current limitations are listed below:

- There is no way to specify priorities for a task.
- The main thread executes tasks, and is responsible for adding/removing nodes
  from the DAG. This may hinder parallelism if the main thread is given a long
  task since the processing of the dag will halt until the main thread becomes
  free again.
- ...

gha_language: Julia


text:
## Untitled Reality

This is [Alberto](https://github.com/albertoxamin)'s and [mine](https://github.com/danibix95) project we developed at the Vertical Innovation Hacktathon 2018 in Bozen. We focused on a tasks based on the Lichtbild Argento vivo open dataset, eploring what opportunities can provide Augumented Reality and Virtual Reality applied to those open data.

## AR Instagram & Facebook Filters
To use the filters on your device you should download [Spark AR Studio](https://sparkar.com/ar-studio) and open `time_machine.arproj` then press `Play` to view the effect on a sample video.
If you want to use it on your face, click `Video` and choose your webcam.
If you want to test it on your smartphone press `Mirror`

## Virtual Tour
In order to run the Virtual Tour locally, it is necessary to start a simple web server that serve the project page, `index.html`.
Accordingly, it is possible to exploit `python` to achieve this goal. Indeed, open a terminal in the `VR` folder and run the follwing command:

    python3 -m http.server

Then, oper your browser and visit the following link: (http://localhost:8000/src/index.html)

If you feel tired or you don't know where to start, you can enjoy a running demo at this [link](https://danibix95.github.io/HackBZ/VR/src/index.html).

**Note:** all the historical images are provided under Creative Commons licence (see each specific case) by Lichtbild Argento vivo project. Its portal can be found [here](https://www.lichtbild-argentovivo.eu/it/banca-dati-fotografica/archivi.html)


text:
#RADD

A basic example of how to use Rails, Devise and Angular.js in conjunction.

This architecture treats Rails as a JSON API and AngularJS as the front-end framework which will do view rendering.

More details on my blog post:
http://jes.al/2013/08/authentication-with-rails-devise-and-angularjs/.

###Demo

http://radd.herokuapp.com/

###Install

``bundle install``

``bundle exec rake db:setup``

``rails s``

repository: hackhands/RADD

repo_name: hackhands/RADD


text:
Finite State Entropy coder
===========================

FSE is a new kind of [Entropy encoder](http://en.wikipedia.org/wiki/Entropy_encoding),
based on [ANS theory, from Jarek Duda](http://arxiv.org/abs/1311.2540).

It is designed to compete with [Huffman encoder](http://en.wikipedia.org/wiki/Huffman_coding)
and [Arithmetic ones](http://en.wikipedia.org/wiki/Arithmetic_coding).

While huffman is fast but can only represent probabilities in power of 2 (50%, 25%, etc.)
arithmetic coding can represent probabilities with much better accuracy, but requires multiplications and divisions.

FSE solve this dilemna by providing precise probabilities, like arithmetic does,
but using only *additions, masks and shifts*.

This makes FSE faster, on par with Huffman speed, and even suitable for low-power CPU environment.

Benchmarks
-------------------------

Benchmarks are run on an Intel Core i5-3340M (oc'ed to 2.9GHz), with Window Seven 64-bits.
Source code is compiled using MSVC 2012, 64-bits mode.
Core loop results are reported ( FSE_compress_usingCTable() & FSE_decompress_usingDTable() )

    Filename	Compressor	Ratio	Compression	Decompression

    book1	FSE	1.766	430 MS/s	520 MS/s

    win98-lz4-run	FSE	2.688	430 MS/s	520 MS/s

    proba70.bin	FSE	6.337	430 MS/s	520 MS/s

    proba90.bin	FSE	15.29	430 MS/s	520 MS/s

*Speed is provided in MS/s (Millions of Symbols per second).
For more detailed results, browse the [benchmark results](benchmarkResults)*

As an obvious outcome, speed of FSE is stable accross all tested file.
By design, Huffman can't break the "1 bit per symbol" limit.
FSE is free of such limit, so its performance increase with probability, remaining close to Shannon limit.

repository: imvu/FiniteStateEntropy

repo_name: imvu/FiniteStateEntropy


text:
[See html formatted version](https://huasofoundries.github.io/google-maps-documentation/DirectionsStatus.html)

DirectionsStatus constants
--------------------------

google.maps.DirectionsStatus constants

The status returned by the DirectionsService on the completion of a call to route(). Specify these by value, or by using the constant's name. For example, 'OK' or google.maps.DirectionsStatus.OK.

Constants

[undefined](#DirectionsStatus.INVALID_REQUEST)

The DirectionsRequest provided was invalid.

[undefined](#DirectionsStatus.MAX_WAYPOINTS_EXCEEDED)

Too many DirectionsWaypoints were provided in the DirectionsRequest. See the [developer's guide](/maps/documentation/javascript/directions#UsageLimits) for the maximum number of waypoints allowed.

[undefined](#DirectionsStatus.NOT_FOUND)

At least one of the origin, destination, or waypoints could not be geocoded.

[undefined](#DirectionsStatus.OK)

The response contains a valid DirectionsResult.

[undefined](#DirectionsStatus.OVER_QUERY_LIMIT)

The webpage has gone over the requests limit in too short a period of time.

[undefined](#DirectionsStatus.REQUEST_DENIED)

The webpage is not allowed to use the directions service.

[undefined](#DirectionsStatus.UNKNOWN_ERROR)

A directions request could not be processed due to a server error. The request may succeed if you try again.

[undefined](#DirectionsStatus.ZERO_RESULTS)

No route could be found between the origin and destination.

branch_name: refs/heads/develop


text:
# Angular2
Template for Angular2 UI applications

Steps to use the template:

1. Install NodeJS in your development machine.

2. Git Clone the repository to local path.

3. Open a new command window and navigate to the clonned directory using change directory (cd) command

4. Run command "npm install" to install dependencies defined in package.json

5. Run command "npm start" to run the application by compiling .ts to .js and hosting in light web server in watcher mode.


text:
# Contents

1. What is Data Acquisition?
2. Sources to use a public dataset - ucmachinelearning, kaggle, google datasets, hugging face datasets
6. Text Extraction: Text file, Tabular Data, Rest API (Tweet of the day)
3. Scraping Data
4. Scraping Data : Wikipedia Tutorial , Beautiful Soup
4. Text extraction and Cleanup: HTML Parsing
10. Scraping Data: Twint for Twitter
5. Text Cleaning: Unicode Normalization
6. Text Extraction: PDF
7. Text Extraction: Image (Tesseract)
8. Text Cleaning: Spelling Correction
9. Scraping Hub Tutorial
10. Regular Expression for cleaning

![data_acquisition.png](./data_acquisition.png)

# Resources
- https://towardsdatascience.com/super-simple-way-to-scrape-bbc-news-articles-in-python-5fe1e6ee82d9
- https://www.freecodecamp.org/news/scraping-wikipedia-articles-with-python/

repository: harveenchadha/NLPH

repo_name: harveenchadha/NLPH


text:
# Semantic Instance Geometry Network for Unsupervised Perception

> Project page: [https://mengyuest.github.io/SIGNet/](https://mengyuest.github.io/SIGNet/)

> Original implementation trained on [KITTI](http://www.cvlibs.net/datasets/kitti/index.php): https://github.com/mengyuest/SIGNet

> Original paper:
Y. Meng, Y. Lu, A. Raj, S. Sunarjo, R. Guo, T. Javidi, G. Bansal, D. Bharadia. **"SIGNet: Semantic Instance Aided Unsupervised 3D Geometry Perception"**,  (CVPR), 2019. \[[arXiv pdf](https://arxiv.org/pdf/1812.05642.pdf)\]

This repository recreates SIGNet for the CARLA Simulator. It also contains detailed instructions about how to train SIGNet on new datasets.

## Prerequisites
1. Ubuntu 16.04, python3, tensorflow-gpu 1.10.1
2. Better to use virtual environment. For the rest of dependencies, please run `pip3 install -r requirements.txt`

## Training & Evaluating Depth on a Different Dataset

Training on a new dataset can be an involved process considering that everything in the original implementation is very specific to KITTI.

### Data Structuring
There are certain key directories in the config files that will need to be changed based on your dataset. Namely, `DATASET_DIR`, `FILELIST_DIR`, `INS_TRAIN_KITTI_DIR`, `INS_TEST_KITTI_DIR`, and `MASK_KITTI_DIR` will need to be updated.

A sample file hierarchy is shown below to aid the discussion.

Data is read using TensorFlow file readers and queues. For convenience, all sequences of (source, target, source) images belonging to a common video should be inside a common folder, such as `video1` below. Each sequence of images should have images which are concatenated horizontally in temporal order (e.g. `seq_x.png`). These should preferably be resized to dimension `(416, 1248, 3)` to match what was used for KITTI, as using a different size may result in lower performance.

Extended subdirectories can exist within this folder, and even the filenames can be different than what is given below - the only important thing is that the file paths for all images should be listed in a document like `train.txt`, which will be used to read the data.

Note that semantic segmentation data (`_.npy`, `_.raw` files), instance mask data (`_instance_new.npy`, `_instance_new.raw` files) and camera intrinsics data (`_cam.txt` files) need to be in the same folders as the image (see hierarchy below).

```
|-- train_data
|   |-- video1
|   |   |-- seq_1.png                   # RGB image sequence
|   |   |-- seq_1.npy                   # Semantic mask data
|   |   |-- seq_1.raw
|   |   |-- seq_1_instance_new.npy      # Instance mask data
|   |   |-- seq_1_instance_new.raw
|   |   |-- 1_cam.txt                   # Camera intrinsics data
|   |   |-- seq_2.png
|   |   |-- seq_2.npy
|   |   |-- seq_2.raw
|   |   |-- seq_2_instance_new.npy
|   |   |-- seq_2_instance_new.raw
|   |   |-- 2_cam.txt
|   |    ...
|   |    ...
|   |-- video2
|   |   ...
|   |   ...
|   |-- train.txt
|
|-- test_data
|   |-- video1
|   |   |-- img_1.png
|   |   |-- img_1.npy
|   |   |-- img_1.raw
|   |   |-- img_1_instance_new.npy
|   |   |-- img_1_instance_new.raw
|   |   |-- img_2.png
|   |   |-- img_2.npy
|   |   |-- img_2.raw
|   |   |-- img_2_instance_new.npy
|   |   |-- img_2_instance_new.raw
|   |    ...
|   |    ...
|   |-- video2
|   |    ...
|   |    ...
|   |-- test_eigen_file.txt
|
```

It is encouraged to go over how exactly these files are read into TF queues so that you can create/modify the functions as per your use case. This information can be found in `sig_main.py` and `data_loader.py`.

`bash run_depth_train.sh config/foobar.cfg` can be used to train depth.

### Generating Semantic Data
The SIGNet paper uses DeepLabv3+ to generate semantic maps. The `_.npy` files are simply the semantic segmentation image maps saved as `npy` files. The extension is updated to `.raw` for faster data loading.

### Generating Instance Masks
The SIGNet paper uses Mask-RCNN trained using FAIR's [Detectron](https://github.com/facebookresearch/Detectron). The Detectron code can be found in ________.
The `_instance_new.npy` files are generated using the script ______. Once again, the extension is updated to `.raw` for faster data loading.

### Generating Camera Intrinsics
The `_cam.txt` files contain 9 comma separated values representing the camera calibration matrix, in index order `(0,0), (0,1), (0,2), (1,0), (1,1), (1,2), (2,0), (2,1), (2,2)`.

### Evaluation

There are a few changes during evaluation. The image files which contained sequences earlier will now contain single images since we only need single image input for depth prediction.

You will also have to modify the ground truth depth generation based on your dataset. SIGNet for KITTI uses velodyne points to generate a sparse depth map for each image (details in paper). This may not be the case in your scenario.

In the end, ground truth depth files are stored as `models/gt_data/gt_depth.npy`. This `npy` file would contain a list with the depth maps of all test files in `test_eigen_file.txt`, in the same order.

`bash run_depth_test_eval.sh config/foobar.cfg` can be used to evaluate depth.

repository: DrZhouKarl/carla-SIGNet

repo_name: DrZhouKarl/carla-SIGNet


text:
# REFIL
Code for [*Randomized Entity-wise Factorization for Multi-Agent Reinforcement Learning*](https://arxiv.org/abs/2006.04222) (Iqbal et al., ICML 2021)

This codebase is built on top of the [PyMARL](https://github.com/oxwhirl/pymarl) framework for multi-agent reinforcement learning algorithms.

# Dependencies
- Docker
- NVIDIA-Docker (if you want to use GPUs)

## Setup instructions

Build the Dockerfile using
```shell
cd docker
./build.sh
```

Set up StarCraft II.

```shell
./install_sc2.sh
```

## Run an experiment

Run an `ALGORITHM` from the folder `src/config/algs`
in an `ENVIRONMENT` from the folder `src/config/envs`
on a specific `GPU` using some `PARAMETERS`:
```shell
./run.sh <GPU> src/main.py --env-config=<ENVIRONMENT> --config=<ALGORITHM> with <PARAMETERS>
```

Possible environments are:
- `group_matching`: Group Matching environment from the paper
- `sc2custom`: StarCraft environment from the paper

For StarCraft you need to specify the set of tasks to train on by including the parameter `scenario=<scenario_set_name>`.
Here are the possible scenario sets:

- Included in the paper:
    - `3-8sz_symmetric`
    - `3-8MMM_symmetric`
    - `3-8csz_symmetric`
- Debugging/Additional:
    - `3-8m_symmetric`
    - `6-11m_mandown`

Possible algorithms are:
- `refil`: REFIL (our method)
- `refil_group_matching`: REFIL w/ hyperparameters for Group Matching game
- `qmix_atten`: QMIX (Attention)
- `qmix_atten_group_matching`: QMIX (Attention) w/ hyperparameters for Group Matching game
- `refil_vdn`: REFIL (VDN)
- `vdn_atten`: VDN (Attention)

For group matching oracle methods, include the following parameters while selecting `refil_group_matching` as the algorithm:
- REFIL (Fixed Oracle): `train_gt_factors=True`
- REFIL (Randomized Oracle): `train_rand_gt_factors=True`

## Citing our work

If you use this repo in your work, please consider citing the corresponding paper:

```bibtex
@InProceedings{iqbal2021refil,
  title={Randomized Entity-wise Factorization for Multi-Agent Reinforcement Learning},
  author={Iqbal, Shariq and de Witt, Christian A Schroeder and Peng, Bei and B{\"o}hmer, Wendelin and Whiteson, Shimon and Sha, Fei},
  booktitle =    {Proceedings of the 38th International Conference on Machine Learning},
  year =     {2021},
  series =   {Proceedings of Machine Learning Research},
  publisher =    {PMLR},
}
```


text:
# Audio-Classification (Kapre Version)

Pipeline for prototyping audio classification algorithms with TF 2

![melspectrogram](docs/mel_spectrograms.png)

<!-- TOC -->

- [YouTube](#youtube)
- [Environment](#environment)
- [Jupyter Notebooks](#jupyter-notebooks)
- [Audio Preprocessing](#audio-preprocessing)
- [Training](#training)
- [Plot History](#plot-history)
- [Confusion Matrix](#confusion-matrix)
- [Receiver Operating Characteristic](#receiver-operating-characteristic)
- [Kapre](#kapre)

<!-- /TOC -->

### YouTube

This series has been re-worked. There are new videos to support this repository. It is recommended to follow the new series.

https://www.youtube.com/playlist?list=PLhA3b2k8R3t0SYW_MhWkWS5fWg-BlYqWn

If you want to follow the old videos, restore to a previous commit.

`git checkout 404f2a6f989cec3421e8217d71ef070f3593a84d`

### Environment

```
conda create -n audio python=3.7
activate audio
pip install -r requirements.txt
```

### Jupyter Notebooks

Assuming you have ipykernel installed from your conda environment

`ipython kernel install --user --name=audio`

`conda activate audio`

`jupyter-notebook`

### Audio Preprocessing

clean.py can be used to preview the signal envelope at a threshold to remove low magnitude data

When you uncomment split_wavs, a clean directory will be created with downsampled mono audio split by delta time

`python clean.py`

![signal envelope](docs/signal_envelope.png)

### Training

Change model_type to: conv1d, conv2d, lstm

Sample rate and delta time should be the same from clean.py

`python train.py`

### Plot History

Assuming you have ran all 3 models and saved the images into logs, check `notebooks/Plot History.ipynb`

![history](docs/model_history.png)

`notebooks/Confusion Matrix and ROC.ipynb`

### Confusion Matrix

![conf_mat](docs/conf_mat.png)

### Receiver Operating Characteristic

![roc](docs/roc.png)

### Kapre

For computation of audio transforms from time to frequency domain on the fly

https://github.com/keunwoochoi/kapre
https://arxiv.org/pdf/1706.05781.pdf

repository: gpdsec/Audio-Classification

repo_name: gpdsec/Audio-Classification


text:
A script to generate SNMPv3 keys as detailed by rfc3414 (passphrases expanded with a kdf, then hashed with the engine id). All key generation is done using the new cryptographically secure _secrets_ library.

As I wrote this with ESXi in mind, it also emits a string suitable for configuring the SNMP daemon via esxcli/PowerCLI, but the hashes are standard and compatible with other SNMPv3 implementations.

With no arguments, it will generate an authentication and privacy passphrase with associated random engine ID in text form. `--json` will format the output as json.

The script is fully idempotent; if you take the parameters it generates randomly and re-enter them, you will get the same output a second time.

Dependencies
============
Runtime: Python 3.6 or greater.

Sample Output
=============

Standard
--------

```
User: observium
Auth: gaYA82XVtNaf3WLwRgoIs544ghP6f80S / f78359764ca382922fa382cf884e588031de575a
Priv: H5XEtRpxXVaGzXU5i2rFwPnYGr8SEzTp / 31a001a56a225fdfc1916bd60190405a1aa22ff0
Engine: 7ae1b0ff0aa2f3950566d3de2274d05a
ESXi USM String: observium/f78359764ca382922fa382cf884e588031de575a/31a001a56a225fdfc1916bd60190405a1aa22ff0/authpriv
SR-OS Config: configure system security user observium snmp authentication md5 f78359764ca382922fa382cf884e588031de575a privacy aes-128-cfb-key 31a001a56a225fdfc1916bd60190405a1aa22ff0
```

JSON
----

```
{
  "user": "observium",
  "engine": "b2a50167b7c8512ddfc9d5765a3490af",
  "phrases": {
    "auth": "71rOhjfj6QVSy2mw5tBo7PueZ8KWSv60",
    "priv": "xwsvzht8NEcuwAlEpUKzMxKFWeH72sK9"
  },
  "hashes": {
    "auth": "fa0d5249293404502f9953b9514d0636a96c2cbc",
    "priv": "cccbdcfa603817df340514ecc22dfae8c4c412e8"
  },
  "esxi": "observium/fa0d5249293404502f9953b9514d0636a96c2cbc/cccbdcfa603817df340514ecc22dfae8c4c412e8/authpriv",
  "sros": "configure system security user observium snmp authentication md5 f78359764ca382922fa382cf884e588031de575a privacy aes-128-cfb-key 31a001a56a225fdfc1916bd60190405a1aa22ff0"}
```

If a YAML or TOML library is installed, you also use the `--yaml` and `--toml` arguments respectively.

It should go without saying, but **DO NOT** use the engine id or passphrases in the samples.

Usage
=====

```
usage: snmpv3-hashgen [-h] [--auth AUTH] [--priv PRIV] [--engine ENGINE] [--user USER] [--mode {auth,priv,none}] [--hash {md5,sha1,sha224,sha256,sha384,sha512}] [--json | --yaml | --toml]

Convert an SNMPv3 auth or priv passphrase to hashes.

optional arguments:
  -h, --help            show this help message and exit
  --auth AUTH           Authentication passphrase to be derived as utf8 string
  --priv PRIV           Privacy passphrase to be derived as utf8 string
  --engine ENGINE       Engine ID as hex string
  --user USER           SNMPv3 USM username (default "librenms")
  --mode {auth,priv,none}
                        SNMPv3 mode (default "priv")
  --hash {md5,sha1,sha224,sha256,sha384,sha512}
                        Hash algorithm to use (default "sha1")
  --json                Emit output as json
  --yaml                Emit output as yaml
  --toml                Emit output as toml

RFC 7630 defines no test data for sha[2-9]{3} - these should be considered experimental.
Report bugs at https://github.com/TheMysteriousX/SNMPv3-Hash-Generator/issues
```


text:
# Setting up your Backend Database

*Duration : 20 mins*

*Persona : API Team*

The set of steps below allows you to setup a backend proxy and Firebase database to serve as the backend data repository for your API proxies.

# Pre-requisites

* GCP account and project

# Instructions

## Creating your GCP service account credentials

All of the extensions labs use GCP services. In order to authenticate against these services from the API proxy, a service account must be created and configured.
Please follow the instructions documented here to create and manage service accounts:

* [Create and Manage Service Accounts](https://cloud.google.com/iam/docs/creating-managing-service-account-keys)

* Grant roles to the service account

Once the service account is created, you need to grant specific roles and permissions.

1. Open the IAM & Admin page in the GCP console
2. Select your GCP project from the drop-down list
3. Identify the service account to which you want to add/edit a role

![image alt text](./media/image_gcp_svc_account.png)

4. Select one or more roles to apply to the service account. Click +Add Role button and select the Logging > Logs Write role and permission

![image alt text](./media/image_gcp_svc_account_logging_role.png)

5. Click Add or Save to apply the role to the service account

## Setting up Firebase backend (Optional)

The API proxies used in the Extension lab exercises, reads and writes *employee* data in a Firebase database on Google Cloud Platform. This process below can be used to set up a new backend database.

**NOTE**
* Instructions for creating a firebase project to contain the backend data is shown below. A ZIP file, dbsetup.zip, contains everything needed to populate the Firebase database.
* Runtime access to the Firebase database is only via the Apigee Edge proxies.

# Create Firebase DB and Import

1. In a browser go to https://firebase.google.com
2. Click Go to Console at the top right.
3. Click +ADD PROJECT button. Select your GCP project name from the drop-down list or enter a new project name.
4. Click on Continue once the project is ready
5. Accept defaults, terms, and Click Add Firebase button.
6. Click Develop > Database in the left nav menu, scroll down to choose Realtime Database, and then click Create database button.
7. Accept default read/write rules (Start in locked mode), and click *Enable* button.
    You will see the database URI to access your Firebase instance (https://{your-gcp-project-name}.firebaseio.com/). You'll need this later.
8. Import data into Firebase. Click three dots on the right and select IMPORT JSON. Navigate to the data directory and under the *Setup* folder select the ./Resources/dbsetup/empdata.json file. Click the IMPORT button.

# Update Firebase Rules

1. In the Firebase Console, select Develop > Database and click the Rules tab.
2. Open the ./Resources/dbsetup/emprules.json file and copy the JSON from that file into the rules text box
3. Click Publish.

# Summary

That completes the setup of Firebase as the backend database. You can now proceed with Lab 1 in this series.


text:
## Integrating Twisted reactor with IPython
Originally published: 2005-04-22 01:26:20
Last updated: 2005-04-22 01:26:20
Author: Matthew Scott

Runs the Twisted reactor event loop in a thread alongside an IPython shell, for introspecting a running Twisted process.

gha_language: Python