text:
# Medical Analytica
A Medical bot with emotional analysis and casual chat

# Table of Contents

* [Description](https://github.com/ejson03/Medical-Chatbot#description)
* [Installation](https://github.com/ejson03/Medical-Chatbot#installation)
* [Output](https://github.com/ejson03/Medical-Chatbot#output)
* [Contributors](https://github.com/ejson03/Medical-Chatbot#contributors)
* [License](https://github.com/ejson03/Medical-Chatbot#license)

# Description

There is a wave of emotional unstabiltiy among people who are on a downward spiral in life or are going through hard times. We have developed a chat companion to make the user feel better and to track analysis of users behaviour. Chatbot as a compnion can provide you factual informatio

This project as a chatbot is a part of our complete project

[Medical Analytica](https://github.com/ejson03/Medical-Analytica)

# Installation

Clone the repository
```
git clone https://github.com/ejson03/Medical-Analytica.git
```

## Run chatbot and ui on local
Setup Python environment
```
python -m venv venv

[Windows users]
.\venv\Scripts\activate

[Ubuntu]
source venv/bin/activate

pip install -r requirements.txt

python -m spacy download en_core_web_md
```

Setup Docker environment
```
docker-compose up -d --build mongodb neo4j
```

Inject data in neo4j
```
cd QA-engine/Knowledge-Base
python build_mdeicalgraph.py
```

For training and testing
```
cd chatbot
rasa train
rasa test
```

Running in one command on windows machine
```
./runserver.bat
```

## Run everything on docker

```
docker-compose up -d --build main
```

Essential docker commands
```
docker build -t <container-name> .
docker run -t <container-name> -p <port>:<port> [ -d for silent]
docker system prune -a (remove all containers)
docker ps (check running containers)
docker stop <container-id>  (stop single container)
docker rm <container-id> (remove single container)
docker rmi <image-id> (remove image)
docker container stop $(docker container ls -aq) (stop all containers)
docker container rm $(docker container ls -aq) (remove all containers)
docker container inspect <container-id>
```
# Output

## Chatbot architecture simple
![Image of architeture](docs/architecture.png)

## Medical Knowledge Graph
![Image of medical knowledge graph](docs/kb.png)

## User Knowledge Graph
![Image of user knowledge graph](docs/ukb.png)

## Mobile responsive
![Image of mobile responsive](docs/mobile-responsive.png)

## Video Embedded
![Image of video](docs/youtube.png)

## Quote Embedded
![Image of quote](docs/quote.png)

# Contributors

* Elvis Dsouza [@ejson03](https://github.com/ejson03)
* Vedant Sahai [@Vedantsahai18](https://github.com/Vedantsahai18)
* Pratik Chowdhury [@pratikpc](https://github.com/pratikpc)

# License

[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

[MIT License Link](https://github.com/ejson03/Medical-Analytica/blob/master/LICENSE)


text:
# Using the render package

If you want rendering JSON and HTML to be even simpler, there is the
`github.com/unrolled/render` package. This package was inspired by the
`martini-contrib/render` package and is my goto when it comes to rendering data
for presentation in my web applications.

``` go
package main

import (
	"net/http"

	"gopkg.in/unrolled/render.v1"
)

func main() {
	r := render.New(render.Options{})
	mux := http.NewServeMux()

	mux.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) {
		w.Write([]byte("Welcome, visit sub pages now."))
	})

	mux.HandleFunc("/data", func(w http.ResponseWriter, req *http.Request) {
		r.Data(w, http.StatusOK, []byte("Some binary data here."))
	})

	mux.HandleFunc("/json", func(w http.ResponseWriter, req *http.Request) {
		r.JSON(w, http.StatusOK, map[string]string{"hello": "json"})
	})

	mux.HandleFunc("/html", func(w http.ResponseWriter, req *http.Request) {
		// Assumes you have a template in ./templates called "example.tmpl"
		// $ mkdir -p templates && echo "<h1>Hello {{.}}.</h1>" > templates/example.tmpl
		r.HTML(w, http.StatusOK, "example", nil)
	})

	http.ListenAndServe(":8080", mux)
}
```

## Exercises
1.  Try using the `.yield` helper function (with the curly braces) and a layout with HTML templates.

repository: CodeFreezr/gobyes

branch_name: refs/heads/master

extension: md

gha_language: Go

license_type: permissive

repo_name: CodeFreezr/gobyes


text:
# Vegetarian Tortilla Soup
4 Servings
### Ingredients
##### Soup
|Quantity|Ingredient|
----------:|:-------
|2| tablespoons canola oil|
|1|onion, coarsely chopped|
|2|carrots, coarsely chopped|
|6|ribs from the heart of celery, coarsely chopped|
|2|tablespoons cumin|
|2|teaspoons crushed fresh garlic|
|1|teaspoon chili powder|
|1|tablespoon salt|
|1/4|cup cilantro|
|8|cup vegetable broth|
|1/2|cup lime juice|
|2|ears of corn, cut into 2 inch wheels|

##### Garnish
|Quantity|Ingredient|
----------:|:-------
|1|cup grated Monterrey Jack cheese|
|1|tomato, chopped|
|1|avocado, chopped|
|1|cup crumbled tortilla chips, or more|

### Instructions

* Heat the canola oil in a large saucepan over medium heat. Add the onions, carrots, and celery; Saute for 3 minutes, add in the cumin, garlic, chili powder, salt, and cilantro. Stir well, and cook for another 3 minutes.
* Add the vegetable broth and lime juice and bring to a simmer. Add the corn and cook for 10-15 minutes.
* While the soup is cooking, divide the cheese, tomatoes, and avocados among 4 bowls. Ladle in the soup, making sure to include two sections of corn for each bowl, because corn is good af. Garnish with a dollop of sour cream and some tortilla chips.

license: MIT

repository: Brooke-white/RecipeParser

path: /Recipes/Vegetarian Tortilla Soup.md

filename: Vegetarian Tortilla Soup.md

repo_name: Brooke-white/RecipeParser


text:
# Map Walker

### World map with countries info and weather data

![Map Walker](https://i.imgur.com/D1myqtj.png)
---
---
![Map Walker](https://i.imgur.com/zYMAoS9.png)
---

### Tech stack
Map Walker uses several open source projects to work properly and for tests:

* [React] - Javascript library for building user interfaces
* [Redux] - Predictable state container for JavaScript apps
* [Bootstrap] - An open source toolkit for developing with HTML, CSS, and JS
* [Google-map-react] - Universal google map react component, allows render react components on the google map
* [Bootswatch] - Free themes for Bootstrap

---

### App at github.io

https://paratagas.github.io/

---

### Source code repository

https://github.com/paratagas/paratagas-github-io

---

### Installation

* Download and extract the [latest version of Map Walker](https://github.com/paratagas/paratagas-github-io)
* Install the dependencies and devDependencies:
```sh
$ cd paratagas-github-io
$ npm install
```

---

### API settings

* Rename
```sh
app/config/api-example.js
```
* to
```sh
app/config/api.js
```
* Set your API keys in file above

---

### Launching
```sh
$ npm start
```

After that your web application is available at:

http://localhost:3000

---

### License

MIT

 [React]: <https://facebook.github.io/react>
 [Redux]: <https://redux.js.org/>
 [Bootstrap]: <https://getbootstrap.com/>
 [Google-map-react]: <https://github.com/istarkov/google-map-react>
 [Bootswatch]: <https://bootswatch.com/>

repository: paratagas/paratagas-github-io

repo_name: paratagas/paratagas-github-io


text:
# alexa-top-hacker-news
Simple Alexa example of getting the top 5 stories from Hacker News.

In order to test locally, go to the `src` directory and run `node test.js`.  To deploy the Skill, upload a zipped version of the **src** directory to an AWS Lambda function.  Then configure the Skill.

See: [Getting Started with the Alexa Skills Kit](https://developer.amazon.com/public/solutions/alexa/alexa-skills-kit/getting-started-guide) for better directions.

**NOTE** there is a MUCH better version of getting the top hacker news.  Just ask Alexa for the top hacker news & see!  Don't use this skill ;)

repository: xeb/alexa-top-hacker-news

repo_name: xeb/alexa-top-hacker-news


text:
---
title: "Python"
---

# Python

[[toc]]

## Installation

```bash
pip install arkecosystem-client
```

## Basics

### Example for v2

```python
from ark.client import ArkClient

client = ArkClient('http://<IP_ADDRESS>:4003/api')

delegates = ark.delegates().delegates()
delegates = client.delegates.all()
```

### Example for v1

```python
from ark.client import ArkClient

client = ArkClient('http://<IP_ADDRESS>:4002/api', api_version='v1')

delegates = ark.delegates().delegates()
delegates = client.delegates.all()
```

repository: Nigui/docs

repo_name: Nigui/docs


text:
# mmtable2

[![Codecov test
coverage](https://codecov.io/gh/ianmoran11/mmtable2/branch/master/graph/badge.svg)](https://codecov.io/gh/ianmoran11/mmtable2?branch=master)
[![R-CMD-check](https://github.com/ianmoran11/mmtable2/workflows/R-CMD-check/badge.svg)](https://github.com/ianmoran11/mmtable2/actions)
[![Lifecycle:
experimental](https://img.shields.io/badge/lifecycle-experimental-orange.svg)](https://lifecycle.r-lib.org/articles/stages.html#experimental)

Create and combine tables with a ggplot2/patchwork syntax.

See a short introduction in the [getting started
vignette](https://ianmoran11.github.io/mmtable2/articles/Some-minimal-examples.html).

## Installation

mmtable2 is not available on CRAN. It can be installed from github with
the following script:

``` r
devtools::install_github("ianmoran11/mmtable2")
```


text:
# atmel xmega e
There are many examples for the older atmega mcu:s. Here some examples for the newer xmega processors.

Main refs:
- Docs: http://www.microchip.com/wwwproducts/en/ATxmega8E5
- Manual: http://ww1.microchip.com/downloads/en/DeviceDoc/Atmel-42005-8-and-16-bit-AVR-Microcontrollers-XMEGA-E_Manual.pdf
- c-code for xmega: http://www.atmel.com/images/doc8075.pdf


text:
---
title: Sample Use Cases: Sessions and Single-Page Apps
description: Explore sample use cases to understand how sessions work with single-page applications (SPAs) that have no backend and authentication in Auth0.
toc: true
topics:
  - sessions
  - single-page-apps
  - sample-use-case
contentType: concept
useCase:
  - build-an-app
---
# Sample Use Cases: Sessions and Single-Page Apps

When you build an application that requires authentication, you can use [sessions](/sessions) to determine if a user is authenticated each time a request is made. Let's look at an example.

::: note
This example is accurate for single-page apps (SPAs) that have no backend and are using the Implicit grant. For SPAs that have a lightweight backend and are using the Authorization Code grant (also, native apps and regular web apps), see [Sample Use Cases: Sessions](/sessions/concepts/sample-use-cases-sessions).
:::

Let's say you've built an OIDC-compliant e-commerce website called Storezero.io.

![View Sample Web Site: Storezero.io](/media/articles/sessions/use-case-storezero.png)

When checking out, a user can optionally log in to the site, but to view the "My Account" pages, the user _must_ log in.

Before checking out, a user wants to view their previous orders, so they navigate to the "All Orders" section in the "My Account" pages.

## User logs in with Identity Provider

Let's say that the user decides to log in with Facebook.

1. Auth0's SDK redirects the user to the Auth0 Authorization Server (**/authorize** endpoint).
2. Your Auth0 Authorization Server creates a session.
3. Your Auth0 Authorization Server redirects the user to the login prompt.
4. The user chooses to log in with Facebook.
5. Your Auth0 Authorization Server redirects the user to Facebook's server.
6. Facebook creates a session, then authenticates the user, and updates the session to indicate that the user is logged in.
7. Facebook redirects the user back to the Authorization Server, where the Authorization Server updates its session to indicate that the user is logged in.
8. The Authorization Server redirects the user back to the application, passing an ID Token and Access Token.
9. The application authenticates the user.

Since we are using the Implicit Grant, the client (storezero.io) can consume the ID Token to authenticate the user and can use the Access Token to interact with the API (until it expires). So no local session is created to keep the user logged in.

## Keep the user logged in without a local session

Since we have no local session to keep the user logged in, we can use the session on the Authorization Server to determine whether to force the user to reauthenticate. We do this through [Silent Authentication](/api-auth/tutorials/silent-authentication).

We create a hidden iframe that redirects to the Authorization Server adding the `prompt=none` parameter, which tells the server not to prompt the user for any input. If the session on the Authorization Server has not expired, the transaction continues seamlessly, and the client gets a new Access Token through WMRM (Web Message Response Mode), which leverages postMessage.

If the session on the Authorization Server has expired or the user logs out, the redirect in the iframe will return an error, indicating that the application needs to redirect the user to the Authorization Server to reauthenticate.

repository: alvin-milton/docs

gha_license_id: MIT

repo_name: alvin-milton/docs


text:
# EonX Symfony Recipes

This repository is to be used as a [Symfony Flex][0] endpoint for EonX Symfony projects as it contains custom recipes.

## Usage

To use this repository as a Symfony Flex endpoint in your project, you can either add the URL of this repository
in the `extra.symfony.endpoint` config option of `composer.json` or in the `SYMFONY_ENDPOINT` env var.
For more information, please refer to this [article][1].

The URL to use for this repository is:

```
https://api.github.com/repos/eonx-com/symfony-recipes/contents/index.json?ref=flex/main
```

### Composer.json

```json
{
    "extra": {
        "symfony": {
            "allow-contrib": false,
            "require": "5.3.*",
            "endpoint": "https://api.github.com/repos/eonx-com/symfony-recipes/contents/index.json?ref=flex/main"
        }
    }
}
```

[0]: https://github.com/symfony/flex
[1]: https://symfony.com/blog/symfony-flex-is-going-serverless

repository: dextercampos/easy-monorepo

repo_name: dextercampos/easy-monorepo


text:
libsharlayan
============
A Haskell library for parsing lodestone data

Contributing
------------
1. Fork it!
2. Create your feature branch: `git checkout -b my-new-feature`
3.  Push to the branch: `git push origin my-new-feature`
5. Submit a pull request :D

*We're all adults here, so let's get along. This project uses the NCoC, which you can read more about [here](https://github.com/domgetter/NCoC).*

License
-------
This library is available under the BSD 3-clause license, check the LICENSE file for more details.

repository: callummance/libsharlayan

repo_name: callummance/libsharlayan


text:
Thus you will teach him something you did not know, and neither did he.

## To support a bucket of water on the points of three knives laid flat without touching the ground

> *Figure*
>

According to the strength of your knives, either kitchen or table knives, you will make them support a large weight on their tips laid flat arranged in a triangle, edge to edge, as you can see, and not touching the ground. And after arranging them this way, if you turn them the other way without disassembling them, the handles can also support a large weight without touching the ground. You can as well adapt this to other uses with pikes, with timbers, or to quickly make a tripod in a camp with three halberd points. If the edge of the knife marked A is turned to the left, the butts of the handles will rise, but if the edge of the same knife is turned to the right, the tips will rise.

## To boil an egg in cold water without a fire

Empty an egg from both ends so that nothing remains inside, then fill it with quicklime and natural sulphur, then plug the holes with wax and put it in water so that it floats two or three fingers above the surface.

## To make rabbits come out of a burrow

Have some embers in a pot, and after putting sulphur on top, place it inside the burrows and block them with something light.

gha_language: HTML


text:
# meow

meow is a [Nim](https://nim-lang.org/) wrapper for the [meow_hash](https://github.com/cmuratori/meow_hash) library.

`meow` is distributed as a [Nimble](https://github.com/nim-lang/nimble) package and depends on [nimterop](https://github.com/nimterop/nimterop) to generate the wrappers. The `meow_hash` source code is downloaded using Git so having ```git``` in the path is required.

## Installation

`meow` can be installed via [Nimble](https://github.com/nim-lang/nimble):

```
> nimble install meow
```

This will download and install `meow` in the standard Nimble package location, typically ~/.nimble. Once installed, it can be imported into any Nim program.

## Usage

Module documentation can be found [here](https://disruptek.github.io/meow/meow.html)

```nim
import meow

echo MeowFile("path/to/file")
```

## Credits

`meow` wraps the `meow_hash` source code and all licensing terms of [meow_hash](https://github.com/cmuratori/meow_hash/blob/master/LICENSE) apply to the usage of this package.

## Feedback

`meow` is a work in progress and any feedback or suggestions are welcome. It is hosted on [GitHub](https://github.com/disruptek/meow) with an MIT license so issues, forks and PRs are most appreciated.

## Documentation
See [the documentation for the meow module](https://disruptek.github.io/meow/meow.html) as generated directly from the source.

repository: disruptek/meow

repo_name: disruptek/meow


text:
# Brightcove Connector for Sitecore

Developer Setup

1) Install Sitecore 9.0 via instructions from the official Sitecore dev site

2) Install the Brightcove connector via the package in Data/packages/Brightcove Media Framework-9.0.zip. This now includes media framework. You can also put the xml file in the Sitecore packages directory in order to generate/modify the package.

3) Modify the Brightcove .Extended config by replacing placeholder values and remove the disabled extension

4) Modify App_Config/Includes/Unicorn/Unicorn.Brightcove.config to point to the Serialization directory in your source directory. Keep in mind you may need to change app pool identity or give permissions to the Serialization folder.

5) Run the SQL script in the src/Data/ folder inside the solution on the reporting DB

6) Perform a smart publish of the entire site

Then, you can use this solution and publish over your website as usual.

# License

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License.

You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0

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


text:
# SunRiseAlarm
Raspberry PI based sunrise alarm clock

## Requires
|       Item    |       Reason      |   Setup Instruction   |
|   ---         |       ---         |           ---         |
|gpiozero       | GPIO output | (should be already installed)|
| tinydb        | Configuration storage|    `pip install tinydb`|
| tinydb-serialization | Serializing enums for config |    `pip install tinydb-serialization`|
| mako        | Web Server pages |    `pip install mako`|
| py-flags        | Python 3.5 compatible flags enum |    `pip install py-flags`|
| pytest        | Unit testing |    `pip install pytest`|


text:
You might be interested in cloning their behavior: reconstruct them. This
repository holds tools for semi-automatically and very accurately reconstructing
color filters.

The truth is folks like Instagram filters. They are trying to
[reproduce](https://github.com/girliemac/Filterous)
them [again](https://github.com/girliemac/filterous-2)
and [again](https://github.com/acoomans/instagram-filters).
And [again](https://github.com/lukexyz/CV-Instagram-Filters)
and [again](https://www.practicepython.org/blog/2016/12/20/instagram-filters-python.html).
And [again](https://code.tutsplus.com/tutorials/create-instagram-filters-with-php--net-24504)
and [again](https://picturepan2.github.io/instagram.css/).
The problem with the attempts is they mostly deal with manually correcting
colors. For me, it was more interesting to find a solution using
a more robust method and maths.

This looks like the only attempt to provide an accurate
color filter reconstruction.
For instance, one of the following images was obtained by applying
the `Clarendon` Instagram filter to the [source image](./static/source.jpg),
while another one was derived via an accurate reconstruction.
Try guessing which one was reconstructed.

To compare, here is the result of applying **the same filter** from
a commercial set of Instagram-like filters.

## How it works

This method is based on
[three-dimensional lookup tables][wiki-luts] and their two-dimensional
representation: [hald images][hald-image].
The core idea is simple: a sample hald image with a uniform color distribution
is processed using a target color filter with an unknown transformation algorithm.
The processed hald image can then be used as a filter for a very accurate
approximation of that target color transformation.

A resulting hald image could then be used in various software such as
GraphicsMagick or Adobe Photoshop.
You can implement those hald images in your iOS or macOS app
with [CocoaLUT][CocoaLUT]. Also, hald images could be converted to the
3D LUT cube file format, which is common in a great number of video editing
software.

## Limitation

This method can capture color transformations only where no other variables are
used for manipulations.
For example, vignetting, scratches, gradients, and watermarks can not be captured.
It also might be wrong when different filters are applied to different parts of
a single image.

## Requirements

To generate and convert hald images, you will need git and a pip-enabled Python
interpreter.

```bash
$ git clone https://github.com/homm/color-filters-reconstruction.git
$ cd color-filters-reconstruction
$ pip install -r requirements.txt
```

The resulting hald images can be applied to any visuals in your application
using GraphicsMagick bindings for Python, Ruby, PHP, JavaScript™, and other
programming languages or using CLI. No software from this repository is required.

## Guide

1. First, you'll need to create the identity image. Just run:

    ```bash
    $ ./bin/generate.py
    ```

    This will create a file named `hald.5.png`.
    The number in the filename stands for the square root of a 3D LUT size.
    For example, `5` means we're dealing with a `25×25×25` lookup table.

    This file doesn't look like other hald images.
    This image is specifically designed to oppose distortions
    which may occur during transformations such as vignetting,
    scratches, gradients, and JPEG artifacts.

2. Process the identity image with a target software you prefer.
    Say, if you were using Instagram, you'd have to transfer the identity
    image to your device and post that image with one of the filters applied.
    After that, you'll see filtered identity image in your camera roll.
    Well, just transfer it back.

    Before continuing, make sure that the resolution of your filtered identity
    image exactly matches that of the source one.

3. Convert the filtered to the real hald image:

    ```bash
    $ ./bin/convert.py raw/1.Clarendon.jpg halds/
    ```

    Where `halds/` is your output directory.

4. That's it!
    You can now apply that resulting hald image to any input.

    ```bash
    $ gm convert sample.jpg -hald-clut halds/1.Clarendon.png out.jpeg
    ```

## Advanced tips

While the default parameters provide you with high-quality hald filters,
there are some cases where it is not enough.

If the target filter has heavy distortions on the local level or significant
gradients in the center of an image, some undesired effects may occur.
The most noticeable one is color banding. This is an original image and the one
processed with the Hudson-like filter, one of the most problematic in this aspect.

```bash
# Create hald image from processed by Instagram identity hald image
$ ./bin/convert.py raw/15.Hudson.jpg halds/
# Apply hald image to the sample image
$ gm convert girl.jpg -hald-clut halds/15.Hudson.png girl.15.jpg
```

You can notice that in the processed image many objects look flat and posterized:
face, hair, chairs in the background.
While posterization is one of the common image filters, it is not a part of the
Hudson filter.

If you thoroughly look at the
[image with a Hudson-like filter applied](./raw/15.Hudson.jpg),
you'll see that it looks noisy, and that's where the problem comes from.

Fortunately enough, you can ask `convert.py` to apply a gaussian blur to the
three-dimensional lookup table to reduce that noise. You'll need to install
[SciPy][scipy] to continue.

```bash
# The next line is only needed once
$ pip install scipy
$ ./bin/convert.py raw/15.Hudson.jpg halds/ --smooth 1.5
$ gm convert girl.jpg -hald-clut halds/15.Hudson.png girl.15.fixed.jpg
```

You can discover the additional `convert.py` options by executing
`./bin/convert.py --help`.

Have fun with reverse engineering!

[wiki-luts]: https://en.wikipedia.org/wiki/3D_lookup_table
[hald-image]: http://www.quelsolaar.com/technology/clut.html
[scipy]: https://www.scipy.org
[CocoaLUT]: http://cocoadocs.org/docsets/CocoaLUT/0.2.31/

repository: grapeot/color-filters-reconstruction

repo_name: grapeot/color-filters-reconstruction


text:
Title: The System Pip On Lion Is Completely Broken??
DisqusId: 6
Slug: the-system-pip-on-lion-is-completely-broken
Tags:
    python
    bugs
Posted: 2012-02-18T19:58:00Z
I sat down to hack on [Pullme](https://github.com/erincall/pullme) for the first time on my new macbook. I ran into unreasonable roadblocks:

----------8<-----------------

```
$ mkvirtualenv pullme
Running virtualenv with interpreter /usr/local/Cellar/python/2.7.2/bin/python
Overwriting pullme/lib/python2.7/orig-prefix.txt with new content
New python executable in pullme/bin/python
Installing setuptools.............done.
Installing pip...............done.
Traceback (most recent call last):
  File "<string>", line 1, in <module>
ImportError: No module named virtualenvwrapper.hook_loader
```

Augh, what is happening? Well, for some reason the pip that comes with OSX Lion puts things in a directory that's _totally unrelated_ to the directories that the system Python searches:

```
$ python -c 'import sys; print "\n".join(map(repr, sys.path))'
''
'/usr/local/Cellar/python/2.7.2/lib/python2.7/site-packages/distribute-0.6.24-py2.7.egg'
'/usr/local/Cellar/python/2.7.2/lib/python2.7/site-packages/pip-1.1-py2.7.egg'
...snip...
'/usr/local/Cellar/python/2.7.2/lib/python2.7/lib-dynload'
'/usr/local/Cellar/python/2.7.2/lib/python2.7/site-packages'
'/usr/local/Cellar/python/2.7.2/lib/python2.7/site-packages/setuptools-0.6c11-py2.7.egg-info'
```

Python is only looking in `/usr/local/Cellar/...`

```
$ locate virtualenvwrapper
/Library/Python/2.7/site-packages/virtualenvwrapper
/Library/Python/2.7/site-packages/virtualenvwrapper/hook_loader.py
/Library/Python/2.7/site-packages/virtualenvwrapper/hook_loader.pyc
...snip...
/Library/Python/2.7/site-packages/virtualenvwrapper-3.0-py2.7.egg-info/requires.txt
/Library/Python/2.7/site-packages/virtualenvwrapper-3.0-py2.7.egg-info/top_level.txt
/usr/local/bin/virtualenvwrapper.sh
```

Meanwhile, `virtualenvwrapper` is installed in `/Library/Python/...`

I solved the problem with a new pip:

```
$ easy_install pip
Searching for pip
Reading http://pypi.python.org/simple/pip/
Reading http://www.pip-installer.org
...snip...
Installed /usr/local/lib/python2.7/site-packages/pip-1.1-py2.7.egg
Processing dependencies for pip
Finished processing dependencies for pip

$ type pip
pip is hashed (/usr/local/bin/pip)

$ hash -r

$ type pip
pip is /usr/local/share/python/pip

$ pip install virtualenvwrapper
Downloading/unpacking virtualenvwrapper
  Downloading virtualenvwrapper-3.0.tar.gz (717Kb): 717Kb downloaded
  Running setup.py egg_info for package virtualenvwrapper
...snip...
    Installing virtualenv script to /usr/local/share/python
Successfully installed virtualenvwrapper virtualenv
Cleaning up...

$ mkvirtualenv pullme
New python executable in pullme/bin/python
Installing setuptools.............done.
Installing pip...............done.
virtualenvwrapper.user_scripts creating /Users/erincall/Envs/pullme/bin/predeactivate
virtualenvwrapper.user_scripts creating /Users/erincall/Envs/pullme/bin/postdeactivate
virtualenvwrapper.user_scripts creating /Users/erincall/Envs/pullme/bin/preactivate
virtualenvwrapper.user_scripts creating /Users/erincall/Envs/pullme/bin/postactivate
virtualenvwrapper.user_scripts creating /Users/erincall/Envs/pullme/bin/get_env_details
```

Success!

It's possible I actually installed `pip` some crazy way, but I don't know where I would've gotten it other than `easy_install`. If Lion really is shipping with a `pip` that _doesn't install packages to Python's `sys.path`_, well geez, that's just terrible.

repository: ErinCall/bloge

repo_name: ErinCall/bloge


text:
Wikibot, a bot which uses the Wiki-library & provides you with features like definitions, titles & other cool stuff!

### Table of Contents
* [Bio](#bio)
* [Bot Commands](#bot-commands)
  * [Def](#1-def)
  * [Title](#2-title)
  * [URL](#3-url)
  * [Lang](#4-lang)
  * [Map](#5-map)
  * [Nearby](#6-nearby)
  * [Random](#7-random)
  * [Others](#8-others)
* [Test](#test)
* [Contribute](#contribute)
* [Credits](#credits)
* [References](#references)

## Bio
When I made this bot there existed no bot which did more than outputting the definition of a word. Wikipedia has a lot more set of functions that were not provided by any of the existing bots. So, this bot was made with the sole purpose of showing other functions that Wiki can provide.

## Bot Commands

### 1. Def
Short form of definition. Fetches wiki definition for your word.
```python
/def
```

### 2. Title
Shows a list of possible titles that you can search from a word.
```python
/title
```

### 3. URL
Provides you with the URL of the wiki page for a word.
```python
/url
```

### 4. Lang
Change to your local language which will be used for every wiki output.
```python
/lang
/prefix
```

### 5.  Nearby
With the help of coordinates provides you with nearby locations under 1km.
```python
/nearby
```

### 7. Random
Sends you a random wiki link.
```python
/random
```

### 8. Others
Some other set of commands that wikibot provides.
```python
/help
/extra
/spot
/suggest
/dev
/source
/issues
```

## Test
To test this bot. You can follow these steps:
1. Setup a Bot with **[BotFather](https://t.me/botfather)**.
2. Put your **Token** in
```python
TOKEN = ''
```
3. Setup **RTDB** in **[Firebase](https://firebase.google.com/)**.
4. Download your **key file**, place it next to your bot file
```python
cred = credentials.Certificate('xxxYOURKEYFILExxx.json')
```
5. Paste your RTDB url in
```python
firebase_admin.initialize_app(cred, {'databaseURL': 'https://yourappname-user-default-rtdb.firebaseio.com/'})
```
6. Setup a project in **Heroku**.
7. Paste your Project url in
```python
bot.set_webhook(url='https://yourappname.herokuapp.com/' + TOKEN)
```
8. Files you need for Heroku
```heroku
xxxYOURKEYFILExxx.json #firebase key
Procfile
bot.py
requirements.txt
```
9. To resolve bugs
```heroku
Heroku --logs
```

## Contribute
Thank you for considering contributing to Wikibot. Please add useful comments with your PR's.

To contact me go [here](https://telegram.me/themagicalmammal).

## Credits
#### [kurkurzz](https://github.com/kurkurzz) - Introducing the keyboard & some optimized commands.

## References
#### 1. [Webhook](https://github.com/eternnoir/pyTelegramBotAPI/tree/master/examples/webhook_examples) - To learn how to add a webhook to your bot.
#### 2. [Telebot](https://github.com/eternnoir/pyTelegramBotAPI/tree/master/examples) - Bot examples for texts & commands.
#### 3. [Firebase](https://www.youtube.com/watch?v=EiddkXBK0-o) - Easy way to learn about firebase.
#### 4. [Wiki-libs](https://wikipedia.readthedocs.io/en/latest/) - Simple docs to learn about its functions.

repository: reejit/Wikibot

repo_name: reejit/Wikibot


text:
## How to create spreadsheet in PHP with ByteScout Spreadsheet SDK

### The tutorial shows how to create spreadsheet in PHP

The sample source codes on this page shows how to create spreadsheet in PHP. What is ByteScout Spreadsheet SDK? It is the SDK component for writing, reading, modifying and calculating Excel and CSV spreadsheets. Can calculate and reculculate formulas with Excel installed. You may import or export data to and from CSV, XML, JSON. Supports export to databases, arrays, streams. It can help you to create spreadsheet in your PHP application.

You will save a lot of time on writing and testing code as you may just take the PHP code from ByteScout Spreadsheet SDK for create spreadsheet below and use it in your application. In your PHP project or application you may simply copy & paste the code and then run your app! Detailed tutorials and documentation are available along with installed ByteScout Spreadsheet SDK if you'd like to dive deeper into the topic and the details of the API.

You can download free trial version of ByteScout Spreadsheet SDK from our website to see and try many others source code samples for PHP.

## Get In Touch

[Click here to get in touch](https://bytescout.zendesk.com/hc/en-us/requests/new?subject=ByteScout%20Spreadsheet%20SDK%20Question)

or send email to [support@bytescout.com](mailto:support@bytescout.com?subject=ByteScout%20Spreadsheet%20SDK%20Question)

## Free Trial Download

[Get Your 60 Day Free Trial](https://bytescout.com/download/web-installer?utm_source=github-readme)

## Web API (On-demand version)

[Get your free API key](https://pdf.co/documentation/api?utm_source=github-readme)

## API Documentation and References

[Explore ByteScout Spreadsheet SDK Documentation](https://bytescout.com/documentation/index.html?utm_source=github-readme)

[Explore Web API Documentation](https://pdf.co/documentation/api?utm_source=github-readme)

[Check Free Training Sessions for ByteScout%20Spreadsheet%20SDK](https://academy.bytescout.com/)

## Video Review

[https://www.youtube.com/watch?v=nm_7I0PN1TY](https://www.youtube.com/watch?v=nm_7I0PN1TY)

repository: repohoarder/ByteScout-SDK-SourceCode

repo_name: repohoarder/ByteScout-SDK-SourceCode


text:
[![Docker](https://img.shields.io/docker/pulls/nejdetkadirr/freetube.svg)](https://hub.docker.com/r/nejdetkadirr/freetube)

# Freetube
![cover](doc/cover.png)
Freetube is like free and ad-free Youtube and it is created with NuxtJS

# Preview
You can watch preview from [here](https://youtu.be/oCXmQME4cXs)

## Build Setup
install dependencies
```bash
$ yarn install
```

serve with hot reload at localhost:3000
```bash
$ yarn dev
```

build for production and launch server
```bash
$ yarn build
$ yarn start
```

generate static project
```bash
$ yarn generate
```
## You can use with docker
Pull from docker hub
```bash
$ docker pull nejdetkadirr/freetube:1.0.0
```
Then run it
```
$ docker run -p <your port>:3000 <image id or vs.>
```

For detailed explanation on how things work, check out [Nuxt.js docs](https://nuxtjs.org).

repository: nejdetkadir/freetube

repo_name: nejdetkadir/freetube


text:
# Performance enhanced version

Changes have been made to the Adafruit.cpp drawChar() funtion to improve rendering speed of the free fonts significantly.

To aid performance enhancment tests there are #define switches within that function as follows:

If FAST_LINE is #defined then the free fonts are rendered using horizontal lines this makes rendering fonts 2-5 times faster. Particularly good for large fonts.
This is an elegant solution since it still uses generic functions present in the stock library.

If FAST_SHIFT is defined then a slightly faster (for AVR) shifting bit mask is used. The performance gain is small but worthwhile at 10%.

The overal performance gain will be dependant on the font and how many multipixel horizontal lines are in the rendered character. Even small fonts show a significant perfromance improvement even though there are many single pixel plots needed.

The test case for the performance test here is to print "Hello world" (lower case w) in different fonts.

When saved in your library folder it must be given the name Adafruit_GFX (remove the _plus from the folder name)

# Adafruit GFX Library

This is the core graphics library for all our displays, providing a common set of graphics primitives (points, lines, circles, etc.). It needs to be paired with a hardware-specific library for each display device we carry (to handle the lower-level functions).

Adafruit invests time and resources providing this open source code, please support Adafruit and open-source hardware by purchasing products from Adafruit!

Written by Limor Fried/Ladyada for Adafruit Industries.
BSD license, check license.txt for more information.
All text above must be included in any redistribution.

Recent Arduino IDE releases include the Library Manager for easy installation. Otherwise, to download, click the DOWNLOAD ZIP button, uncompress and rename the uncompressed folder Adafruit_GFX. Confirm that the Adafruit_GFX folder contains Adafruit_GFX.cpp and Adafruit_GFX.h. Place the Adafruit_GFX library folder your <arduinosketchfolder>/Libraries/ folder. You may need to create the Libraries subfolder if its your first library. Restart the IDE.

# Useful Resources

- Image2Code: This is a handy Java GUI utility to convert a BMP file into the array code necessary to display the image with the drawBitmap function. Check out the code at ehubin's GitHub repository: https://github.com/ehubin/Adafruit-GFX-Library/tree/master/Img2Code

- drawXBitmap function: You can use the GIMP photo editor to save a .xbm file and use the array saved in the file to draw a bitmap with the drawXBitmap function. See the pull request here for more details: https://github.com/adafruit/Adafruit-GFX-Library/pull/31

- 'Fonts' folder contains bitmap fonts for use with recent (1.1 and later) Adafruit_GFX. To use a font in your Arduino sketch, #include the corresponding .h file and pass address of GFXfont struct to setFont(). Pass NULL to revert to 'classic' fixed-space bitmap font.

- 'fontconvert' folder contains a command-line tool for converting TTF fonts to Adafruit_GFX .h format.


text:
# TypeScript-LINQ test project with qunit.

This is the test project for the "TypeScript-LINQ" module.

The test suite is based on the 'qunit' test framwork.

## Requirements

The references to the "TypeScript-LINQ" library and the "TypeScript-Base" library must be resolved.

The easiest way to do this is to clone the "TypeScript-Base", "TypeScript-LINQ" and this solution and to store them in the same directory.

## Running

You can run the test suite after a successful build of this and all dependant solutions. Select the file "TestSuite.html" in the root directory of this solution as your start page and hit the "F5" key. Make sure, that you start with one of the latest chrome or firefox browsers. There is currently no microsoft browser which supports the latest JavaScript standard.

##License

This software is licensed under the "Microsoft Public License".

See: [MS-PL](https://opensource.org/licenses/MS-PL")

&copy<EMAIL_ADDRESS>2016

license: MS-PL

repository: lord-saumagen/TypeScript-LINQ-Test

repo_name: lord-saumagen/TypeScript-LINQ-Test


text:
## SYNOPSIS

This is a collection of notes on Unix (primarily illumos) as I work
through various things.

## ENTRIES

Nothing to see.

## IN-PROGRESS

* [the illumos boot process](/5/illumos-boot.html)

## SEE ALSO

[about](/about.html),
[cscope(1)](http://cscope.sourceforge.net/),
[illumos](https://github.com/illumos/illumos-gate)

## REFERENCES

[**APUE**] W. Richard Stevens and Stephen A. Rago. 2013. *Advanced
Programming in the Unix Environment (3rd Edition)*. Addison-Wesley,
Upper Saddle River, NJ, USA.

[**SI**] Jim Mauro and Richard McDougall. 2006. *Solaris Internals
(2nd Edition).* Prentice Hall PTR, Upper Saddle River, NJ, USA.

license: ISC

repository: kisom/unix-notes

repo_name: kisom/unix-notes


text:
# representabot

## About me

Hi, I am `representabot`. I am a Twitter Bot that tweets regular updates of the latest votes in the U.S. Senate. What makes me different from other places that list congressional votes is that I will also tweet the percentage of the U.S. population represented by yeas and nays. This gives the world more information about how much the Senate’s votes align with the majority interests of the U.S.

## Methodology

### Data sources

All vote data and vote totals come from the [U.S. Senate](https://senate.gov) website. Data for state population comes from the [Census API](https://api.census.gov).

### Calculating representation

To calculate representation, a state's population is added each time a Senator from that state votes a specific way ("yea" or "nay"). The sum of these two numbers is divided by twice our calculated total of the U.S. population. (I do not include D.C. or Puerto Rico in this calculation, which means our statistic overestimates the percent of total people represented.)

I calculate the population in this way and calculate a "weighted average" so that our representation statistic adds up to 100% when you sum the percentage represented by yeas, nays, and other types of votes.

## Setting Me Up

### Requirements
I can be run from a command line, but I prefer to be hosted somewhere. I’m currently configured by my maker to use Amazon Web Services. Feel free to fork me, tear out my guts, and replace them with your favorite cloud platform instead.

I also store a running memory of my tweets in a CSV file. By default, this file is hosted on an AWS S3 bucket. There is an [empty version of this file][data/tweets.csv] in the repository for you to start with.

See [AWS documentation](https://docs.aws.amazon.com/index.html) for more details on setting up AWS. You’ll need to look at [Lambda](https://docs.aws.amazon.com/lambda/) and [S3](https://docs.aws.amazon.com/s3/) in particular.

I also need access to a Twitter account and their developer API. This comes in the form of four tokens: a consumer key, a consumer secret, an access token, and an access token secret. You can generate these for me from the [Twitter Developer Platform](https://developer.twitter.com).

Finally, I also require access to US Census data via their [Census API](https://www.census.gov/data/developers.html). You can [request a key](https://api.census.gov/data/key_signup.html) from the [US Census website](https://www.census.gov).

### Configuration
I use environment variables to run, which can be set in the AWS Lambda setup. Here's what I need. (See `env.sample` in the repo as well)

```
# AWS
AWS_ACCESS_KEY=<AWS access key>
AWS_SECRET_ACCESS_KEY=<AWS secret access key>
AWS_BUCKET_NAME=<AWS bucket name>
OBJ_FILENAME=<CSV filename, e.g. tweets.csv>

# Census data
CENSUS_API_KEY=<API key from the US Census API>

# Twitter
CONSUMER_KEY=<First of four keys provided by Twitter’s API>
CONSUMER_SECRET=<Second Twitter key>
ACCESS_TOKEN=<Third Twitter key>
ACCESS_TOKEN_SECRET=<Fourth and final Twitter key, whew>
MAX_TWEETS=<Any integer, defaults to 4>
```

### Usage
You can run me with the following command:

```
python bot.py --congress <congress number> --session <senate session>
```

E.g.

```
python bot.py --congress 117 --session 1
```

Assuming everything is properly configured, I should tweet summaries of votes taken in the Senate for the current session.

### Advanced config/features
I’m not really a bot if I don’t run without a human instructing me what to do. In order to bring me to life, you will need to set up AWS Lambda and deploy me to that service. That is beyond the scope of this document, so please see the AWS Lambda documentation for more details.

You can also fool me into skipping votes by adding details to the CSV "database". If you don't want me to tweet about certain votes, just add fake entries to the database. I won’t be mad.

## Getting Help
If you have questions, concerns, bug reports, etc., please file an issue in this repository's [Issue Tracker](https://github.com/Protect-Democracy/representabot/issues).

## Getting Involved
See my instructions in [CONTRIBUTING](CONTRIBUTING.md).

----

## Open source licensing info
1. [TERMS](TERMS.md)
2. [LICENSE](LICENSE)

repository: Protect-Democracy/representabot

branch_name: refs/heads/main

gha_language: Python

repo_name: Protect-Democracy/representabot


text:
## 3.0.0

 - Graduate package to a stable release. See pre-releases prior to this version for changelog entries.

## 3.0.0-dev.19

 - Update a dependency to the latest release.

## 3.0.0-dev.18

 - Update a dependency to the latest release.

## 3.0.0-dev.17

 - Update a dependency to the latest release.

## 3.0.0-dev.16

 - Update a dependency to the latest release.

## 3.0.0-dev.15

 - Update a dependency to the latest release.

## 3.0.0-dev.14

 - Update a dependency to the latest release.

## 3.0.0-dev.13

 - **FEAT**: support for hasura auth and storage client and refactor them to accept only URL.

## 3.0.0-dev.12

 - **FEAT**: Support for Subdomain cloud hosting and ServiceUrls self-hosting Nhost projects.

## 3.0.0-dev.11

 - **FEAT**: seperating all clients into their own packages.

## 3.0.0-dev.10

 - Update a dependency to the latest release.

## 3.0.0-dev.9

 - **FIX**: fix analyzer to fix ci.

## 3.0.0-dev.8

 - Update a dependency to the latest release.

## 3.0.0-dev.7

 - **FIX**: fix token expire time to be second and fix example of persistent token and silent login.

## 3.0.0-dev.6

 - **FIX**: bug in server and parsing user metadata.
 - **FEAT**: support for subdomain api.

## 3.0.0-dev.5

 - Update a dependency to the latest release.

## 3.0.0-dev.4

 - Update a dependency to the latest release.

## 3.0.0-dev.3

 - Update a dependency to the latest release.

## 3.0.0-dev.2

 - **FIX**: fix analyzer on ci for both stable and beta flutter sdk.
 - **FEAT**: add analyze command to melos.

## 3.0.0-dev.1

 - Update a dependency to the latest release.

## 3.0.0-dev.0

> Note: This release has breaking changes.

 - **FIX**: upgrade deps.
 - **BREAKING** **FEAT**: increase flutter sdk constrain.

## 2.0.4

- **FEAT**: Add `metadata` to sign up

## 2.0.3

- **CHORE**: bump `nhost_sdk` version

## 2.0.2

- **FIX**: nhost_flutter_auth: deprecated functions.

## 2.0.1

- **DOCS**: Update pubspec sample in READMEs.

## 2.0.0

- Graduate package to a stable release. See pre-releases prior to this version for changelog entries.

## 2.0.0-beta.3

- Update a dependency to the latest release.

## 2.0.0-beta.2

> Note: This release has breaking changes.

- **REFACTOR**: Change all instances of login to sign in.
- **BREAKING** **REFACTOR**: Rename signIn -> signInEmailPassword.

## 2.0.0-beta.1

> Note: This release has breaking changes.

- **BREAKING** **REFACTOR**: Change client names to include the word client.

## 2.0.0-beta.0

> Note: This release has breaking changes.

- **BREAKING** **FEAT**: Migrate to the Nhost v2 backend.

## 1.0.11

- **FIX**: Remove outdated links.
- **FIX**: Remove unneeded imports across the board.

## 1.0.10

- Update a dependency to the latest release.

## 1.0.9

- **FIX**: Fix broken URLs across packages.
- **DOCS**: Remove mention of older Flutter support from READMEs.
- **CHORE**: Satisfy a couple of the new lints.
- **CHORE**: Upgrade to latest stable SDK.
- **CHORE**: Upgrade dependencies.
- **CHORE**: Publish packages.
- **CHORE**: Publish packages.
- **CHORE**: Publish packages.

## 1.0.8

- Update a dependency to the latest release.

## 1.0.7

- **FIX**: Update NhostAuthProvider to rebuild on transitions from loading -> logged{In,Out}.

## 1.0.6

- Update a dependency to the latest release.

## 1.0.5

- Update a dependency to the latest release.

## 1.0.4

- Update a dependency to the latest release.

## 1.0.3

- Graduate package to a stable release. See pre-releases prior to this version for changelog entries.

## 1.0.3-dev.2

- Update a dependency to the latest release.

## 1.0.3-dev.1

- Update a dependency to the latest release.

## 1.0.3-dev.0

- Update a dependency to the latest release.

## 1.0.2

- **FIX**: Function signature in OAuth example.
- **FIX**: Incorrect host in OAuth example.
- **DOCS**: Fixed broken links in all README.md.
- **CHORE**: Fill in a comment.

## 1.0.1

- **DOCS**: Update links to point to future repo home.
- **DOCS**: Add issue_tracker field to all pubspecs.
- **DOCS**: Update repository urls in pubspecs.
- **DOCS**: Update all version numbers in README getting starteds.
- **DOCS**: Update test badge on all repos.

## 1.0.0

- 🛳🐿

## 0.3.0+2

- **FIX**: Fix the OAuth provider login flow example.
- **CI**: Set up repository-wide continuous tests.
- **CHORE**: Change name of example package.
- **CHORE**: Publish packages.

## 0.3.0+1

- **DOCS**: Update links in example READMEs to point to monorepo.
- **CHORE**: Update imports to point to new nhost_sdk top-level.
- **CHORE**: Add a standard Flutter .gitignore to the example.
- **CHORE**: Update package repository URLs.

## 0.3.0

- Update to latest nhost_sdk

## 0.2.0

- NhostAuthProvider.of no longer fails if authentication information cannot be
  found

## 0.1.0

- Migrate to newer APIs
- Add examples
- Rename parameter

## 0.0.0

- First version, in pre-release

repository: MaxSchilling/nhost-dart

repo_name: MaxSchilling/nhost-dart


text:
Bracelet VI
===============
**Please note: This thing is part of a list that was [automatically generated](https://github.com/carlosgs/export-things) and may have been updated since then. Make sure to check for the current license and authorship.**

Bracelet VI  by MakeALot , published Mar 27, 2011

![Image](img/slottedBracelet_display_large_display_large.jpg)

Description
--------
Slotted concave bracelet

Instructions
--------
Unprinted as yet...

Files
--------
[![Image](img/slottedBraceletLeft_preview_tinycard.jpg)](slottedBraceletLeft.stl)
 [ slottedBraceletLeft.stl](slottedBraceletLeft.stl)

[![Image](img/slottedBracelet_preview_tinycard.jpg)](slottedBracelet.stl)
 [ slottedBracelet.stl](slottedBracelet.stl)

[![Image](img/Gears_preview_tinycard.jpg)](slottedBracelet.scad)
 [ slottedBracelet.scad](slottedBracelet.scad)

Pictures
--------
![Image](img/slottedBracelet_display_large.jpg)
![Image](img/slottedBraceletLeft_display_large.jpg)

Tags
--------
bracelet , openscad

License
--------
Bracelet VI by MakeALot is licensed under the BSD License license.

By: Mark Durbin (MakeALot)
--------
<http://NestedCube.com/>

repository: seffyroff/thingiverse-designs

repo_name: seffyroff/thingiverse-designs


text:
# Scripts for Seismic Computing SCEDC Data on AWS cloud

## Steps to get up and running with Python and/or Julia

1. Log into AWS using

2. Launch a fresh EC2 instance
- Step 1 Choose AMI: Select Ubuntu Server 18.04 LTS
- Step 2 Choose an Instance Type: m5a.large are good for build & testing.
- Step 3 Configure Instance Details: Turn on IAM role to access S3 to avoid using AWS credentials on EC2. **Do not leave AWS credentials on public AMI**
- Step 4 Add Storage: Increase EBS volume size to 100 GB to host sample mseed data.

3. Install Python and Julia using:
- Anaconda python environment. See [./build_environment/python](./build_environment/python)
- Julia installer. See[./build_environemt/julia](./build_environment/julia)

4. Pull data from S3. See [./download_data](./download_data)

5. Run sample Python/Julia code on mseed data.

repository: tclements/SCEDC-AWS

repo_name: tclements/SCEDC-AWS


text:
# Change Log

All notable changes to this project will be documented in this file. This
project adheres to [Semantic Versioning](http://semver.org/).

## 0.16.0-0

* `react` peer dependency version bumped to 16.x
* `react-dom` peer dependency version bumped to 16.x
* `react-redux` peer dependency version bumped to 7.x
* `redux` peer dependency version bumped to 4.x

## 0.14.1

* Update outdated dependencies to their latest version.

## 0.14.0

In this release, Redux Fetch will use Redux as the source of truth so that data
between the server and client can be shared accordingly. An overhaul of the
implementation was required and therefore is not backwards compatible.

* Use Redux to record fetch state between server and client.

* Renamed `fetch` to `withFetch` to avoid conflict with native Fetch API.

* The `FetchRootContainer` is the only component using `StaticContainer` to
  continue rendering the previous view until the data required to render the
  next view is fetched from the server.

* The `FetchContainer` is a higher-order component whose only purpose is to
  declare the function used to fulfill the data required to render a component
  as a static method.

* Additional documentation regarding usage in different scenarios were added.

## 0.12.2

* Fix issue where rendering errors were swallowed.

## 0.12.1

* Export React Router middleware in main file

## 0.12.0

* Add a React Router middleware.

## 0.11.1

* Fix an issue where modules would not be found in some environments.

* Update documentation with argument and return value types.

## 0.11.0

* Complete API overhaul that simplifies the library integration by leveraging
  React Router 2 API

## 0.10.0

* Fix an issue where data requirements are not fulfilled before transitioning
  between components on the client side.

  The issue surfaced as a result of the changes made to `0.9.4` where the fetch
  container was updated to perform fulfillment of data requirements on
  `componentDidMount` instead of `componentWillMount` to ensure the component
  is rendered on the server-side and prevent warnings in React when `setState`
  is called unexpectedly.

  *We feel that this fix is hackish and will go back to the drawing board to
  figure out a better way to handle universal rendering with React Router
  and Redux.*

* Some breaking changes were made to the API to help clarify the context in
  which things are executed:

  - Renamed `shouldFetchOnMount` to `shouldFetchBeforeMount` and changed the
    order of the injected parameters.
  - Renamed `shouldFetchOnUpdate` to `shouldFetchBeforeUpdate` and changed the
    order of the injected parameters.
  - Renamed `renderSuccess` to `renderFetched`
  - Renamed `fetchRouteData` to `fetchAsyncStateOnServer`

## 0.9.4

* Fix an issue where `setState()` was called unexpectedly while server-side
  rendering a wrapped component.

## 0.9.3

* Fix an issue where calling `fetchRouteData` with an `undefined` component
  results in an error.

## 0.9.2

* Removed `./utilities/fetch-data` module.

* Moved store prop types definition into its own file, namely
  `./utilities/store-shape.js`.

* Modified language in render error messages to feel similar to those around
  the React community.

## 0.9.1

* Fix unresolvable path in entry file

## 0.9.0

* New `renderSuccess` callback option was added to `fetch` higher order component.

* Unset default render callbacks for loading and error states. Instead users
  will need to explicitly define them in each component wrapped with
  `fetch()` or globally using `fetch.setup()`.

## 0.8.1

* Fix issue where fetchers are not called when route component is updated with
  different locations.

## 0.8.0

* Rename options that indicate whether HOC should fetch on mount and update.

* Fix issue where `setState()` is called after components are unmounted.

* Fix issue where fetchers are called multiple times between route transitions.

* Fix issue where application state is not injected into `shouldFetchOnUpdate` option.

* Fix issue where rendering errors are swallowed in promise chain.

## 0.7.0

* By default, the `fetch` higher order component will fetch data when mounted
  or updated, unless specified to do otherwise using `fetchOnMount()` or
  `fetchOnUpdate()` options.

* The `forceInitialFetch` option was removed in favor of the `fetchOnMount()`
  function, which can be configured globally with `fetch.setup()`.

## 0.6.0

* Forward props passed to wrapped components to `getInitialAsyncState`.
  It allows developers to access props passed from React Router to their
  components. Unfortunately, in universal applications, populating this
  parameter requires the developer to pass it to `fetchRouteData`,
  potentially leading to discrepancies since React Router provide slightly
  different properties.

## 0.5.0

* Move `react` and `redux` to peer dependencies

## 0.4.0

* Reflect project rename across all files.

## 0.3.0

* Settings configured with `fetch.setup()` apply to all unmounted/uninitialized
  fetcher components returned by `fetch()`.

## 0.2.0

* A new `<Glitch />` component rendered when an uncaught error occurs after
  fetching data.

* Ability to configure loading component rendered while fetching.

* Ability to configure failure component rendered when an uncaught error
  occurs after fetching.

* Ability to force a request to the server even after data is hydrated on the
  Redux store after first render.

* Ability to change the default behavior for the `fetch` component globally
  using `fetch.setup` function.

* Modifying the store state via the `fetchReducer` is no longer needed to
  figure out whether the wrapped route components should send a request to the
  server on first mount.

## 0.1.0

* Initial release

repository: flowcommerce/redux-fetch

gha_language: JavaScript

repo_name: flowcommerce/redux-fetch


text:
### [CVE-2006-1599](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2006-1599)
![](https://img.shields.io/static/v1?label=Product&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Version&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Vulnerability&message=n%2Fa&color=brighgreen)

### Description

Unspecified vulnerability in VCEngine.php in v-creator before 1.3-pre3, when the VC_CRYPTO_METHOD option is OPENSSL, allows remote attackers to execute arbitrary commands, possibly due to problems in the (1) encrypt and (2) decrypt functions.

### POC

#### Reference
No PoCs from references.

#### Github
- https://github.com/ARPSyndicate/cvemon
- https://github.com/chnzzh/OpenSSL-CVE-lib

repository: trickest/cve

repo_name: trickest/cve


text:
# Edge Detection Using Genetic Algorithm

- Implement "![Edge detection in medical images using a genetic algorithm]"

  [Edge detection in medical images using a genetic algorithm]:https://ieeexplore.ieee.org/abstract/document/712136/

- result:
  32x32 pixels:
  ![medical32]
  64x64 pixels:
  ![medical64]
  128x128 pixels:
  ![medical128]

  [medical32]:https://github.com/yangchengwei/genetic_algorithms/blob/master/project_4/results/medical32.gif
  [medical64]:https://github.com/yangchengwei/genetic_algorithms/blob/master/project_4/results/medical64.gif
  [medical128]:https://github.com/yangchengwei/genetic_algorithms/blob/master/project_4/results/medical128.gif


text:
---
layout: post
title:      "Creating a CLI Gem about Podcasts Part 1"
date:       2018-02-05 15:07:31 -0500
permalink:  creating_a_cli_gem_about_podcasts
---

It is an amazing feeling to feel like I am starting to "get it." I'm starting to feel like a coder. Anyway. The last week and a half has been quite a learning experience. I have just finished my CLI gem and it actually works.

Here is how it went.

# Learn by example

1. I watched the Ari's walkthrough for his "Daily Deal" gem.
2. Then I cloned the two examples of gems, "Now Playing and Best Restaurants."

I wanted to understand the structure of how gem's are laid out.
I wanted to solidify the relationships between classes and methods.
I wanted to better understand scraping.

Now it was time to create my own gem.

# Questions I asked myself:

1.  What is something I am interested in?
2.  What is something that changes day to day
3.  What is something that has straight forward relationships

The answer? PODCASTS

So, I set out to create my CLI gem about the top 200 podcasts.

Process

Plan my gem. Decide how the interface will work.

**A command line interface for current top 200 podcasts**

User types top_podcasts

User is welcomed to the top podcasts gem.
User is asked to enter a range of ten numbers, i.e. 1-10, 11-20, etc.
Once user enters the numbers a list of ten podcasts are shown, sorted by rank

1. Rank, Podcast
2. Rank, Podcast
3. Rank, Podcast
4. Rank, Podcast
5. Rank, Podcast
6. Rank, Podcast
7. Rank, Podcast
8. Rank, Podcast
9. Rank, Podcast
10. Rank, Podcast

Which podcast do you want to know more about?

“1”

User enters the number of the podcast he/she is interested in.

User is shown the rank, title and summary of that particular podcast.

Then user is asked if he/she would like to choose another podcast?

User types Y or N

If Y then the process starts over.

If X then the user is given a goodby message.

**Now that I had a plan, it was time to create my gem layout with Bundler.**

In learn IDE, I typed bundle install “top_podcasts”
The Gem layout was in place.

Next, I created by bin file “top_podcasts,” which would eventually call my CLI class. I knew that I needed to require the bundler/setup and “top_podcasts” folders. I would need to also set a method to instantiate the CLI method “call” when executed.

Next, I decided to tackle the CLI class.

I started by entering what I wanted the program to do.

User enters "top_podcast,
then the program starts with a welcome message.
It then asks the user for input.
it iterates over data and returns a list of podcasts, based on user input
It then asks the user to enter a number for the podcast he/she is interested in
It returns the podcast with a summary of the podcast
It then asks the user if he/she would like information on another podcast.
If yes, then the process starts over, if no then the program terminates with a goodby message.

Here is the code I came up with:

```class TopPodcasts::CLI

  def call
    TopPodcasts::Scraper.new.make_podcasts
    puts "Welcome to the top 50 podcasts:"
    start
  end

  def start
    puts ""
    puts "What number podcasts would you like to see? 1-10, 11-20, 21-30, 31-40 or 41-50?"
    input = gets.strip.to_i

    print_podcasts(input)

    puts ""
    puts "What podcast would you like more information on?"
    input = gets.strip

    podcast = TopPodcasts::Podcast.find(input.to_i)

    print_podcast(podcast)

    puts ""
    puts "Would you like to see another podcast? Enter Y or N"

    input = gets.strip.downcase
      if input == "y"
          start
      else
        puts ""
        puts "Thankyou! Have a great day!"
        exit
      end
    end

  def print_podcast(podcast)
    puts ""
    puts "----------- #{podcast.rank} - #{podcast.name} -----------"
    puts ""
    puts "----------------------------Summary---------------------------"
    puts ""
    puts "#{podcast.summary}"
    puts ""
  end

  def print_podcasts(from_number)
    puts ""
    puts "---------- Podcasts #{from_number} - #{from_number+9} ----------"
    puts ""
    TopPodcasts::Podcast.all[from_number-1, 10].each.with_index(from_number) do |podcast, index|
      puts "#{podcast.rank} - #{podcast.name}"
    end
  end
end
```

# Next, Podcast class
I asked myself, what is a podcast?  What does it contain?  The answer - A name, a rank, and a summary.

Here is what I came up with:

```class TopPodcasts::Podcast

  attr_accessor :name, :rank, :summary

    @@all = []

    def self.new_from_index_page(p)
    self.new(
      p.css("h3").text.gsub(/\t/, '').strip,
      p.css(".numberImage").text.gsub(/\t/, '').strip,
      p.css("p").text.strip
      )
  end

  def initialize(name = nil, rank = nil, summary = nil)
    @name = name
    @rank = rank
    @summary = summary
    @@all << self
  end

  def self.all
    @@all
  end

  def self.find(id)
    self.all[id-1]
  end
end```

With this in place, I knew that the self.new_from_index_page(p) method would create a new instance of a podcast with scraped data taken from the scraper class. It would initialize and each podcast would be included in the @@all array.

I also created a self.find(id) method so that one could search for podcasts by number

# Scraper class

Here is what I have for my Scraper class. Pretty straightforward.

**Get_page** method gets the podcast website we are scraping from using Nokogiri.
**Get_podcasts** method gets all of the data from the page.
**make_podcasts** method iterates over the **get_podcasts method** and returns a podcast with data scraped from the Podcast.new_from_index_page(p) method.

```class TopPodcasts::Scraper

  def get_page
    Nokogiri::HTML(open("http://toppodcast.com/top-200-podcast/"))
  end

  def get_podcasts
    self.get_page.css(".podcastRow")
  end

  def make_podcasts
    self.get_podcasts.each do |p|
    TopPodcasts::Podcast.new_from_index_page(p)
    end
  end
end
```

Once all of this was in place. The program magically came to life.

extension: markdown


text:
# LEARNING FROM RULES GENERALIZING LABELED EXEMPLARS (ICLR 2020)

This repository provides an implementation of experiments in our [ICLR2020 paper](https://openreview.net/forum?id=SkeuexBtDr)
```
@inproceedings{
Awasthi2020Learning,
title={Learning from Rules Generalizing Labeled Exemplars},
author={Abhijeet Awasthi and Sabyasachi Ghosh and Rasna Goyal and Sunita Sarawagi},
booktitle={International Conference on Learning Representations},
year={2020},
url={https://openreview.net/forum?id=SkeuexBtDr}
}
```

# Requirements
This code has been developed with
  - python 3.6
  - tensorflow 1.12.0
  - numpy 1.17.2
  - snorkel 0.9.1
  - tensorflow_hub 0.7.0

# Data Description
We have currently released processed version of 4 datastes used in our paper.
Following datasets can be found in data/ directory
  * TREC - Question Classification task (Source: http://cogcomp.org/Data/QA/QC/)
  * MITR - Slot filling task (Source: https://groups.csail.mit.edu/sls/downloads/restaurant/)
  * YOUTUBE - Spam Classification task of youtube comments (Source: http://www.dt.fee.unicamp.br/~tiago//youtubespamcollection)
  * SMS - Spam classification task of text messages (Source: https://archive.ics.uci.edu/ml/datasets/SMS+Spam+Collection)
  * Please see the README files in individual dataset directiories for more information

## data/TREC (or any other data dir) consists following four pickle files
  * d_processed.p (d set: labeled data -- In paper we refer to this is as the "L" dataset)
  * U_processed.p (U set: unlabeled data -- In paper as well this is referred as "U" dataset)
  * validation_processed.p (validation data)
  * test_processed.p (test data)
  * **NOTE** U_processed.p for YOUTUBE and MITR is unavailable on GitHub due to larger size. You can download entire data dir from [this](https://drive.google.com/file/d/1dWTUC_f0Ks-Hg4TtkHrwWy0RmzLMH-X1/view?usp=sharing) link

## Following objects are dumped inside each pickle file
* x : feature representation of instances
    - shape : [num_instances, num_features]
* l : Class Labels assigned by rules
    - shape : [num_instances, num_rules]
    - class labels belong to {0, 1, 2, .. num_classes-1}
    - l[i][j] provides the class label provided by jth rule on ith instance
    - if jth rule doesn't cover ith instance, then l[i][j] = num_classes (convention)
    - in snorkel, convention is to keep l[i][j] = -1, if jth rule doesn't cover ith instance
* m : Rule coverage mask
    - A binary matrix of shape [num_instances, num_rules]
    - m[i][j] = 1 if jth rule cover ith instance
    - m[i][j] = 0 otherwise
* L : Instance labels
    - shape : [num_instances, 1]
    - L[i] = label of ith instance, if label is available i.e. if instance is from labeled set d
    - Else, L[i] = num_clases if instances comes from the unlabeled set U
    - class labels belong to {0, 1, 2, .. num_classes-1}
* d : binary matrix of shape [num_instances, 1]
    - d[i]=1 if instance belongs to labeled data (d), d[i]=0 otherwise
    - d[i]=1 for all instances is from d_processed.p
    - d[i]=0 for all instances in other 3 pickles {U,validation,test}_processed.p
* r : A binary matrix of shape [num_instances, num_rules]
    - r[i][j]=1 if jth rule was associated with ith instance
    - Highly sparse matrix
    - r is a 0 matrix in all the pickles except d_processed.p
    - Note that this is different from rule coverage mask "m"
    - This matrix defines the coupled rule,example pairs.

# Usage

From src/hls

* For reproducing numbers in Table 1, Row 1
  - python3 get_rule_related_statistics.py ../../data/TREC 6 None
  - This also provides Majority Vote accuracy in Table2  Column2 (Question dataset)
* For training, saving and testing a snorkel model
  - python3 run_snorkel.py ../../data/TREC 6 None
  - (**RUN THIS BEFORE EXPERIMENTS WHICH DEPEND ON SNORKEL LABELS**) if snorkel model is not already saved in the dataset directory.
  - We have released pre-trained snorkel models in each dataset directory with name "saved_label_model" )
* For reproducing (approximately) numbers in Table2 Column2 (Question dataset)
  - use train_TREC.sh for training models for different loss functions
  - use test_TREC.sh for testing models for different loss functions
  - best hyperparameters are already set in these scripts
  - both of the above scripts use TREC.sh
* For reproducing numbers (approximately) for other datasets follow steps same as above, with TREC replaced by the dataset name.

# Note:
* f network refes to the classification network
* w network refers to the rule network

# File Description in src/hls
* analyze_w_predictions.py - Used for diagnostics (Old Precision Vs Denoised Precision in Figure 3)
* checkpoint.py - Load/Save checkpoints (Uses code from [checkmate](https://github.com/vonclites/checkmate))
* config.py - All configuration options go here
* data_feeders.py - all kind of data handling for training and testing.
* data_feeder_utils.py - Load train/test data from processed pickles
* data_utils.py - Other utilities related to data processing
* generalized_cross_entropy_utils.py - Implementation of a [noise tolerant loss functions](https://arxiv.org/pdf/1805.07836.pdf)
* get_rule_related_statistics.py - For reproducing numbers in Table 1
* hls_data_types.py - some basic data types used in data_feeders.py
* hls_model.py - Creates train ops **All the loss functions are defined here**
* hls_test.py - Runs inference using f or w.
  - Inference on f tests the classification network (valid for all the loss functions)
  - Inference on w is used to analyze the denoised rule-precision obtained by w network
  - Inference on w is only meaningful for ImplyLoss and Posterior Reg. method since only these involve a rule (w) network.
* hls_train.py - Two modes:
  - f_d (simply trains f network on labeled data)
  - f_d_U : used for all other modes which utilize unlabeled data
* learn2reweight_utils.py - utilities for implementing [L2R method](https://arxiv.org/abs/1803.09050)
* main.py - entry point
* metrics_utils.py - utilities for computing metrics
* networks.py - implementation of f network (classification network) and w network (rule network)
* pr_utils.py - utilities for implementing Posterior Reg. method
* run_snorkel.py - training, saving and testing a snorkel model
* snorkel_utils.py - utilitiy to convert l in our format to l in snorkel's format
* test_"DATASET_NAME".sh - model testing (inference) script
  - e.g. test_TREC.sh runs inference for models trained on TREC dataset
* "train_"DATASET_NAME".sh - model training script
  - e.g. train_TREC.sh trains models on TREC dataset
* "DATASET_NAME".sh - test_"DATASET_NAME".sh and train_"DATASET_NAME".sh use "DATASET_NAME".sh
* utils.py - misc. utilities

repository: IndominousRex/Learning-From-Rules

repo_name: IndominousRex/Learning-From-Rules


text:
# Change Log

## [v0.2.6](https://github.com/billtrik/karma-fixture/tree/v0.2.6) (2016-02-13)

**Closed issues:**

- Modifying loaded fixture data permanently modifies fixture data [\#12](https://github.com/billtrik/karma-fixture/issues/12)

[Full Changelog](https://github.com/billtrik/karma-fixture/compare/v0.2.5...v0.2.6)

## [v0.2.5](https://github.com/billtrik/karma-fixture/tree/v0.2.5) (2015-05-26)

**Closed issues:**

- Does not load json objects with escaped characters [\#7](https://github.com/billtrik/karma-fixture/issues/7)

[Full Changelog](https://github.com/billtrik/karma-fixture/compare/v0.2.4...v0.2.5)

## [v0.2.4](https://github.com/billtrik/karma-fixture/tree/v0.2.4) (2015-05-18)

**Closed issues:**

- Don't eval() text in `<script>` if type isn't "text/javascript" or "application/javascript" [\#8](https://github.com/billtrik/karma-fixture/issues/8)

[Full Changelog](https://github.com/billtrik/karma-fixture/compare/v0.2.3...v0.2.4)

## [v0.2.3](https://github.com/billtrik/karma-fixture/tree/v0.2.3) (2015-03-07)

[Full Changelog](https://github.com/billtrik/karma-fixture/compare/v0.2.2...v0.2.3)

**Closed issues:**

- Modify base path? [\#6](https://github.com/billtrik/karma-fixture/issues/6)

- Can't find variable: Fixture [\#1](https://github.com/billtrik/karma-fixture/issues/1)

**Implemented enhancements:**

- Add setter method for base

- Ignore base when searching for fixture, if fixture starts with '/'

- Add fixture's name to the not found error thrown

## [v0.2.2](https://github.com/billtrik/karma-fixture/tree/v0.2.2) (2015-03-01)

[Full Changelog](https://github.com/billtrik/karma-fixture/compare/v0.2.1-1...v0.2.2)

**Closed issues:**

- Throw error when fixture not found? [\#5](https://github.com/billtrik/karma-fixture/issues/5)

- fixture.clear\(\) is really fixture.cleanup\(\) [\#4](https://github.com/billtrik/karma-fixture/issues/4)

**Merged pull requests:**

- Add step to setup in README [\#2](https://github.com/billtrik/karma-fixture/pull/2) ([martiansnoop](https://github.com/martiansnoop))

## [v0.2.1-1](https://github.com/billtrik/karma-fixture/tree/v0.2.1-1) (2014-05-23)

[Full Changelog](https://github.com/billtrik/karma-fixture/compare/v0.2.1...v0.2.1-1)

## [v0.2.1](https://github.com/billtrik/karma-fixture/tree/v0.2.1) (2014-05-23)

[Full Changelog](https://github.com/billtrik/karma-fixture/compare/v0.2.0...v0.2.1)

**Implemented enhancements:**

- Properly empty `fixture.json` array when loading JSON fixture with `append=false`

## [v0.2.0](https://github.com/billtrik/karma-fixture/tree/v0.2.0) (2014-05-23)

[Full Changelog](https://github.com/billtrik/karma-fixture/compare/v0.1.0...v0.2.0)

**Implemented enhancements:**

- Update .load() to return either an array of results or the single result

- Enable Travis  CI for the project

## [v0.1.0](https://github.com/billtrik/karma-fixture/tree/v0.1.0) (2014-05-23)

\* *This Change Log was automatically generated by [github_changelog_generator](https://github.com/skywinder/Github-Changelog-Generator)*

repository: alanozzo/easyerp

repo_name: alanozzo/easyerp


text:
# Bogart Form Warden

## Installation

* Install with npm: `npm install bogart-form-warden`
* Clone from git: `git clone https://github.com/nrstott/bogart-form-warden`

## Usage

This package provies Form Warden JSGI middleware.
Require `bogart-form-warden` for the middleware constructor.
Use it in routes or in `app.use` calls.

Example of using `formWarden` middleware in a route:

    var router = bogart.router();

    var validationOptions = {
      fields: {
        email: [
          {
            isValid: 'required',
            message: 'Email is required'
          },
          {
            isValid: 'email',
            message: 'Email must be a valid email address'
          }
        ]
      }
    };

    router.get('/',

      formWarden(validationOptions).viewEngine(viewEngine),

      function (req) {
        var email = req.params.email;
        return viewEngine.respond('index.html', {
          locals: { email: email }
        });
      }
    );

## Tests

Run the tests with `npm test`.

## Example

* Install dependencies: `npm install`.
* Run the example in the `examples` directory: `node examples/app.js`.

repository: soitgoes/bogart-form-warden

repo_name: soitgoes/bogart-form-warden


text:
---
layout: page
title: Appendix
url: "http://omondiEric.github.io/whereYouArt"
baseurl: "/whereYouArt"

---

## Team
- [Team Contract](/contract.md)

## Project Proposal
- [Project Proposal](/proposal.md)

## Looking to Understand
- [Contextual Inquiry Plan](/contextual.md)
- [Contextual Inquiry Check-In](/contextual1.md)
- [Contextual Inquiry Review](/contextualReview.md)
- [Project Ideation](/sketches.md)
- [Task Review](/taskReview.md)
- [Project Design Check-In](/design-checkin-3-4.md)
- [Project Design Review](/project-design-review.md)
- [User Experience Research Overview](/ux-research-overview.md)

## Understanding to Make
- [Paper Prototype](/paper_prototype/paper-prototype.md)
- [Heuristic Evaluation](/heuristic_eval.md)
- [Usability Testing Check-In](/usability-test/usability-test-checkin.md)
- [Usability Testing Review](/usability-test/usability-test-review.md)
- [Digital Mock-Up](/digital-mockup/digital-mockup.md)
- [User Experience Design Overview](/ux-final-report.md)

repository: omondiEric/whereYouArt

repo_name: omondiEric/whereYouArt


text:
# RUM - RUM access method

## Introduction

The **rum** module provides access method to work with RUM index. It is based
on the GIN access methods code.

## License

This module available under the same license as
[PostgreSQL](http://www.postgresql.org/about/licence/).

## Installation

Before build and install **rum** you should ensure following:

* PostgreSQL version is 9.6.

Typical installation procedure may look like this:

    $ git clone https://github.com/postgrespro/rum
    $ cd rum
    $ make USE_PGXS=1
    $ sudo make USE_PGXS=1 install
    $ make USE_PGXS=1 installcheck
    $ psql DB -c "CREATE EXTENSION rum;"

## New access method and operator class

The **rum** module provides the access method **rum** and the operator class
**rum_tsvector_ops**.

The module provides new operators.

|       Operator       | Returns |                 Description
| -------------------- | ------- | ----------------------------------------------
| tsvector <=> tsquery | float4  | Returns distance between tsvector and tsquery.

## Examples

Let us assume we have the table:

```sql
CREATE TABLE test_rum(t text, a tsvector);

CREATE TRIGGER tsvectorupdate
BEFORE UPDATE OR INSERT ON test_rum
FOR EACH ROW EXECUTE PROCEDURE tsvector_update_trigger('a', 'pg_catalog.english', 't');

INSERT INTO test_rum(t) VALUES ('The situation is most beautiful');
INSERT INTO test_rum(t) VALUES ('It is a beautiful');
INSERT INTO test_rum(t) VALUES ('It looks like a beautiful place');
```

To create the **rum** index we need create an extension:

```sql
CREATE EXTENSION rum;
```

Then we can create new index:

```sql
CREATE INDEX rumidx ON test_rum USING rum (a rum_tsvector_ops);
```

And we can execute the following queries:

```sql
=# SELECT t, a <=> to_tsquery('english', 'beautiful | place') AS rank
	FROM test_rum
	WHERE a @@ to_tsquery('english', 'beautiful | place')
	ORDER BY a <=> to_tsquery('english', 'beautiful | place');
                t                |   rank
---------------------------------+-----------
 The situation is most beautiful | 0.0303964
 It is a beautiful               | 0.0303964
 It looks like a beautiful place | 0.0607927
(3 rows)

=# SELECT t, a <=> to_tsquery('english', 'place | situation') AS rank
	FROM test_rum
	WHERE a @@ to_tsquery('english', 'place | situation')
	ORDER BY a <=> to_tsquery('english', 'place | situation');
                t                |   rank
---------------------------------+-----------
 The situation is most beautiful | 0.0303964
 It looks like a beautiful place | 0.0303964
(2 rows)
```

## Authors

Alexander Korotkov<EMAIL_ADDRESS>Postgres Professional Ltd., Russia

Oleg Bartunov<EMAIL_ADDRESS>Postgres Professional Ltd., Russia

Teodor Sigaev<EMAIL_ADDRESS>Postgres Professional Ltd., Russia

license: PostgreSQL

repository: nwaycn/rum

repo_name: nwaycn/rum


text:
---
layout: post
title: Black Beer
tags: [brewlog, beer, black, dry-hopped, motueka-hops]
image:
  - url: /images/labels/2012-03-Black.jpg
    title: Bottle Label
---

Recently the weather has taken a turn for the worse, although to be fair it
never really got going over summer with lots of [grey
days](http://www.stuff.co.nz/national/6525665/Grey-summer-breaks-records).
This has got me thinking forward to the winter months when having a big black
beer in the fridge is never a bad thing.  Time for a new brew, so off to the
brew shop for a few supplies.  I didn't really know what I was after but came
away with a couple of cans:

{:.image-right-50}
![Label](/images/labels/2012-03-Black.jpg)

- [Mangrove Jack's Irish Stout](http://mangrovejacks.com/products/international-series-irish-stout)
- [Black Rock Dark Malt Extract](http://www.brewshop.co.nz/black-rock-dark-malt-extract.html)

Hopefully this combo isn't too bitter, I hope the extra malt extract adds
something to the body of the beer and leaves the bitterness up to the hops
from the Stout.  Since I have some hops in the freezer I decided to try a hint
of dry hopping too by adding 40g of [Motueka
hops](http://www.nzhops.co.nz/variety/motueka).  I know this goes against the
normal thinking of black beers, but that is the beauty of homebrew, I get to
make the rules.

This brew has been in the drum for about a week now starting out with an SG of
1036.  It is now down to about 1010 and the bubbling has almost stopped, so I
expect it will have an FG of around 1006 when ready for bottling.  This should
give an alcohol content of about 4.0% once the priming sugar is added.


text:
---
title: Monthly Review - July 2020
date: 2020-08-01 10:01:00 +01:00
categories:
- Monthly-Review
tags:
- monthly-review
- 3ds
- gaming
- netflix
- witcher
- podcasts
author: jamesleighton
Status: published
layout: post
image: "/images/switch-in-dock.jpg"
---

### I've been listening to

Folklore by Taylor Swift

[Hello Internet](https://www.hellointernet.fm/) from Episode 1

### I've been reading

[Sword of Destiny](https://en.wikipedia.org/wiki/Sword_of_Destiny) by Andrzej Sapkowski and [Humble Pi](https://www.goodreads.com/book/show/39074550-humble-pi) by Matt Parker (Audio Book)

### I've been watching

The Politician on Netflix, Cursed on Netflix

### I've been playing

Fantasy Life on 3DS, Digimon Cyber Sleuth on Vita


text:
---
title: The Weight of Words
category: archive
layout: post
tags:
- words
- writing
- ideas
- communication
---

Words are ideas. And ideas are most useful when they can be easily transferred to others.

It’s not easy to absorb new ideas. It not only requires an open receiving mind, but also the right articulation of the idea.

So how you communicate ideas is pretty important. That’s why short & crisp is usually best.

And this extends beyond just communicating ideas to all communication. Words have a weight to them. The more of them there are, the harder to parse through them.

Take these 2 sentences below —

* I work in product in enterprise saas.
* I am a product management executive working on next generation technologies for modern businesses.

While they say the same thing, one has more words. The words add color, but they make the sentence harder to understand. The sentence feels heavier, harder to carry in your mind all at once.

The best expressed ideas let you try them on, walk around in it, and really feel it out. The worst ones are just words that don’t let you try the idea out at all.

So make sure that all comms are as simple as possible. Less words is almost always better. Nouns & verbs. Everything else is cruft that obfuscates your ideas.

repository: ChrisEYin/sustain

repo_name: ChrisEYin/sustain


text:
---
layout: case
permalink: /case-study/report-card
keyword: case
title: National Report Card
section1-title: The Challenge
section1-para1: A national agency created-program to evaluate the education progress of elementary, middle, and high school students across the nation in key learning areas. This site is essentially a web application where users are asked to report data on students and their performance at different intervals over an academic year.
section1-para2: Why and where are users struggling with the tasks on this site?
section1-para3: How do I help them be successful?
section2-title: My Process
section2-img: /img/reportcard/reportcard-flowchart.svg
section2-img-alt: Flow chart of my process
section2-para:
section3-title: User Journey Maps
section3-img: /img/reportcard/reportcard-UJM-1.jpg
section3-img-alt: Example of user journey map
section3-para1: I created user journey maps in order to have a clear left-to-right view of their engagement arc with the web app. User touchpoints with the site were spread throughout an academic year and fluctuated between sporadic and frequent. These assets were particularly beneficial because they were a touchpoint as we developed the content strategy and UX for each phase of the journey.
section3-h3: Key User Concerns
section3-para2: Lack of familiarity with the site. Few repeat users from year to year.
section3-para3: Tech insecurity. Users, already experiencing insecurity around technology, were frustrated and confused.
section4-title: Annotated Wireframes
section4-img1: /img/reportcard/reportcard-wire-1.gif
section4-img1-alt: Wireframe for Site Orientation
section4-img2: /img/reportcard/reportcard-wire-2.gif
section4-img2-alt: Wireframe for Prior to Assessment landing
section4-img3: /img/reportcard/reportcard-wire-3.gif
section4-img3-alt: Wireframe for Prior to Assessment video
section4-img4: /img/reportcard/reportcard-wire-4.gif
section4-img4-alt: Wireframe for Prior to Assessment, Update Student List
section4-img5: /img/reportcard/reportcard-wire-5.gif
section4-img5-alt: Wireframe for Prior to Assessment, Add New or Missing Students
section4-img6: /img/reportcard/reportcard-wire-6.gif
section4-img6-alt: Wireframe for Prior to Assessment, Match Students
section4-img7: /img/reportcard/reportcard-wire-7.gif
section4-img7-alt: Wireframe for Representative Workflow
section4-para: I chose to provide a set of medium-fidelity wireframes that include examples of tone and voice, recommended content length, a color language, annotations, and other design elements. Please note, the copy, colors, and typography are not final or part of a branding or content strategy; they are meant to be examples that are inline with our recommendations.
blockquote: I provided the team that administrates the site a robust documentation set (see below) that included three key UX areas to target —task wayfinding, content strategy, and contextual help—and a road map for implementation. Additionally, I provided a set of design patterns such as form workflows, navigation best practices, reward language, and many others for them to implement through out their properties and collateral.
section5-title: Recommendations & Final Documentation
section5-img1: /img/reportcard/reportcard-rec-1.gif
section5-img1-alt: UX Audit & Recommendations, table of contents
section5-img2: /img/reportcard/reportcard-rec-2.gif
section5-img2-alt: UX Audit & Recommendations, task wayfinding, implementation
section5-img3: /img/reportcard/reportcard-rec-3.gif
section5-img3-alt: UX Audit & Recommendations, task wayfinding, areas to consider
section5-para1: I provided 40+ pages of documentation with examples, best practices, roadmaps, implementation guidelines, design patterns, 508 compliance and accessibility recommendations, and many additional avenues to consider alongside a helpful asset set of formalized wireframes, content strategy, user journey maps, interview recordings (audio and visual), brand strategy, and short-term UI workflows and comps.
next: /project/cancer-trials

---

repository: agentbetty/innerstate

repo_name: agentbetty/innerstate


text:
# EMSFormBundle
Generate forms based on ElasticMS content configuration

## Coding standards
PHP Code Sniffer is available via composer, the standard used is defined in phpcs.xml.diff:
````bash
composer phpcs
````

If your code is not compliant, you could try fixing it automatically:
````bash
composer phpcbf
````

PHPStan is run at level 7, you can check for errors locally using:
`````bash
composer phpstan
`````

PHP Mess Detector can generate a report in ./phpmd.html, rule violations are ignored by Travis for now.
````bash
composer phpmd
composer phpmd-win
````

Use phpmd-win when working on Windows!

## Build frontend resources
`````bash
npm install
npm run build
`````

In development stage
`````bash
npm run start
`````

## Documentation

* [Installation](../master/Resources/doc/install.md)
* [Configuration](../master/Resources/doc/config.md)
* [How to implement?](../master/Resources/doc/example.md)
* [Handle Submitted data](../master/Resources/doc/handlers.md)
* [Supported fields](../master/Resources/doc/fields.md)
* [Supported validations](../master/Resources/doc/validations.md)

repository: dameert/EMSFormBundle

gha_language: PHP

repo_name: dameert/EMSFormBundle


text:
# DetectionIoTools

[![Build Status](https://github.com/baggepinnen/DetectionIoTools.jl/workflows/CI/badge.svg)](https://github.com/baggepinnen/DetectionIoTools.jl/actions)
[![Coverage](https://codecov.io/gh/baggepinnen/DetectionIoTools.jl/branch/master/graph/badge.svg)](https://codecov.io/gh/baggepinnen/DetectionIoTools.jl)

Contains some utilities for reading and saving files when solving detection problems. Most functionality previously existed in [AudioClustering.jl](https://github.com/baggepinnen/AudioClustering.jl) but have been factored out into a lighter dependency.

- `mapsoundfiles`
- `thing2file`
- `wavplay`
- `save_interesting`

gha_language: Julia


text:
While Raku regex and tokens are meant to work on data structures (such as parsing and validating file types), they can help us to better understand malware. Malware, as any other legit binary, have some signatures within. Some “file signatures” are widely used to blacklist those specific samples (the hashes), but the problem is that blacklisting hashes is not safe enough. Sometimes, the very same kind of malware could be slightly different in small details, and have many different samples related. In this case, apart from relying on dynamic detection (monitoring devices and alerting the user when something seems to be acting suspiciously), genes are also investigated.

Malware genes are pieces of the reversed code (such as strings) that are commonly seen in most or all the samples of a malware family. This sort of genes help researchers identify the malware family and contextualize the attacks , since this is relevant not only to try to put an end to the threat by executing the proper counterfeits in time, but also helps profiling and framing threat actors in some cases.

Generally, these genes are also useful to look for malware families among a unknown group of samples. A common tool for this is “YARA”.  YARA is a tool used by researchers to create some rules and basic logic to try to find genes across samples. The structure of how YARA works can also be approached using Raku grammars, providing an alternative that might be useful when the YARA logic is not enough for the regex rules in specific cases. In order to test this idea, I created “CuBu” (curious butterfly), a tool similar to YARA which takes advantage of Raku elements to look for malware genes. For testing out the tool I designed a script to look for Sparkling Goblin genes. Sparkling Goblin is an APT (advanced persistent threat) that I happened to investigate a few months ago. While working on a YARA rule, I found out the following gene was commonly seen in some of their malware:

```
InterfaceSpeedTester9Calc
```

So I created a token in Raku using that gene:

```
my token gen1 {'InterfaceSpeedTester9Calc'}
```

Now created a regex with it:

```
my regex sparkling_goblin {<gen1>}
```

And parsed a file line by line trying to look for the gene:

```
my $c = 1;
    for "$fo/$fi".IO.lines -> $line {
        # If the line contains the gene, print it
         if $line ~~ &sparkling_goblin {say "Sparkling Goblin found: "; say $line; say "in line $c"; say "in file $fi"; say " "; }
         #if $line ~~ &sparkling2 {say "Sparkling Goblin complex regex found: "; say $line; say "in line $c"; say " "; }

         $c++;
    }
```

In the code above, the file is parsed in a given folder ($fo) and file ($fi) and when the gene is found it prints the name of the file and the line. In this case there are too many steps for a single gene, but let’s check then using another regex from different tokens. Let’s say we also want to check for gene:

```
ScheduledCtrl9UpdateJobERK
```

So in this case we can create another token:

```
my token gen2 {'ScheduledCtrl9UpdateJobERK'}
```

And change the regex so it checks for one or the other:

```
my regex sparkling2 {
    [
       <gen1>|<gen2>
    ]
    }
```

And we can keep going with yet another gene:

```
my token gen3 {'ScanHardwareInfoPSt'}
```

And add it in the regex:

```
my regex sparkling2 {
    [
       <gen1>|<gen2>|<gen3>
    ]
    }
```

Now let’s say that the first gene is only suspicious when seen in the end of a line, but the second and third genes are suspicious always. We then should use the regex `<gen1>$`  included in our logic.

```
my regex sparkling2 {
    [
       <gen1>$|<gen2>|<gen3>
    ]
    }
```

This is becoming interesting and more specific. If we wanted to check for a line which ends with the first gene, or starts with the second gene we would do:

```
my regex sparkling2 {
    [
       <gen1>$|^<gen2>
    ]
    }
```

And if we want to look for a line which is specifically the third gene without anything else or any of the other genes inside the strings:

```
my regex sparkling2 {
    [
       <gen1>|<gen2>|^<gen3>$
    ]
    }
```

And so on. Once you know your malware you can create more and more refined regex to work with them. You can create more than one regex to look for different specific things. This is how the whole code for the last option would look like:

```
sub MAIN (Str :$fi = '', Str :$fo = '') {
    # some genes in the binary

    my token gen1 {'InterfaceSpeedTester9Calc'}
    my token gen2 {'ScheduledCtrl9UpdateJobERK'}
    my token gen3 {'ScanHardwareInfoPSt'}

    my regex sparkling2 {
        [
           <gen1>|<gen2>|^<gen3>$
        ]
     }

    my $c = 1;
    for "$fo/$fi".IO.lines -> $line {
        if $line ~~ &sparkling2 {say "Sparkling Goblin complex regex found: "; say $line; say "in line $c"; say "in file $fi"; say " "; }

    $c++;
  }
}
```

In my tool, CuBu, I used this raku (compiled with rakudo) inside a bash script using Zenity for a simple user friendly GUI that asks for the folder and the raku script and creates a CSV and a raw file with the results. It iterates every single file of the folder:

```
#!/bin/sh

zenity --forms --title="New analysis" \
	--text="Enter configuration:" \
	--separator="," \
	--add-entry="Folder" \
	--add-entry="Threat name" >> threat.csv

case $? in
    0)
        echo "Configuration set"
	name=$(csvtool col 2-2 threat.csv)
	mv threat.csv* "$name.csv"

	folder2=$(csvtool col 1-1 $name.csv)
	;;
    1)
        echo "Nothing configured."
	;;
    -1)
        echo "An unexpected error has occurred."
	;;
esac

zenity --question \
--text="You are going to check samples in folder $folder2 in order to look for $name. Is that okay?"
if [ $? ]; then
	echo "Starting analysis: "

touch results_$name

	for i in "$folder2"/*; do
		rakudo $name.raku --fi="$i" --fo=. >> results_$name
	done

	zenity --info \
	--text="Info saved in results_$name"
else
	echo "okay! bye!"
fi

```

repository: Raku/advent

gha_language: Raku

repo_name: Raku/advent


text:
# TrackKit

## 2.4.0

- Added support for a custom `.track` format.

## 2.3.2

- Update AEXML.

## 2.3.1

- Added support for Swift 4.

## 2.3.0

- Added `NMEA` file support. _Currently supported identifiers are GPGGA, GPGLL, GPRMC & GPWPL._

## 2.2.0

- Added full support for `GPX`'s `TrackPointExtensions`.

## 2.1.0

- Added `LOG` file support.
- Added `GPX` file version v1.0 support.
- Extended the documentation.

## Version 2.0.1

- Fix the `Trackpoint` parsing.
- Add the `TrackType` property to the `File`.

## Version 2.0.0

- Cleanup the code.
- Added `TCX` file support.
- Extended the documentation.

## Version 1.2.0

- Rename `GPXKit` to `TrackKit` because we want to be able to support multiple formats.
- Update the code to be Swift 3.0 compatible.

## Version 1.1.0

- Remove the empty parse error notice.
- Remove the `GK` prefix for all the classes.
- The license property in the copyright notice is now in the correct `NSURL` format.
- Add the magnetic variant property to a point.
- Add the fix property to a point.
- Add the dgps station type to point.
- Throw an error when an incorrect GPX version is loaded. Only version **1.1** is supported by `GPXKit`.
- Update AEXML to version **3.0**.

## Version 1.0.2

* Cleanup the code.
* Removed the `AFDateHelper` dependency.
* Became a Swift package. _PR request sent in order to add AEXML as a package._
* Add support for OS X, Apple Tv and WatchOS 2.0.
* Fully test the application.

## Version 1.0.1

* Cleanup the README.
* Add inline documentation.

## Version 1.0.0

* Parses a GPX file into a readable format with Swift.
* An example project with spec that cover 100% of the framework.

repository: mathieutozer/trackkit

repo_name: mathieutozer/trackkit