text:
# SwaggerJsClient.AdditionalInformation

## Properties
Name | Type | Description | Notes
------------ | ------------- | ------------- | -------------
**id** | **String** | DTO ID in UUID form |
**type** | **String** | Discriminator for subtypes. At the moment only `Category` and `Contractor` are supported. |

repository: quackes/sents

repo_name: quackes/sents


text:
>"For over a thousand generations the Jedi Knights were the guardians of peace and justice in the Old Republic. Before the dark times, before the Empire." -- Obi-Wan Kenoby

Cerberus
========

Cerberus is a Rack middleware for form-based authentication. Its purpose is only
to offer a nicer (or more actual) replacement for Basic HTTP authentication.

Install with:

    # sudo gem install rack-cerberus

You can use it almost the same way you use `Rack::Auth::Basic`:

    require 'cerberus'
    use Rack::Session::Cookie, :secret => 'change_me'
    use Cerberus do |login, pass|
      pass=='secret'
    end

Like in that example, make sure you have a session, because Cerberus use it for
persistent login.

There is an optional hash you can add for customisation it. Options are:

- `:company_name`
- `:fg_color` (foreground color)
- `:bg_color` (background color)
- `:text_color`
- `:icon_url` (for a company logo or any icon)
- `:css_location`

Which is used that way:

    use Cerberus, {:company_name => 'Nintendo'} do |login, pass|
      pass=='secret'
    end

The purpose of Cerberus is to be basic, which is why there are enough options to have
a page fairly customized with colors and logo (`:icon_url`). The logo can even replace
the company name if you leave `:company_name` blank. But should you be fussy, this is possible
to have more control using an external CSS file with the option `:css_location`.

Just like `Rack::Auth::Basic`, Cerberus yields login and pass, and delegate authentication
to the block you send it which should return a boolean.

If you want to see a concrete example, go into the Cerberus directory and run:

    # rackup example.ru

It's gonna start the example at http://localhost:9292

You can also use the 3rd argument which is the request object:

use Cerberus, {:company_name => 'Nintendo'} do |login, pass, req|
  pass=='secret' && req.xhr?
end

This is more if you use it as a gateway for an API or something and you want to check other values.
Like the referer or another parameter.
But bear in mind that `cerberus_login` and `cerberus_pass` are still mandatory.

Logout
------

Any request to `/logout` on the path where the middleware is mounted will log you out.
In other words, if you put the middleware at `/admin`, query `/admin/logout` to be
logged out. Pretty simple.

Help
----

If you want to help me, don't hesitate to fork that project on Github or send patches.

Changelog
---------

	0.0.1 Changed Everything somehow
	0.1.0 Make it possible to authenticate through GET request (for restful APIs)
	0.1.1 Documentation improvement
	0.1.2 Raise message when using without session
	0.1.3 Don't go to page /logout when signing in after a logout (redirect to / instead)
	0.1.4 Fix /logout redirect so that it works with mapping
	0.1.5 Fix CSS and Javascript for IE (Yes I'm too kind)
	0.1.6 Send an Array instead of a string to Rack so that it works on Ruby 1.9
	0.2.0 External CSS file + `:text_color` option + keep details after login failure
	0.3.0 Now sends request as a 3rd argument to the block
	0.3.1 Escape HTML in fields now that they are kept

Copyright
---------

(c) 2010-2011 Mickael Riga - see MIT_LICENCE for details

license: MIT

repository: yortz/cerberus

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: yortz/cerberus


text:
# lannuaire

![icon for license](https://camo.githubusercontent.com/3ccf4c50a1576b0dd30b286717451fa56b783512/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f4c6963656e73652d4d49542d79656c6c6f772e737667)

# Table of contents
1. [Description](#Description)
2. [Installation instructions](#Installation-instructions)
3. [Usage](#usage)
4. [Contributions](#Contributions)
5. [Testing instructions](#Testing-instructions)
6. [License](#License)
7. [Questions](#Questions)

## Description:
This is a website for viewing non-sensitive information about employees and coworkers. The user can alphebetize their list and/or filter by country.

This application is deployed  here.

The user is greeted with the following screen:
![welcome screen](./images/mainList.JPG)

The user can alphebatize and/or filter by country:
The user is greeted with the following screen:
![filter alpha](./images/usa_alpha.JPG)

## Installation instructions:
Users should run npm install to install the dependencies before running locally.

## Usage:
This is catered towards managers of international companies.

## Contributions:
This is currently a solo project of skolnikskolnik.

## Testing instructions:
Try alphebetizing your lists to verify the functionality works.

## License:
This project is covered under the MIT License license.

## Questions
Visit my github page.

Email me at<EMAIL_ADDRESS>with any additional questions you may have. I am always happy to talk to users of my product!

repository: skolnikskolnik/lannuaire

branch_name: refs/heads/main

repo_name: skolnikskolnik/lannuaire


text:
---
title: "Reading Note: ThiNet: A Filter Level Pruning Method for Deep Neural Network Compression"
category: ["Computer Vision"]
tag: ["Reading Note", "CNN", "Compression"]
---

**TITLE**: ThiNet: A Filter Level Pruning Method for Deep Neural Network Compression

**AUTHOR**: Jian-Hao Luo, Jianxin Wu, Weiyao Lin

**ASSOCIATION**: Nanjing University, Shanghai Jiao Tong University

**FROM**: [arXiv:1707.06342](https://arxiv.org/abs/1707.06342)

## CONTRIBUTIONS ##

1. A simple yet effective framework, namely ThiNet, is proposed to simultaneously accelerate and compress CNN models.
2. Filter pruning is formally established as an optimization problem, and statistics information computed from its next layer is used to prune filters.

## METHOD ##

### Framework ###

The framework of ThiNet compression procedure is illustrated in the following figure. The yellow dotted boxes are the weak channels and their corresponding filgers that would be pruned.

![Framework](https://raw.githubusercontent.com/joshua19881228/my_blogs/master/Computer_Vision/Reading_Note/figures/Reading_Note_20170803_ThiNet_0.png "Framework"){: .center-image .image-width-640}

1. **Filter selection.** The output of layer $ i + 1 $ is used to guide the pruning in layer $ i $. The key idea is: if a subset of channels in layer $ (i + 1) $’s input can approximate the output in layer $ i + 1 $, the other channels can be safely removed from the input of layer $ i + 1 $. Note that one channel in layer $ (i + 1) $’s input is produced by one filter in layer $i$, hence the corresponding filter in layer $i$ can be safely pruned.
2. **Pruning.** Weak channels in layer $(i + 1)$’s input and their corresponding filters in layer i would be pruned away, leading to a much smaller model. Note that, the pruned network has exactly the same structure but with fewer filters and channels.
3. **Fine-tuning.** Fine-tuning is a necessary step to recover the generalization ability damaged by filter pruning. For time-saving considerations, fine-tune one or two epochs after the pruning of one layer. In order to get an accurate model, more additional epochs would be carried out when all layers have been pruned.
4. **Iterate to step 1 to prune the next layer.**

### Data-driven channel selection ###

Denote the convolution process in layer $i$ as A triplet $$ \left \langle \mathscr{I}_{i}, \mathscr{W}_{i}, * \right \rangle $$, where $$ \mathscr{I}_{i} $$ is the input tensor, which has $$ C $$ channels, $$ H $$ rows and $$ W $$ columns. And $$ \mathscr{W}_{i} $$ is a set of filters with $$ K \times K $$ kernel size, which generates a new tensor with $$ D $$ channels. Note that, if a filter in $$ \mathscr{W}_{i} $$ is removed, its corresponding channel in $$ \mathscr{I}_{i+1} $$ and $$ \mathscr{W}_{i+1} $$ would also be discarded. However, since the filter number in layer $$ i + 1 $$ has not been changed, the size of its output tensor, i.e., $$ \mathscr{I}_{i+2} $$, would be kept exactly the same. If we can remove several filters that has little influence on $$ \mathscr{I}_{i+2} $$ (which is also the output of layer $$i + 1$$), it would have little influence on the overall performance too.

### Collecting training examples ###

The training set is randomly sampled from the tensor $$ \mathscr{I}_{i+2} $$ as illustrated in the following figure.

![Sampling](https://raw.githubusercontent.com/joshua19881228/my_blogs/master/Computer_Vision/Reading_Note/figures/Reading_Note_20170803_ThiNet_1.png "Sampling"){: .center-image .image-width-480}

The convolution operation can be formalized in a simple way

$$ \hat{y} = \sum_{c=1}^{C} \hat{x}_{c} $$

### A greedy algorithm for channel selection ###

Given a set of $$m$$ training examples $$ \left\{ (\mathrm{\hat{x}}_{i}, \hat{y}_{i}) \right\} $$, selecting channel can be seen as a optimization problem,

![Objective](https://raw.githubusercontent.com/joshua19881228/my_blogs/master/Computer_Vision/Reading_Note/figures/Reading_Note_20170803_ThiNet_2.png "Objective"){: .center-image .image-width-480}

and it eauivalently can be the following alternative objective,

![Objective](https://raw.githubusercontent.com/joshua19881228/my_blogs/master/Computer_Vision/Reading_Note/figures/Reading_Note_20170803_ThiNet_3.png "Objective"){: .center-image .image-width-480}

where $$ S \cup T = \left\{ 1,2,...,C \right\} $$ and $$ S \cap T = \emptyset $$. This problem can be sovled by greedy algorithm.

### Minimize the reconstruction error ###

After the subset $$T$$ is obtained, a scaling factor for each filter weights is learned to minimize the reconstruction error.

## Some Ideas ##

1. Maybe the finetue can help avoid the final step of minimizing the reconstruction error.
2. If we use this work on non-classification task, such as detection and segmentation, the performance remains to be checked.


text:
# HungryGator
An aggregator of restaurant data.

This is a course-work project.

This project aims to aggregate restaurant data from different online platforms to educate the customer which platform they should trust w.r.t different restaurants.

# Please run the below command to install the Python packages for the project:

pip3 install -r stable-req.txt

# Follow below instructions if you run into the below issues:

# 1.ImportError: No module named wordcloud

We are using WordCloud for producing WordCloud on the restaurants.
You might face issues when trying to import wordcloud in Anaconda.

 Follow the below steps to get it resolved:

   i.This most likely happens because in spite of having wordcloud in the local python environment, it is not available to the Anaconda package.

   ii.Try installing the wordcloud package using the Anaconda terminal.

       If you are using MAC, you might have to change the default shell to bash in order for the Anaconda Shell to run as the shell is available to bash only.

       Use: chsh -s /bin/bash to change the shell from zsh to bash.

       Use: chsh -s /bin/zsh to revert back to zsh later.

   iii.Once the shell has been changed run the below command on the Anaconda shell to install wordcloud.

       ## conda install -c conda-forge wordcloud

   iv.After this ideally the wordcloud import statements should work.

# This can be followed for most imports, if they are not working with normal pip installation.

The conda commands for installing the packages using conda terminal can be found in :

https://conda.io/docs/user-guide/tasks/manage-pkgs.html

# Results of Our Aggregation:

Below is a sample results of our analysis of data from the two major restaurant data sites - Zomato and Yelp

![publish message](https://raw.githubusercontent.com/imjuoy/Hungrygator/master/pictures_for_readme/Rating_Comparisons.png)

Below is a word cloud description generated using restaurant reviews from a user entered ZIPCODE.

![publish message](https://raw.githubusercontent.com/imjuoy/Hungrygator/master/pictures_for_readme/WordCloud_Based_On_Zip_Code1.gif)

# You can check the source code for more interesting insights.

repository: imjuoy/HungryGator

repo_name: imjuoy/HungryGator


text:
---
title: Ritual
---

> I fear not the man who has practiced 10,000 kicks once, but I fear the man who has practiced one kick 10,000 times. -  Bruce Lee

The second stage of [[tuna-operating-system]] where I follow my intuition to form rituals that I perform everyday. Rituals are habits that follow other habits that allow you to focus on what actually matters. Rituals are particularly good for habit formation because they already provide a cue for your new habit, a previous habit.

![](./images/habit-loop.png)

> Craft your day to [[build-the-life-you-want-to-live-then-save]]. Maximize the stuff you want to do and minimize the stuff you do not.

# Morning Reflection Ritual
1. **Reflect** on yesterday
    1. Did I accomplish my goal?
    2. What were my blockers?
    3. What were my learnings?
    4. Do I need to spin out new tasks and goals?
2. **Plan** for today
    1. Keystone Habits
    2. Mandatory Meetings, Tasks, chores
    3. Social Events (Rena > Friends > Solo)
    4. Initial thoughts on Personal Project Plans
3. **Inspiration** Writeups

# Creation Cycle
The cycle for creation falls into 3 stages that roughly align with where my energy levels fall with during a full day.

Mornings are for design. I'll sketch some ideas. I'll outline some thoughts and tenets. I'll design software.
Afternoons are for execution. Then I'll ink. Then I'll write dialogue. Then I'll code.
Evenings are for inspiration. Then I'll play games, watch anime and read.

Each stage informs the next.
In the morning if I don't know what to design I wasn't taking in enough during inspiration.
In the afternoon if there's nothing to ink, write or code then I didn't sufficiently design.
In the evening if there's nothing I feel I need to learn the I didn't push enough boundaries during execution.

During each stage there is an intuitive sense of what I want to do. [[trust-your-feelings]] and follow my inspiration to do what I want to do. What inspires, energizes and motivates me.

## Design
Coding is your the topic of [[the-journey-of-the-craftsman]] for your life. Always devote time to coding. Deep work says to find large chunks of time in the morning to work.

I want ideate. I want an atelier. To create. Create sketches. Projects I want to make. Stories I want to write. Write thoughts into my notion. Draw some sketches about poisonous swamps. Flying through the sky. Write about being human. Then create my compositions for the world to see. Sketches about warriors. Then compile these into actionable tasks to chip away at during the afternoon.

## Execution
More Manual Labor things. Rule of thumb is I should be able to zone out with a mild stream running in the background and still be able to do it.

## Inspire
[[input-begets-output]]

This marks the end of my disciplined time and my brain is usually fried. Afterwords, I'm free to do what I want and what my body requires. I won't be hard on myself for not being productive during this time period. But I do want to be inspired. To experience life. Observe its beauty. Shortcomings. Read the Ghibli book. Watch Nausica. Play Zelda. Embrace the sunset. Socialize. Play games with my friends. Relax. Take in the sun. Enjoy the seasons. Enjoy Rena. Enjoy the weekend.

# Start Small with New Rituals
> We rise to the level of our ambitions, and we fall to the level of our systems.

- fitness: K Boges recommends high volume and daily training because it takes less time for each session and there's lower perceived effort (2 sets of pullups per day or 5 sets 2 days a week). If you don't actually do the workout then it doesn't matter. It also has less fatigue and soreness associated with it.

repository: tunaphish/blog

repo_name: tunaphish/blog


text:
This folder contains all tests which relies on external service such as TiDB.

## Preprations

1. The following three executables must be copied or linked into these locations:

   - `bin/pd-server`
   - `bin/tikv-server`
   - `bin/tidb-server`
   - `bin/binlogctl`
   - `bin/sync_diff_inspector`

2. The following programs must be installed:

   - `mysql`(the CLI client)
   - `kafka`  working on default port 9092

3. The user executing the tests must have permission to create the folder

   `/tmp/tidb_binlog_test/pump`. All test artifacts will be written into this folder.

## Running

Run `make integration_test` to execute the integration tests. This command will

1. Check that all executables exist.
2. Build `pump` and `drainer`
3. Execute `tests/run.sh`

If the first two steps are done before, you could also run `tests/run.sh directly.

The scrip will

1. Start PD, TiKV, TiDB, Pump, Drainer in backgroud

2. Find out all `tests/*/run.sh` and run it.

   Run `tests/run.sh --debug` to pause immediately after all servers are started.

## Writing new tests

New integration tests can be written as shell script in `tests/TEST_NAME/run.sh`.

The script should exit with a nonzero error code on failure.

Serveral convenient commands are provided:

- `run_drainer`  Starts `drainer` using tests/TEST_NAME/drainer.toml (notice it may continue at the checkpoint from the last test case)
- `run_sql <SQL>` Executes an SQL query on the TiDB database(port 4000)
- `down_run_sql <SQL>` Executes an SQL query on the downstream TiDB database(port 3306)

- `check_contains <TEXT>` — Checks if the previous `run_sql` result contains the given text
  (in `-E` format)
- `check_not_contains <TEXT>` — Checks if the previous `run_sql` result does not contain the given
  text (in `-E` format)
- `check_status <NODE_TYPE> <NODE_ID> <STATUS>` — Checks if the node's status is STATUS, if NODE_TYPE is 'drainer', don't need set the NODE_ID
- `check_data <CONFIG_FILE>` - Checks data between TiDB and downstream by sync_diff_inspector, this tool can download from [tidb-enterprise-tools-latest-linux-amd64.tar.gz](https://download.pingcap.org/tidb-enterprise-tools-latest-linux-amd64.tar.gz)

repository: pingcap/tidb-binlog

gha_language: Go

repo_name: pingcap/tidb-binlog


text:
# Mendeleev

## CLI Commands

```bash
# install dependencies
yarn

# serve with hot reload at localhost:8080
yarn dev

# build for production with minification
yarn build

# test the production build locally
yarn serve

# test the production build locally
yarn lint

# run tests with jest and enzyme
yarn test
```

repository: ravecat/mendeleev

gha_language: JavaScript

gha_license_id: MIT

repo_name: ravecat/mendeleev


text:
### Zillow Scraper

Zillow Scraper is an [Apify actor](https://apify.com/actors) for extracting data about homes from [Zillow.com](https://zillow.com). It allows you to search homes in any location and extract detailed information about each one. It is build on top of [Apify SDK](https://sdk.apify.com/) and you can run it both on [Apify platform](https://my.apify.com) and locally.

The way it works is by accesing Zillow's internal API and recursively splitting the map 4 ways to overcome the limit of 500 results per search. To limit the number of outputted results, you can set the maximum depth of the 4-way split zooms. This is done using the `maxLevel` attribute.

- [Input](#input)
- [Output](#output)
- [Map splitting](#map-splitting)
- [Compute units consumption](#compute-units-consumption)
- [Extend output function](#extend-output-function)

### Input

| Field | Type | Description | Default value
| ----- | ---- | ----------- | -------------|
| search | string | Query string to be searched on the site | `"Los Angeles"` |
| startUrls | array | List of [Request](https://sdk.apify.com/docs/api/request#docsNav) objects that will be deeply crawled. The URL can be any Zillow.com home list page | none |
| maxItems | number | Maximum number of pages that will be scraped | `200` |
| maxLevel | number | Maximum map splitting level | `20` |
| minDate | string | Minimum date of the results allowed (timestamp or date string) | none |
| simple | boolean | Toggle whether simplified results will be returned | `true` |
| extendOutputFunction | string | Function that takes Zillow home data object as argument and returns data that will be merged with the default output. More information in [Extend output function](#extend-output-function) | `(data) => { return {}; }` |
| proxyConfiguration | object | Proxy settings of the run. If you have access to Apify proxy, leave the default settings. If not, you can set `{ "useApifyProxy": false" }` to disable proxy usage | `{ "useApifyProxy": true }`|

Either the `search` or `startUrls` atrribute has to be set.

### Output

Output is stored in a dataset. Each item is information about a home.
If the `simple` attribute is set, an example result may look like this:
```
{
  "address": {
    "streetAddress": "312 N Kendall Ave APT B",
    "city": "Kalamazoo",
    "state": "MI",
    "zipcode": "49006",
    "neighborhood": "Westwood",
    "community": null,
    "subdivision": null
  },
  "bedrooms": 6,
  "bathrooms": 3.5,
  "price": 300,
  "longitude": -85.626183,
  "latitude": 42.29457,
  "description": "Rent: $300.00/bed Student Housing. This is a 3-unit complex within close proximity to WMU consisting of 6 bedrooms and 3.5 baths throughout three levels in each unit. The main level features 1 of the 6 bedrooms, 1/2 bath, a roomy living room, kitchen with an eating area, and entry to your private deck. The upper level features 3 bedrooms, 2 full baths and a laundry area with a full size washer and dryer. The lower level features 2 bedrooms, 1 full bath and a bonus 2nd living area to use for socializing, gaming, studying, etc. All bedrooms are good-size and privately keyed. trash, lawn and snow plowing services included. Pet friendly with prior management approval and pet rent. Cats Allowed\nOven\nParking\nResident Pays Electricity\nResident Pays Gas\nResident Pays Water\nSmall Dogs Allowed\nSmoke Free\nTrash Pick Up Included\nUnfurnished\nWasher & Dryer",
  "livingArea": 2236,
  "currency": "USD",
  "url": "https://www.zillow.com/homedetails/312-N-Kendall-Ave-APT-B-Kalamazoo-MI-49006/2096316908_zpid/",
  "photos": [
    "https://photos.zillowstatic.com/p_f/IS3f0lgq5a0cxn0000000000.jpg",
    "https://photos.zillowstatic.com/p_f/ISzvuwdfl85g7p0000000000.jpg",
    "https://photos.zillowstatic.com/p_f/ISrpskv8h0xi7p0000000000.jpg",
    "https://photos.zillowstatic.com/p_f/ISjjq8d2dsol7p0000000000.jpg",
    "https://photos.zillowstatic.com/p_f/ISbdowuv8kgo7p0000000000.jpg",
    "https://photos.zillowstatic.com/p_f/IS3zfi07y70jap0000000000.jpg"
  ]
}
```
If the `simple` attribute is not set, the result will contain many more attributes.
You can find example of a full result [here](https://pastebin.com/P016j7ip).

### Map splitting
To overcome the limit of 500 results per page, the crawler uses Zillow's internal API to search for homes on a rectangular section of a map. If the number of results on the map is higher than 500, the map is split into 4 quadrants and zoomed. Each of these quadrants is searched for homes and can again contain 500 results (that means using 1 split, we've increased the total result limit to 2000). Unless the result count in the quadrant is less than 500 (no need to split anymore), the quadrant is split again and so on. To limit this behavior, you can set the `maxLevel` attribute. That way, the map will be split only a maximum of `maxLevel` times, even if the number of results is higher than 500.

### Compute units consumption
Keep in mind that it is much more efficient to run one longer scrape (at least one minute) than more shorter ones because of the startup time.

The average consumption is about **1 Compute unit per 2000 results** scraped.

### Extend output function

You can use this function to update the default output of this actor. This function gets Zillow internal home data object as an argument, so you can choose which other attributes you would like to add. The output from this function will get merged with the default output.

The internal home object contains huge amounts of data - [example](https://pastebin.com/kiWayJvs)
Any of these attributes can be added to the result object.

The return value of this function has to be an object!

You can return fields to achieve 3 different things:
- Add a new field - Return object with a field that is not in the default output
- Change a field - Return an existing field with a new value
- Remove a field - Return an existing field with a value `undefined`

```
(data) => {
    return {
        schools: data.property.schools,
        homeStatus: 'SOLD',
        address: undefined,
    }
}
```
This example will add a new field `schools`, change the `homeStatus` field and remove the `address` field

### Epilogue
Thank you for trying my actor. You can send any feedback you have to my email<EMAIL_ADDRESS>
If you find any bug, please create an issue on the [Github page](https://github.com/cermak-petr/actor-zillow-api-scraper).


text:
# OfficejetPro86xx-Downgrade
HP intentionally sabotaged their Officejet86xx series of printers (and quite a few others) to reject remanufactured cartridges on 9/13/16. While their intention is to stem illegal production of cloned and patent-infringing ink cartridges, the un-announced nature of this effort has cost many people a large sum of money and even their jobs.
This script is designed to upload the timebomb-less firmware until remanufacturing/filling companies can provide updated cartridges.
I want to recommend updating firmware back to the latest version once cartridge refillers have a chance to update their chips/software, but due to the lack of warning and the dishonest nature of HP's tactics, I'd disable all updates until further notice. (That's just my opinion.)

## Requirements
	 - HP Officejet 86xx printer connected to local network.
	 - Netcat (included in most linux distributions)
	 - HP firmware to "downgrade" with saved in the same directory as this script.
**Note: I can _not_ provide the firmware, but I _will_ list the version needed for each printer.**

## Usage
The script can be executed from any linux system running bash as follows:
 ```bash
./fix.sh <IP_ADDRESS>
```
Change <IP_ADDRESS> to whatever IP your printer has on the network.
## TODO
- [ ] Support for Windows and OSX
- [ ] Implement OS detection
- [ ] Implement firmware selection
- [ ] Code cleanup
- [ ] Improve future support for more printers

## Firmware Filenames/Version
 Model | Version | Filename
-------|---------|----------
8610 | FDP1CN1416AR | ojpro_8610_1416A_04152014_1.ful.rfu
8620 | FDP1CN1416AR | ojpro_8620_1416A_04152014_1.ful.rfu
8630 | FDP1CN1416AR | ojpro_8630_1416A_04152014_1.ful.rfu
8640 | FDP1CN1416AR | ojpro_8640_1416A_04152014_1.ful.rfu
8660 | FDP1CN1416AR | ojpro_8660_1416A_04152014_1.ful.rfu

The script can automatically download the firmware files from HP.

##DISCLAIMER:
>I am not affiliated with HP. Officejet is a registered trademark of Hewlett-Packard Development Company.
>I am not responsible for what you do with this script as it is provided for demonstration purposes only.
>This script itself is nothing more than a tool and does not in any way provide software/code from HP.

gha_language: Shell


text:
# Equaliser

https://en.wikipedia.org/wiki/Equaliser_(mathematics)

An equaliser is a set of arguments where two or more functions have equal values. An equaliser is the solution set of an equation. In certain contexts, a difference kernel is the equaliser of exactly two functions.

## Definitions

Let `X` and `Y` be sets. Let `f` and `g` be functions, both from `X` to `Y`. Then the equaliser of `f` and `g` is the set of elements `x ∈ X` such that
`f(x) = g(x)` in `Y`.

`Eq(f,g)` := `{ x ∈ X | f(x) = g(x) }`

```js
// for example
X = { a, b, c, d, e }
Y = { a, b, c, d }

f : X → Y = { a ⟼ c, b ⟼ b, c ⟼ d, d ⟼ d, e ⟼ d }
g : X → Y = { a ⟼ c, b ⟼ d, c ⟼ d, d ⟼ c, e ⟼ c }
//            ^^^^^^          ^^^^^^

eq(f,g) = { a, c }
```

The equaliser may be denoted `Eq(f,g)` or `eq(f,g)`. In informal contexts, the notation `{f=g}` is common.

The definition above used two functions f and g, but there is no need to restrict to only two functions, or even to only finitely many functions.

In general, if `F` is a set of functions from `X` to `Y`, then the equaliser of the members of `F` is the set of elements `x ∈ X` such that, given any two members `f` and `g` of `F`, `f(x) = g(x)` in `Y`. Symbolically:

`eq(𝓕)` := `{ x ∈ X | ∀f,g ∈ 𝓕. f(x) = g(x) }`

This equaliser may be written as `eq(f,g,h,…)` if `𝓕 = {f,g,h,…}`.

As a degenerate case of the general definition, let `F` be a singleton `{f}`. Since `f(x)` always equals itself, the equaliser must be the entire domain `X`.

As an even more degenerate case, let `F` be the empty set. Then the equaliser is again the entire domain `X`, since the universal quantification in the definition is vacuously true.

## Difference kernels

A *binary equaliser* (equaliser of two functions) is also called a **difference kernel** and denoted `DiffKer(f, g)` or `Ker(f, g)` or `Ker(f − g)`.

The last notation shows where this terminology comes from, and why it is most common in the context of abstract algebra: the difference kernel of `f` and `g` is simply the kernel of the difference `f − g`.

Furthermore, the kernel of a single function `f` can be reconstructed as the difference kernel `Eq(f,0)`, where `0` is the constant function with value zero.

Of course, all of this presumes an algebraic context where the kernel of a function is the preimage of zero under that function; that is not true in all situations. However, the terminology "difference kernel" has no other meaning.

license: Unlicense


text:
## What is Python Fun bites

`#pythonfunbites` is a new content initiative ran by the Python v-team at Azure Cloud Advocacy. During the week of November 16th-20th we will be releasing bite-size content on all things related to Python at Microsoft.

All the content will be published in <https://dev.to/azure>

repository: GeekTrainer/python-fun-bites

repo_name: GeekTrainer/python-fun-bites


text:
# center

center an element in window or inside another element.

``` js
var center = require('center')

document.body.appendChild(center(el))

```

If you want to add features, post an issue and i'll add you as collaborator.

## License

MIT

repository: dominictarr/center

repo_name: dominictarr/center


text:
# Ustilago spinulosa L. Ling, 1953 SPECIES

#### Status
SYNONYM

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

#### Published in
Sydowia 7(1-4): 153 (1953)

#### Original name
Ustilago spinulosa L. Ling, 1953

### Remarks
null

repository: mdoering/backbone

path: /life/Fungi/Basidiomycota/Ustilaginomycetes/Ustilaginales/Ustilaginaceae/Macalpinomyces/Macalpinomyces spinulosus/ Syn. Ustilago spinulosa/README.md

repo_name: mdoering/backbone


text:
## MGObservers

**MGObservers** provides an lightweight API for keypath observing and UIControl event
handling.

### Setup

```
pod 'MGObservers'
```

### Examples

```objc
#import <MGObservers/MGObservers.h>
```

### Keypath Observing

```objc
[box onChangeOf:@"selected" do:^{
    NSLog(@"the new selected value is: %d", box.selected);
}];
```

### Control Event Observing

```objc
[button onControlEvent:UIControlEventTouchUpInside do:^{
    NSLog(@"i've been touched up inside. golly.");
}];
```

Or in Swift:

```swift
button.onControlEvent(.TouchUpInside) {
    print("you touched me!")
}
```

extension: markdown


text:
Serve
=====

Serve is a simple command line utility to serve the files in the current
directory via http.

Usage:

```
> serve
> Listening on port 80
```

By default serve listens on port 80, but you can override this by providing
a port number explicitly:

```
> serve 3000
> Listening on port 3000
```

# To do

* Better error handling
* Any ideas? Open a PR!

repository: BlakeWilliams/Serve

repo_name: BlakeWilliams/Serve


text:
This directory is created by the android tool on the command line as follow and
was executed at its parent's directory. You don't need to run this command by
yourself.

    android create project -n HelloGYP -t android-19 -p android -a MainActivity -k com.example.hellogyp

Before starting this example. Some requirements need to be installed. If you
have Homebrew on Mac, you can simply run...

    brew install android-sdk android-ndk ant

Now we need to create android makefiles for our gypified library. Before doing
this, change the directory to `<hellogyp_root>` to prevent the `Path  attempts
to escape from gyp path` error generated by GYP. The reason we need to
change to the `<hellogyp_root>` directory is because we use "`..`" in the
`include_dirs` parameter in `<hellogyp_root>/hellogyp/hellogyp.gyp`.

    cd <hellogyp_root>
    gyp --depth=./ -f android hellogyp/hellogyp.gyp

At this point, we can change to the root directory of our Android example.

    cd <hellogyp_root>/android/

Then we need to generate the `build.xml` file by

    android update project -p .

Before actually build the app. We need to build native code firstly by NDK.

    ndk-build

At this point, we can build the actual app.

    ant debug

To install the app into Android emulator. You need to open the AVD Manager
and launch any virtual device.

    android avd

After the virtual device is launched. We can finally install the app to
the emulator.

    adb install bin/HelloGYP-debug.apk

repository: ollix/hellogyp

repo_name: ollix/hellogyp


text:
# The relationship between generated source-code artifacts and RDF vocabularies

Source-code artifacts (e.g., Java JARs, Node.js modules, C# assemblies, etc.)
can be generated from individual RDF vocabularies, or from collections of
multiple RDF vocabularies. For example, in the case of Java, a single
generated Java JAR may contain multiple Java Classes, with each Class
representing the 'terms' (i.e., the Classes, Properties and Constants)
described within a single RDF vocabulary. In other words, each Java Class
within that JAR would define static constants for each of the defined terms
within a corresponding RDF vocabulary.

Developers often need to work with terms from multiple vocabularies, which is
why for convenience the Artifact Generator can bundle classes generated from
multiple vocabularies into a single artifact. In this way, a developer can
depend on a single artifact and import just the specific vocabulary classes
they need to work with. For instance, Inrupt bundles over 40 common RDF
vocabularies into a single artifact, and it bundles all Solid vocabularies
into another single artifact, and all Inrupt vocabularies into yet another.

Perhaps the single most important, and widely used, vocabulary today is
Schema.org, from Google, Microsoft, Yahoo and Yandex. The official RDF for
Schema.org is defined here: `https://schema.org/version/latest/schemaorg-current-http.ttl`.

Any individual or company is completely free to use the Artifact Generator
(or any other generator!) to generate their own source-code artifacts
to represent the terms defined in Schema.org. And of course, they are also
free to use the Artifact Generator to generate source-code artifacts (e.g.,
a Java JAR containing Java classes, or an `npm` package containing JavaScript
classes) that represents any available RDF vocabularies, including their own
purely internal and/or proprietary vocabularies.

So anyone is completely free to define their own RDF vocabularies. Likewise,
anyone is completely free to run the Artifact Generator against any available
RDF vocabulary, meaning it's perfectly fine to have a multitude of generated
artifacts claiming to represent the terms from anyone else's RDF vocabulary.

In other words, it's important to remember that it's not necessary to control
an RDF vocabulary in order to generate useful source-code artifacts from it.

For instance, IBM could choose to generate their own JavaScript module from
the Schema.org vocabulary, and publish their generated module for others to
depend on as follows:
```json
dependencies: {
<EMAIL_ADDRESS>"^1.5.3"
}
```

...whereas Accenture (a major competitor to IBM) are completely free to also
publish their generated JavaScript (or Java, or C#, or Scala, etc.) source
code artifacts representing exactly the same Schema.org vocabulary, e.g.:
```json
dependencies: {
<EMAIL_ADDRESS>"^0.0.9"
}
```

The Artifact Generator allows each of these entities to configure their
generated artifacts as they see fit, e.g., perhaps IBM augments their version
with translations for various languages (that Schema.org does not provide
today), or Accenture augments their version with references to related
resources (e.g., via `rdfs:seeAlso` references) to similar terms in existing
Accenture glossaries or data dictionaries.

Of course, individuals or companies are always completely free to choose
between reusing existing generated artifacts from entities that they trust,
or generating their own internal-only artifacts. Or they could choose to
create their own programming-language-specific Classes containing constants
for the terms in existing common RDF vocabularies (but why would anyone
choose to do that... :) ?).

[Back to the homepage](../README.md)

repository: tiago-peres/artifact-generator

repo_name: tiago-peres/artifact-generator


text:
# TestCafe Reporter Slack
### testcafe-reporter-slack

This is a reporter for [TestCafe](http://devexpress.github.io/testcafe). It sends the output of the test to slack.

## Purpose
Once configured the repoter sends test results to Slack depending on a .env file from the folder the tests are run from

## Setup instructions
Follow the instructions bellow to configure this plugin.

First install this package globaly to the machine you would like to run your tests on and then:

## Testing
Running TestCafe with testcafe-reporter-slack.

In order to use this TestCafe reporter plugin it is necessary to define .env variables in your test project, hence the folder from where your call TestCafe.

- cd into your test project.
- Edit or create the .env file by adding the following ki-reporter required variables:

```
TESTCAFE_SLACK_WEBHOOK=https://hooks.slack.com/services/*****
TESTCAFE_SLACK_CHANNEL='#testcafe'
TESTCAFE_SLACK_USERNAME=testcafebot
```

Now run your tests from the commmand line with the ki-reporter specified, e.g.:

```
$ testcafe chrome 'path/to/test/file.js' --reporter slack
```

When you use TestCafe API, you can pass the reporter name to the `reporter()` method:

```js
testCafe
    .createRunner()
    .src('path/to/test/file.js')
    .browsers('chrome')
    .reporter('slack') // <-
    .run();
```

## Further Documentation
[TestCafe Reporter Plugins](https://devexpress.github.io/testcafe/documentation/extending-testcafe/reporter-plugin/)

repository: daitasu/testcafe-reporter-slack

repo_name: daitasu/testcafe-reporter-slack


text:
Below are some brief scratchings on how this works so I don't forget.

## What is MDX actually good for?

I recently moved my website over to MDX as I was tempted by the prospect of adding more interesting and interactive content that is normally in plain old markdown blogs. MDX lets you include react components directly into your markdown syntax documents and render them to a static page with Gatsby. I've wanted to put large zoomable images into some of my posts and this seems like a straightforward way.

## Make tiles from a big image

Some of my generative art or visualisation algorithms make images in the range of a few hundred megapixels, displaying these over the web takes a little care. The first step in translating a single giant image into a interactive zoomable is to slice it up into a bunch of tiles at different resolutions. [This Python repo](https://github.com/openzoom/deepzoom.py) provides all you need for this step.

```Python
import deepzoom

creator = deepzoom.ImageCreator(
    tile_size=256,
    tile_overlap=0,
    tile_format="jpg",
    image_quality=0.8,
    resize_filter="bicubic",
)

creator.create("input.tiff", "output/zoomable.dzi")
```

Some code like the above will convert a large tiff file into a folder containing subdirectories with many tiles at different resolutions, which I can then upload to my web host.

## Display with leaflet

Leaflet then provides a pan and zoomable display of the image. Leaflet is normally used for displaying maps, but is simple to adapt it to using the tiles generated above by specifying the correctly formatted url, and [setting the co-ordinate reference system to "simple"](https://leafletjs.com/examples/crs-simple/crs-simple.html), i.e. a plain grid.

_One small issue with the above is that Leaflet doesn't like fractional tiles so there are currently some weird edge effects which I could solve by making sure I pad all the tiles to the full dimensions._

Incorporating leaflet into a Gatsby site is happily very simple[^1] thanks to the [Gatsby React-Leaflet plugin](https://github.com/dweirich/gatsby-plugin-react-leaflet) which takes care of properly wrapping up the existing React-leaflet library (which itself makes Leaflet accessible as React components). Writing the r[eact component required to display the image](https://github.com/justinpinkney/justinpinkney.com/blob/master/src/components/BigImage.js) is very straightforward and then I can directly write the following in my markdown file to give the zoomable image at the top of the page.

```markdown
<BigImage
    options={ {center:[-0.25, 0.35], zoom:10, minZoom:9, maxZoom:14 } }
    tile_url="http://assets.justinpinkney.com/sandbox/montage/montage_files/{z}/{x}_{y}.jpg" />
```

One simple gotcha is highlighted on [gatsby-plugin-react-leaflet's readme](https://github.com/dweirich/gatsby-plugin-react-leaflet#step-3). Make sure any usage of leaflet or react-leaflet are wrapped in a check that the window is defined. During build time the plugin will [stub out the leaflet loader](https://www.gatsbyjs.org/docs/debugging-html-builds/#fixing-third-party-modules) so any imports will return an undefined, and if you try and use these during build time (rather than run time, which is what the window check above ensures) you are likely to get x is undefined type errors.

[^1]:  I actually started off trying to use [OpenSeadragon](https://openseadragon.github.io/) which has a much smoother pan and zoom action, but with no existing Gatsby integration it seemed like the harder option to start with.


text:
# Codeception TestRail Integration Module

This [Codeception](https://codeception.com) extension provides functionality for tests to report results to
[TestRail](https://testrail.com) using the [TestRail API v2](http://docs.gurock.com/testrail-api2/start).

**Note:** The extension currently only supports the `Cest` Codeception test format.  It cannot report PHPUnit or `Cept`
tests.

## Installation

The easiest way to install this plugin is using [Composer](https://getcomposer.org/).  You can install module
by running:

```
composer require --dev bookit/codeception-testrail
```

## Theory of Operation
The extension hooks the following Codeception events: `suite.after`, `test.success`, `test.skipped`, `test.incomplete`,
`test.error`, and `test.fail`.  The extension also provides an `_initialize()` method and some other helper methods.

During the `_initialize()` step, the module will fetch the project details and create a new plan for the run.  The plan
name can be procedurally generated but by default it will be the date and time formatted as *Y-m-d H:i;s*.  Also during
this step the default status list is overriden with any from the config.

During the `test.success`, `test.skipped`, `test.incomplete`, `test.error`, and `test.fail` events, a result is recorded
for that event.  TestRail Suites and TestRail Test Cases are set for the test using annotations (`@tr-suite` and
`@tr-case`).  The TestRail Suite can either be set at the class level or the method level; precedent is give to the
method level annotation.  The TestRail Test Case can only be set at the method level.  Additionally, the elapsed time
of the test will be formatted and recorded.

During the `after.suite` event, the collected results will be transmitted to TestRail.  This is accomplished by
performing two actions.  The first action is to create a TestRail Test Plan Entry for each of the TestRail suites in the
result set.  The Test Plan Entry will only contain Test Cases which were also registered.  The Test Plan Entry will
be named after the Codeception suite and the TestRail suite, separated by a colon.

After the Test Plan Entry is created, the Test Run ID is captured from the response and the test results are transmitted
using the bulk test result action.  Before the results are passed to TestRail, they're filtered to remove any results
which set the TestRail System Status of *Untested*.  The TestRail API issues an error when a result attempts to set this
status.

The default status map is:

| Codeception Status | TestRail Status | TestRail Status ID |
|:------------------ |:---------------:|:------------------:|
| success            | Success         | 1                  |
| failure            | Failed          | 5                  |
| error              | Failed          | 5                  |
| incomplete         | Success         | 1                  |
| skipped            | Untested        | 3                  |

## Configuration

The extension requires four configuration parameters to be set (`user`, `apikey`, `project`).  There are additional
configuration options for overriding statuses and disabling the connection to TestRail.

To enable the extension the following can be added to your `codeception.yml` config file:

```yaml
extensions:
    enabled:
        - BookIt\Codeception\TestRail\Extension
```

Global configuration options (like the `user` and `apikey`) should also be set in the `codeception.yml` config:

```yaml
extensions:
    config:
        BookIt\Codeception\TestRail\Extension:
            enabled: false                    # When false, don't communicate with TestRail (optional; default: true)
            user<EMAIL_ADDRESS> # A TestRail user (required)
            apikey: 'REDACTED'                # A TestRail API Key (required)
	  		url: 'https://myurl.testrail.com' # The base URL for you TestRail Instance
            project: 9                        # TestRail Project ID (required)
            status:
                success: 1                    # Override the default success status (optional)
                skipped: 11                   # Override the default skipped status (optional)
                incomplete: 12                # Override the default incomplete status (optional)
                failed: 5                     # Override the default failed status (optional)
                error: 5                      # Override the default error status (optional)
```

## More Information

* [Codeception](https://codeception.com)
* [TestRail](https://testrail.com)
* [TestRail API](http://docs.gurock.com/testrail-api2/start)
* [TestRail API Keys & Authentication](http://docs.gurock.com/testrail-api2/accessing#username_and_api_key)

## License

MIT

(c) BookIt.com 2016

repository: codeator/codeception-testrail

repo_name: codeator/codeception-testrail


text:
# Birdwatcher (Quack) Application

## Table of contents
 * [Overview](#Overview)
 * [Features](#Features)
 * [Deployment of application](#Deployment-of-application)
 * [Application Code](#Application-Code)
 * [Screenshots](#Screenshots)
 * [Future Developments](#Future-Developments)
 * [License](#License)
 * [Creators and Collaborators](#Creators-and-Collaborators)

# Overview
 Quack is a birdwatcher application which allows for users to view bird sightings (submitted by others) in an interactive map. Users can submit their own bird sightings; they can also learn more about individual birds by clicking on its respective HTML cards.

 This application is centered around the Ottawa area, though users can still technically submit bird sightings from anywhere in the world.

# Features

  * Entering the application:
     * To enter the Quack website and view its contents, prospective users must either sign up or log in. Quack will confirm if the username and password match its database, as well as verify that the username doesn't already exist.
     * For security purposes, the password must have a minimum of 6 and a maximum of 20 characters; the password must also conform to additional measures, such as the use of special and uppercase characters.
     * A successful login redirects the user to the homepage.

  * Homepage:
     * The user is presented random HTML `cards` containing images of birds commonly found in the Ottawa area.
     * Hovering over the card with the mouse displays the name of the bird associated with the image, as well as a `Learn More` feature allowing you to view more details about the bird in question. This feature applies to all bird cards.
     * At the bottom of the random selection of birds, there is a `View All Birds` link to see the complete list of pre-submitted birds, arranged alphabetically. This option is also available in the navigation bar.
     * Also, there is a `Shuffle` link, that helps to refresh page in order to see other 8 random birds.
     * The navigation bar allows users to quickly find features which allow them to submit bird sightings, view specifics about a particular bird, or submit a new bird profile.
     * The homepage includes a map containing bird markers; they represent bird sightings, corresponding to the birds from the (above) cards. They are selected randomly from the database, meaning that these markers will naturally be different each time the page loads!

  * Add Sighting
     * To add a bird sighting, the user clicks on the `View Map` link - located close to the map - or by clicking the `Add Sighting` in the navigation bar.
     * The `/map` route brings you to a large map with two inputs above it. From there, our user enters two pieces of information:
      - The bird you saw; this is an autocomplete list, coming directly from the database, and
      - The map coordinates (where you saw the bird); clicking on the map populates this input with its respective coordinates.
     * You can submit your bird sighting to the database by pressing the `Submit Bird Sighting For` button.
     * After submitting, the application redirects you to a `/singlebird:id` page which corresponds to the id of the bird you've submitted. (You don't have to worry about this; our code handles that!)

  * View Individual Birds
    * From the homepage, if you click for more information about a bird, or from `/map` after submitting a bird, you are brought to a `/singlebird` route, which presents you more specific information about your bird of choice, including its technical Latin name, its top age and weight, and a detailed description.

  * Creating a New Bird Profile
    * The Quack application comes pre-loaded with 20 unique bird profiles. By clicking the `Add New Bird` link in the navigation bar, users can create and submit a “new" bird profile, including details such as its proper name, its age, weight, and description.
    * Upon submission, users are redirected to the `Submit Sighting` page, in which their bird appears as a searchable option.

  * Deleting a Bird Profile
    * Given that a bird might have been added mistakenly or in bad faith, Quack's developers are able to delete bird profiles by accessing a secret URL and entering their choice of bird in an interactive menu.

  * Logging Out
    * At any time, the user can log out from the application by clicking “Logout” inside the navigation bar. The session terminates and the user is redirected to the sign in/sign up page. Our application also contains `Terms of Service`, and a `Privacy Policy` for security purposes.

 # Deployment of application

   To run the application, [click this link to be taken to the Heroku app.](https://birdwatcherquack.herokuapp.com/)

 # Application Code

   To view application code, [click this link to be taken to the Git repository.](https://github.com/BirdWatcherQuack/BirdWatcher)

 # Screenshots
 ### Login/Sign up page

  ### Side bar that displays username of logged-in user

  ### Home page with location markers (based on birds in above cards)

  ### Single bird description

  ### Form to submit a sighting for a bird

 ### Markers on the map

 ### Form to submit new bird

### Delete bird (only available for developers)

 # Future Developments

The Quack application has a number of features, allowing you to add and view birds and bird sightings. However, many extra features could be added to make Quack website more interactive. Here are a few ways we can improve our applications going forward.

 * There are no means to retrieve a forgotten password (i.e., the `Forgot Your Password?` prompt found under most logins). Our login page has such a prompt, which takes you to a form. However, submitting this form does not accomplish a password retrieval. Going forward, we plan on allowing users to update their passwords.

 * As it stands, we have the limited ability to sign up or log in using a Facebook account. We would further refine this process.

 * The login/signup page contains icons which allow a user to register through Twitter, Google, or LinkedIn. These currently do not work, but we can later link Quack with these social media accounts in the future, among others.

 * Furthermore, we would like to create user-specific account information, in which they may view birds they have added.

 * In addition to the existing bird profile generator, we might allow users to submit personal images of the birds they've seen. This would require a performant server, as large numbers of images would otherwise slow down the operation of our website.

 * To prevent a user from overflowing the map with markers (in bad faith), we plan on setting up restrictions (e.g., one bird sighting submission per 30 seconds). Moreover, we would create an approval process, for administrators to review and approve the bird sighting/profile before it appears on the website for all to view. These measures would limit false information.

## License
This project is licensed under:

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

## Creators and Collaborators

* Fabio Miguel Amorim Rodrigues
* Nwakaego Gift Eze
* Ahmed Hakeem
* Anastasia Sorkin
* Daniel Pisani


text:
+++
link = "http://sayanchowdhury.dgplug.org/2013/darkserver-improvement-pen-down.html"
description = ""
tags = ["gsoc", "fedora", "darkserver"]
date = "2013-09-25T12:00:00+05:30"
title = "Darkserver Improvement: Pen Down"
slug = "darkserver-improvement-pen-down"
timeToRead = 3
+++

Lot of things to do!

Lot of things to do!

Lot of things to do!

This was continuously revovlving around my head for last 2 weeks. I had to
deploy the work i had done on staging instance and test it. But wait! I had
never written a setup.py before, never made a RPM package before.

While in college, I had a fascination toward RPM packaging as most of my
college seniors had created a RPM package sometime or other. During Mukti
2011, I had attended a RPM packaging workshop by Rahul Sundaram(mether), so i had the idea of how to package a RPM.

But well before that i had to write a setup script for darkserver. Though the basic setup.py did not take much time, but i got stuck when it came to
include staticfiles in setup.py. After a lot of googling and seraching, the
result was null. So i asked in #python IRC channel, when Ned Batchelder
helped me out. Finally, I got a link to package a Django app titled-
Packaging a Django resuable app

After completing writing setup.py, I started working on building RPM
packaging. Here are some links:

* [Packaging:Guidlines](https://fedoraproject.org/wiki/Packaging:Guidelines?rd=Packaging/Guidelines)
* [How to create an RPM package](http://fedoraproject.org/wiki/How_to_create_an_RPM_package)
* [Packaging:Python](http://fedoraproject.org/wiki/Packaging:Python)

After completing rpm packaging, it’s time for koji scratch build. And i did it
but while installing it in the staging instance, something happened. I had
used target as rawhide instead of dist-6E-epel while koji scratch build.
Nevermind, I repeated the steps and voilà, i successfully perform a fresh
install of the package and everything was working properly.:)

And, with that Google Summer of Code came to an End.

.. image:: ../galleries/the-end.jpg
    :width: 90%
    :align: center


text:
# singlecellutils 1.0.0

* Initial release of the package.

### Features

- Sample/Feature filtering via `filter_samples` and `filter_features`.
- Inlcudes several dimension reduction methods, like `isomds`, `randomized_svd`, `approximate_svd` and `umap`.
- Provides access to the powerful hierarchical density-based clustering via `hdbscan`.
- Provides a logistic regression test for differential expression or accessibility via `lrde_test`.

### Vignettes / Articles

- Released version includes a vignette to illustrate sample/feature filtering.

repository: jenzopr/singlecellutils

repo_name: jenzopr/singlecellutils


text:
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
[![Build Status](https://travis-ci.org/nickrobison/backer.svg?branch=master)](https://travis-ci.org/nickrobison/backer)
[![Appveyor Build status](https://ci.appveyor.com/api/projects/status/3o70eaw8lpkqqeg9/branch/master?svg=true)](https://ci.appveyor.com/project/nickrobison/backer/branch/master)
[ ![Download](https://api.bintray.com/packages/nickrobison/debian/backer/images/download.svg) ](https://bintray.com/nickrobison/debian/backer/_latestVersion)
# Backer

Simple utility for keeping those various config files and settings that you have scattered across your servers, backed up to remote storage.

I created this tool after a server crash left me scrambling to rebuild nginx sites and dnsmasq configurations that I'd setup years ago and forgot about.

This is *NOT* intended to be used as a full backup solution, there are much better tools for that.
This is designed to be a lightweight utility for watching a handfull of files and pushing them to a remote location whenever they change.

## Usage

### Install

#### Go package

```bash
get get -u github.com/nickrobison/backer
```

#### Debian repository

```bash
sudo apt-get install apt-transport-https # Bintray only supports https connections
echo "deb https://dl.bintray.com/nickrobison/debian {distribution} {components}" | sudo tee -a /etc/apt/sources.list
apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys 379CE192D401AB61 # We need to import the Bintray public key
sudo apt-get update && apt-get install backer
```

### Configuring

Backer has a few configuration options that need to be set.
If you installed the Debian package, the default config is located in `/etc/backer/config.json`.
Otherwise, create a `config.json` file and point Backer to it.

```js
{
    "syncOnStartup": true, // On startup, sync all the files in the watcher paths with the remote backends
    "deleteOnRemove": true, // When a file is removed from the system, delete its remote copy (Not implemented yet)
    "deleteOnShutdown": false, // Delete the remote files when a shutdown occurs (Not implemented yet)
    "watchers": [
        {
            "bucketPath": "",
            "path": ""
        }
    ], // Array of files paths to watch, along with a root directory to store files in
    "s3": {
        "versioning": true, // Enable versioning in the S3 bucket
        "reducedRedundancy": true, // Use reduced redundency storage
        "region": "us-west-2", // AWS region
        "bucket": "", // Name of bucket to use
        "bucketRoot": "", // Directory within the bucket to store the files
        "credentials": {
            "AccessKeyID": "",
            "SecretAccessKey": "",
        } // AWS credentials
    }
}
```

### Running

This tool has two parts, a backend daemon and a frontend CLI.

The daemon needs to be running in order for the CLI to have something to communicate with.

#### Start the Daemon

```bash
backer --daemon --config={path to config file}
```

If you're using the Debian package, you can use systemd to start everything.

```bash
systemctl start backer
```

### Using the CLI

Most of the CLI is unimplemented right now, but you can at least get a list of watcher roots, so that's nice.

```bash
backer list watchers
```

## TODO list

This is a really early stage release, lots of things still left to do.

Right now, you can only upload files, you can't delete them, and you can't download them directly with Backer. You'll need to rely on other tools for that.

- [ ] File downloading
- [ ] File deletion
- [ ] Multiple backends
    - [ ] SCP
    - [ ] FTP
    - [ ] Glacier
    - [ ] Azure
    - [ ] Digital Ocean
    - [ ] Backblaze
- [ ] Full CLI support
- [x] Windows support

repository: nickrobison/backer

repo_name: nickrobison/backer


text:
# Xchanger
Application that displays currency exchange rates that update in real time every second. [APK download links.](https://github.com/steelahhh/Xchanger/releases/tag/0.0.1)

<img src="media/screen_0.jpg" width="250">

## Technologies used
- Multi-module architecture, with packaging by feature. Each module is responsible for only certain set of operations, but recurring or common to all modules tasks could be extracted into a separate module.
- MVVM via airbnb/MvRx. The library allows for easy state managment and persistance.
- Dagger2 for DI
- AdapterDelegates for reducing RecyclerView boilerplate
- RxJava
- Moshi for JSON parsing
- Retrofit

## What could be improved
- Navigation. Whenever the need for more complex navigation arises, it could be done by either introducing some library (i.e. AAC Navigation), or by wrapping the FragmentManater and using its APIs. Inter-module navigation could be achieved by introducing an interface with navigation routes/actions in the feature module, that the app or flow-common module implements.
- Maybe persist selected currency with the value
- Persist polling rate, so it's not static and could be configured via some remote service
- UI + integration testing

repository: steelahhh/Xchanger

repo_name: steelahhh/Xchanger


text:
---
layout: post
title: Pipes
readtime: true
date: Wed Dec  7 23:05:22 2022
---

# Learning Objectives

At the end of this lecture, you should be able to:
- Define pipes and the way they are implemented in the OS.
- Use pipes to allow for exchange of information between processes.

---

# Topics

In this lecture, we will cover the following topics:
- Unix pipes.

---

# Notes

<!-- vim-markdown-toc GFM -->

* [Motivation](#motivation)
* [Pipes](#pipes)
  * [Implementation](#implementation)
  * [Usage](#usage)
  * [Example](#example)
  * [Edge Cases](#edge-cases)

<!-- vim-markdown-toc -->

# Motivation

- By default, processes are isolated from one another. One process cannot read
  data that is in another process's address space.
  - :question: Why would we want to do that?
- As much as we would like processes to be completed isolated, we must allow
  them some forms of communication.
  - :question: If you were designing your OS now, how would you implement
    inter-process communication?
- So far, we have seen one way for processes to communicate with each other, and
  that is through using signals.
  - However, signals cannot carry too much information, only notifications.

# Pipes

- Pipes are in-memory files that allow for data communication between related
  processes in a first-in-first-out fashion.
- In fact, processes can communicate without even knowing who is on the other
  end of the pipe.
  - Kind of like a tunnel where someone is shouting on the other end, you can
    hear them but you cannot really know who they are.
- In this class, we will focus on __unnamed__ pipes, named pipes are beyond what
  we will cover here.

- __Definition__: A pipe is a __unidrectional__ channel of communication between
  two or more processes that share an ancestor that has set up a pipe.
  - All descendants of that ancestor will share access to that pipe.
    ![pipe](./simple_pipe.png)

## Implementation

- Behind the scenes, the operating system implements a pipe as a virtual file in
  memory.
  - In other words, the file does not exist on the disk, and after it is closed,
    its content are lost.
- The process wishing to communicate will maintain file pointers to that
  in-memory file, typically using file descriptors represented by integers.
  - Similar to what we get when we open a file in Linux using `fd = open(...)`.

- A pipe's in-memory file is implemented as a circular array of characters.
  - The pipe file's data structure maintains two pointers:
    1. A read pointer from which to read the next character.
    2. A write pointer where to write the next character.
  ![ca](./circular_array.png)

## Usage

- To create a pipe, a process can use the `pipe()` function that takes as
  argument an array of two integers.
  - The first element of that array will be the __reading__ end of the pipe.
  - The second element of that array will be the __writing__ end of the pipe.
- To read or write to a pipe, you can use the appropriate `read` and `write`
  system calls using the corresponding end of the pipe.

## Example

- Here is an example of creating a pipe and reading/writing data to it.
  ```c
  int fd[2];
  pipe(fd);

  if(fork() == 0) {
    /* this child is the writer, so it must close the reading end */
    close(fd[0]);

    const char *msg = "hello world!";
    write(fd[1], msg, strlen(msg));
    close(fd[1]);
    exit(0);
  } else {
    /* the parent is the reader, so it must close the writing end */
    close(fd[1]);

    char buff[512];
    if(read(fd[0], buff, 512) > 0) {
      printf("Read %s from pipe\n", buff);
    }
    close(fd[0]);
  }
  ```

## Edge Cases

- There are 4 cases that might arise when dealing with a pipe:
  1. Reading from a pipe that has enough data in it:
    - All is well and everything is good.
  2. Writing to a pipe that has enough space in it:
    - All is well and everything is good.
  3. Reading from an empty pipe, the calling process will sleep until one of the
     following conditions happen:
    - Someone writes to the pipe, then `read` returns the number of bytes
      read.
    - All writing ends are closed, and then `read` returns 0.
  4. Writing to a full pipe, the calling process will sleep until:
      : Someone reads from the pipe and then there is enough room in the pipe.
    - All reading ends are closed, the kernel will send the process the
      `SIGPIPE` signal (though this behavior can be overridden).

gha_language: C


text:
The flag has been inserted at the end of the zlib deflate stream after
the PNG row / pixel data.

```
$ dd if=denouement.png bs=1 skip=41 |  ~/projects/misc_perl/zlibinflate.pl | strings -a | tail -n 1
126867+0 records in
126867+0 records out
126867 bytes (127 kB, 124 KiB) copied, 0.0976865 s, 1.3 MB/s
CTF{then_we_just_float_away_with_the_rest_of_the_pixels}
```

libpng provides a big hint:
`libpng warning: IDAT: Too much image data`

Also the image is a screenshot of a stackoverflow question about
what's in a png zlib stream.


text:
---
sidebar_position: 3
title: Ownable
---

This example shows how you can use the implementation of [ownable](https://github.com/Supercolony-net/openbrush-contracts/tree/main/contracts/access/ownable) to provide `only owner` rights for contract's functions.

## Step 1: Include dependencies

Include dependencies to `ownable` and `brush` in the cargo file.

```toml
[dependencies]
ink_primitives = { tag = "v3.0.0-rc4", git = "https://github.com/Supercolony-net/ink", default-features = false }
ink_metadata = { tag = "v3.0.0-rc4", git = "https://github.com/Supercolony-net/ink", default-features = false, features = ["derive"], optional = true }
ink_env = { tag = "v3.0.0-rc4", git = "https://github.com/Supercolony-net/ink", default-features = false }
ink_storage = { tag = "v3.0.0-rc4", git = "https://github.com/Supercolony-net/ink", default-features = false }
ink_lang = { tag = "v3.0.0-rc4", git = "https://github.com/Supercolony-net/ink", default-features = false }
ink_prelude = { tag = "v3.0.0-rc4", git = "https://github.com/Supercolony-net/ink", default-features = false }

scale = { package = "parity-scale-codec", version = "2.1", default-features = false, features = ["derive"] }
scale-info = { version = "0.6.0", default-features = false, features = ["derive"], optional = true }

# These dependencies
ownable = { tag = "v1.0.0", git = "https://github.com/Supercolony-net/openbrush-contracts", default-features = false }
brush = { tag = "v1.0.0", git = "https://github.com/Supercolony-net/openbrush-contracts", default-features = false }

[features]
default = ["std"]
std = [
   "ink_primitives/std",
   "ink_metadata",
   "ink_metadata/std",
   "ink_env/std",
   "ink_storage/std",
   "ink_lang/std",
   "scale/std",
   "scale-info",
   "scale-info/std",

   # These dependencies
   "ownable/std",
   "brush/std",
]
```

## Step 2: Add imports

Replace `ink::contract` macro by `brush::contract`.
Import **everything** from `ownable::traits`.

```rust
#[brush::contract]
pub mod ownable {
   use ownable::traits::*;
   use brush::modifiers;
   use ink_prelude::vec::Vec;
```

## Step 3: Define storage

Declare storage struct and declare the field related to `OwnableStorage` trait. Then you need to derive the `OwnableStorage` trait and mark the corresponding field with the `#[OwnableStorageField]` attribute. Deriving this trait allows you to reuse the default implementation of `Ownable`.

```rust
#[ink(storage)]
#[derive(Default, OwnableStorage)]
pub struct MyOwnable {
    #[OwnableStorageField]
    ownale: OwnableData,
}
```

## Step 4: Inherit logic

Inherit implementation of the `Ownable` trait. You can customize (override) methods in this `impl` block.

```rust
impl Ownable for MyOwnable {}
```

## Step 5: Define constructor

Define the constructor and initialize the owner with the contract initiator. Your basic version of `Ownable` contract is ready!

```rust
impl MyOwnable {
    #[ink(constructor)]
    pub fn new() -> Self {
        let mut instance = Self::default();
        let caller = instance.env().caller();
        instance._init_with_owner(caller);
        instance
    }
}
```

## Step 6: Customize your contract

Customize it by adding ownable logic. We will add a `owner_function` to `MyOwnable` implemenation and add the `only_owner` modifier, which will verify that the caller of the function is the owner.

```rust
#![cfg_attr(not(feature = "std"), no_std)]

#[brush::contract]
pub mod ownable {
   use brush::{
      modifiers,
      traits::InkStorage,
   };
   use ink_prelude::vec::Vec;
   use ownable::traits::*;

   #[ink(storage)]
   #[derive(Default, OwnableStorage)]
   pub struct MyOwnable {
      #[OwnableStorageField]
      ownable: OwnableData,
   }

   impl Ownable for MyOwnable {}

   impl MyOwnable {

      #[ink(constructor)]
      pub fn new() -> Self {
         let mut instance = Self::default();
         let caller = instance.env().caller();
         instance._init_with_owner(caller);
         instance
      }

      #[ink(message)]
      #[modifiers(only_owner)]
      pub fn owner_function(&mut self) {
         // TODO
      }

   }

}

```

You can check the example of usage of [Ownable](https://github.com/Supercolony-net/openbrush-contracts/tree/main/examples/ownable).

repository: pormeu/openbrush-contracts

repo_name: pormeu/openbrush-contracts


text:
An aiohttp stream server for DeepSpeech
=======================================

Implements a full asynchronous HTTP server for converting speech to text in
realtime using [DeepSpeech][].

Since version [0.2][DeepSpeech Streaming], DeepSpeech has supported streaming
APIs that allow processing audio data in small chunks instead of all at once.
This enables the capability of a real-time streaming server (given sufficient
hardware).

Real time streaming of audio data requires that both client and server support
[HTTP chunks][] so that data can be passed from the client to the server in
small batches. This allows the server to start processing the data with
DeepSpeech while more data is being recorded and transferred by the client.

Usage
-----

This project uses [Pipenv][] to manage dependencies. To install the dependencies
and get a shell, run: `pipenv install && pipenv shell`

Once in that, shell, simply run `./app.py` to start the server.

Results
-------

The preliminary results from this implementation are very encouraging. On my
dual-core i5-6200 laptop, the server is easily able to keep up with a realtime
stream of audio data from the microphone:

**Client:**
```
$ ./examples/mic http://localhost:8080/stt
rec WARN wav: Length in output .wav header will be wrong since can't seek to fix it

Input File     : 'default' (pulseaudio)
Channels       : 1
Sample Rate    : 16000
Precision      : 16-bit
Sample Encoding: 16-bit Signed Integer PCM

In:0.00% 00:00:05.63 [00:00:00.00] Out:55.8k [      |      ]        Clip:0
Done.
the quick brown fox jumped over the lazy dog
```

**Server**
```
$ ./app.py
INFO:root:Loading model...
TensorFlow: v1.12.0-10-ge232881
DeepSpeech: v0.4.1-0-g0e40db6
2019-06-05 09:54:49.098465: I tensorflow/core/platform/cpu_feature_guard.cc:141] Your CPU supports instructions that this TensorFlow binary was not compiled to use: AVX2 FMA
INFO:root:Model was loaded in 0.236s
======== Running on http://<IP_ADDRESS>:8080 ========
(Press CTRL+C to quit)
INFO:root:Processing Stream...
INFO:root:Inference took 1.751s for 3.486s audio sample with 0.249s latency. Total time: 7.098s
```

As can be seen, the server was easily able to process the streamed audio data
about twice as fast as it was streamed. In addition, the minimal latency (time
from when the last audio sample was received to the time when the server sent a
response to the client) meant that the server was able to respond back to the
client very promptly once the audio clip was finished.

[DeepSpeech]: https://github.com/mozilla/DeepSpeech
[DeepSpeech Streaming]: https://hacks.mozilla.org/2018/09/speech-recognition-deepspeech/
[HTTP chunks]: https://en.wikipedia.org/wiki/Chunked_transfer_encoding
[Pipenv]: https://docs.pipenv.org/en/latest/

repository: GustavMauler/deep-dregs

gha_language: Python

repo_name: GustavMauler/deep-dregs


text:
# news-cli 📚
A CLI Tool built using Inquirer that fetches the latest news updates based on source

### Installation
Navigate to desired directory using the terminal. Enter the following command

```git clone https://github.com/ARitik/news-cli.git```

To run , enter ```node index.js```

### Usage
After running ```node index.js``` , select the option you want to see news from.

![select-menu](./select.png)

The tool will fetch the latest top-ten news from the option you've selected using the news-api.

![news-feed](./news.png)

Also available as an NPM package

https://www.npmjs.com/package/whatsnews

repository: ARitik/news-cli

repo_name: ARitik/news-cli


text:
# cast [![comychitz](https://circleci.com/gh/comychitz/cast.svg?style=shield)](https://app.circleci.com/pipelines/github/comychitz/cast)
A simple and lightweight C++ build system with minimal user configuration.

## Features
* Minimal user configuration
* Built-in unit testing support
* Support for incremental and partial project builds
* Integrates with [Conan](https://github.com/conan-io/conan) for handling external dependencies
* Support for cross compilation

## usage
Just run cast from the top level of your project!
```
$ cast
```
Simply clean up using:
```
$ cast clean
```
Run unit tests using:
```
$ cast check
```

## project structure
With Cast, every directory under your `src` folder is automatically compiled
based on the `cast.cfg`. If no config exists, the default behavior is to compile
a driver. Cast supports compiling executables and libraries (static and
dynamic). Folders named `test` are targeted for unit tests.

Folder names are used for naming the libraries and executables by default
(libraries prefixed with lib).

Include a `conanfile.txt` file at the top level of your directory and cast will
handle installing and linking against the dependencies for you. *Note: this
requires the CastGenerator package to be available.*

### example projects
See example projects [here](https://github.com/comychitz/cast/tree/master/examples)

### cast.cfg
A simple library configuration can contain the following:
```
target:so
cflag:-fPIC
ldflag:-ldl
```
or
```
target:exe
name:hello_world
```
If your project contains subdirectories that are required to be built in a
particular order, use the `subdir` config item. If a directory exists that isn't
referenced in a config, Cast will enter it an compile it anyway.
```
subdir:myLib
subdir:myExe
```

### config items

| config item | possible values | notes |
|---|---|---|
| target | "exe", "so", "a" |
| name | *string* | file name of the resulting target. libraries are prefixed with `lib` and include the extension
| subdir | *relative_path* | add a subdir to the project
| cflag | *string* | append to the list of cflags |
| ldflag | *string* | append to the list of ldflags |

### integrating cross compilers
To have cast use a cross compiler installed on your machine, add a cross tool
config file into `/usr/local/share/cast/crosstools`, with the cross tool's name
plus `.cfg` as the file's extension. The following items shall be defined in
the cross tool config (following the same format for *cast.cfg* files).

| config item | description |
|---|---|
| ar | archive tool |
| gxx | compiler |
| strip | strip tool |

### default system dependencies
If there are specific libraries that are available on the system (ex. pthread)
that you'd like to use in your project directly, you need to make Cast aware
of them. This can be done by adding dependency config files to the default Cast
dependency directory: `/usr/local/share/cast/deps/`.

For example, to make cast aware that a source file that includes `pthread.h`
needs to link with `-lpthread`, add a file named `pthread.cfg` to the default
Cast dependency directory with the following contents
```
header:pthread.h
lib:-lpthread
```
*If the dependency depends on another dependency, add `dep:` entry for each
dependency. For example, if there is a system library named `libC` that depends
on `libA` and `libB` we would create 3 dependency config files (named
`libA.cfg`, `libB.cfg` and `libC.cfg`), of which the `libC.cfg` file would
contain the following:
```
header:libC.h
lib:-llibC
dep:libA
dep:libB
```

## build cast
### Requires
* c++14 compiler
* [Catch2](https://github.com/catchorg/Catch2) to be installed (for running cast's unit tests)

To build cast simply run:
```
$ cd src
$ make
```
Run unit tests using:
```
$ make check
```
install cast:
```
$ make install
```

### building the Conan generator
Build and install the Conan generator package using the following:
```
$ cd conan && conan create . <user>/<channel>
```
*Specify the appropriate user and channel values*

repository: comychitz/cast

repo_name: comychitz/cast


text:
# IOTA C Client API Reference

## Welcome

This is an IOTA Client library for IOTA Shimmer network.
Learn more about IOTA, please visit [IOTA WiKi](https://wiki.iota.org/).
This C Client is still a highly development project for POSIX systems and embedded development, such as STM32, Nordic, Arduino, and ESP32 MCUs, the repository can be found in [iotaledger/iota.c](https://github.com/iotaledger/iota.c).

```{toctree}
---
maxdepth: 2
caption: IOTA C Client
---
introduction.md
examples.md
arduino_esp32.md
```

```{toctree}
---
maxdepth: 1
caption: API Reference
---
api/wallet.md
api/events.md
api/restful.md
api/core.md
api/crypto.md
```

branch_name: refs/heads/develop


text:
android-floating-action-menu
============================

Floating Action Menu for Android. Inspired by the Google Plus floating menu.

Demo
====

[![IMAGE ALT TEXT HERE](http://img.youtube.com/vi/mLplXAJ5vug/0.jpg)](https://www.youtube.com/watch?v=mLplXAJ5vug&feature=youtu.be)

Setup
=====

The simplest way to use this library is to add the library as a gradle aar dependency to your build. See the CHANGELOG.md for the latest version number.
```gradle
repositories {
	mavenCentral()
}

dependencies {
	compile 'it.sephiroth.android.library.floatingmenu:floatingmenu:x.x.x' // see changelog
}
```
Usage
=====

In your activity create a reference to the `FloatingMenu`:

```java
FloatingActionItem item1 = new FloatingActionItem.Builder(0)
	.withResId(R.drawable.ic_facebook)
	.withDelay(0)
	.withPadding(action_item_padding)
	.build();

FloatingActionItem item2 = new FloatingActionItem.Builder(1)
	.withResId(R.drawable.ic_googleplus)
	.withDelay(50)
	.withPadding(action_item_padding)
	.build();

FloatingActionItem item3 = new FloatingActionItem.Builder(2)
	.withResId(R.drawable.ic_twitter)
	.withDelay(100)
	.withPadding(action_item_padding)
	.build();

mFloatingMenu = new FloatingActionMenu
	.Builder(this)
	.addItem(item1)
	.addItem(item2)
	.addItem(item3)
	.withScrollDelegate(new FloatingActionMenu.AbsListViewScrollDelegate(mListView))
	.withThreshold(R.dimen.float_action_threshold)
	.withGap(R.dimen.float_action_item_gap)
	.withHorizontalPadding(R.dimen.float_action_h_padding)
	.withVerticalPadding(R.dimen.float_action_v_padding)
	.withGravity(FloatingActionMenu.Gravity.CENTER_HORIZONTAL | FloatingActionMenu.Gravity.BOTTOM)
	.withDirection(FloatingActionMenu.Direction.Vertical)
	.animationDuration(300)
	.animationInterpolator(new OvershootInterpolator())
	.visible(visible)
	.build();

mFloatingMenu.setOnItemClickListener(this);
```

License
=======

    Copyright (c) 2014 Alessandro Crugnola

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

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

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

repository: mulieriq/sophia

repo_name: mulieriq/sophia


text:
##What is this?
This is a repackaging of a version of the snowball-stemmer found at https://snowballstem.org/ so that it's available
on Maven Central.

##Maven
```xml
<dependency>
  <groupId>com.github.albarron</groupId>
  <artifactId>snowball-stemmer</artifactId>
  <version>2.0.0</version>
</dependency>
```

##Gradle
This is the original compilation:
```groovy
compile "com.github.albarron:snowball-stemmer:2.0.0"
```
I used this one instead:
```
 gradle build
```
It produces all jar files.

The resulting jar files are currently NOT pushed to maven central. They can be installed locally running
```
mvn install:install-file -Dfile=snowball-stemmer-2.0.0.jar -DgroupId=com.github.albarron -DartifactId=snowball-stemmer -Dversion=2.0.0 -Dpackaging=jar -DgeneratePom=true
```

Anf the dependency can be added as usual in the maven pom file

##Versioning
In the absence of tags, branches, or releases in the original project SVN repository to call out a version, let's go
with what [PyStemmer](https://pypi.python.org/pypi/PyStemmer) is currently using and tack on the SVN revision number at
the end followed by my patch revision number (to fix anything weird that I ---that means rholder--- introduce). For the initial version, we'll
use <IP_ADDRESS>1.1. The current version is 2.0.0

##License
This is a copy of the details about the license from [here](https://snowballstem.org/license.html):

```
Except where explicitly noted, all the software given out on this Snowball site is covered by the 3-clause BSD License:

Copyright (c) 2001, Dr Martin Porter,
Copyright (c) 2002, Richard Boulton.
All rights reserved.

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.

Essentially, all this means is that you can do what you like with the code, except claim another Copyright for it, or claim that it is issued under a different license. The software is also issued without warranties, which means that if anyone suffers through its use, they cannot come back and sue you. You also have to alert anyone to whom you give the Snowball software to the fact that it is covered by the BSD license.
```

##References
* https://snowballstem.org
* https://github.com/snowballstem

repository: albarron/snowball-stemmer

repo_name: albarron/snowball-stemmer


text:
# Zapoteca caracasana (Jacq.) H.M.Hern. SPECIES

#### Status
ACCEPTED

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

#### Published in
Ann. Missouri Bot. Gard. 73:757. 1987 ("1986")

#### Original name
Mimosa caracasana Jacq.

### Remarks
null


text:
# 02807-SureBetting
Computational Tools For Data Science Project by Joakim Edin, Aske Bluhme Klok, Nicolai Pedersen

To run the MapReduce analysis on historical data:

    - Go to the folder historical Data
    - run the script AnalyzeOldSoccerData.py
    - make sure that the folder contains another folder called plots

To run the application:

    - Make sure you have installed java and Apache Spark
    - Run the python script App.py
    - Another terminal opens. This is the web crawler.
    - In the main terminal you can see how much money you make
    - To end the application press ctrl+c in the main window

Requirements:
-Python 3 (Python 3.7)
-Java SDK 8 (java version "1.8.0_161")
-Spark 2 (Apache Spark 2.3.2)

[In brackets is the specific version used for developing the software]

Installing the application:
    The installation of Apache spark follows these youtube videos:
        - [https://www.youtube.com/watch?v=4PlvpoTAbYQ] Set up java
        - [https://www.youtube.com/watch?v=iarn1KHeouc] Set up Spark

    Alternatively, you can follow these steps

Linux install:

-install java and set up path
1) sudo apt install openjdk-8-jre-headless (unless you have already installed java)
    -check with [java -version] if you have java installed
2) locate java file path by running "readlink -f $(which java)"
    -This returned the path "/usr/lib/jvm/java-8-openjdk-amd64/jre/bin" for med
3) add the path to the jre folder to ~/.bashrc (you can use [nano ~/.bashrc] to edit the file) as JAVA_HOME
    - for me [export JAVA_HOME=/usr/lib/jvm/java-8-openjdk-amd64/jre]

-install Apache Spark and set up path
1) download Apache Spark 2.3.2 using [wget http://dk.mirrors.quenda.co/apache/spark/spark-2.3.2/spark-2.3.2-bin-hadoop2.7.tgz]
    - visit https://spark.apache.org/downloads.html for other mirrors and different versions
2) make a directory for Apache Spark
    - I created the directory [sudo mkdir /opt/apache-spark]
3) unzip the downloaded file into the directory
    - for me [tar xvzf spark-2.3.2-bin-hadoop2.7.tgz -C /opt/apache-spark]
4) add the path to the unzipped folder to ~/.bashrc as SPARK_HOME
    - for me [export SPARK_HOME=/opt/apache-spark/spark-2.3.2-bin-hadoop2.7]
5) add java/bin and spark/bin path in ~/.bashrc
    - for me [export PATH=$PATH:$JAVA_HOME/bin:$SPARK_HOME/bin]
6) add python version to be used by pyspark to ~/.bashrc [export PYSPARK_PYTHON=python3]
7) apply changes in ~/.bashrc by runiing the command [source ~/.bashrc]


text:
---
hrs_structure:
  division: '1'
  volume: '7'
  title: '21'
  chapter: '386'
  section: 386-9
type: hrs_section
tags:
  - Government
menu:
  hrs:
    identifier: HRS_0386-0009
    parent: HRS0386
    name: 386-9 Contracting out forbidden
weight: 80055
title: Contracting out forbidden
full_title: 386-9 Contracting out forbidden
---
**§386-9 Contracting out forbidden.** Except as provided in section 386-78, no contract, rule, regulation or device whatsoever shall operate to relieve the employer in whole or in part from any liability created by this chapter. [L 1963, c 116, pt of §1; Supp, §97-9; [HRS §386-9](/title-21/chapter-386/section-386-9/); am L 1969, c 17, §1]

Case Notes

Section preempted by ERISA to the extent it prohibits offsetting workers' compensation payments intended to provide income replacement against pension benefits. 679 F.2d 1319 (1982).

Cited: 23 H. 291, 294 (1916); 31 H. 672, 673 (1930).

repository: SamMade/BlueAndKrabby

repo_name: SamMade/BlueAndKrabby


text:
# WES BOS

So I was hanging out with my friend [Wes Bos](http://wesbos.com/) at [JSConf](http://2013.jsconf.us/) recently. And for some reason, every time I said his name, I added an extra random syllable to both his first and last names. Because it was really the funnest thing. Ever.

For example, "Weston Bosley." Or "Westwood Boswitch." Or "Wesbee Bosshog."

Well, naturally, I had to create a website to celebrate this.

<http://cowboy.github.io/wesbos/>

## Contributing

After cloning, ensure you're on the `master` branch. Then:

1. Run `npm install` to install [Grunt](http://gruntjs.com/) and any required plugins.
1. Run `bower install` to install the client-side dependencies.
1. Run `grunt` to start a live-reloading dev webserver on [localhost:8000](http://localhost:8000/).

When done:

1. Run `grunt prod` to publish everything to `dist` and start a webserver on [localhost:8000](http://localhost:8000/).

When REALLY done:

1. Run `grunt deploy` to publish everything to the `gh-pages` branch, which will be viewable at <http://cowboy.github.io/wesbos/>.

If you have suggestions for more [first and last name suffixes](https://github.com/cowboy/wesbos/blob/master/config/config.json), file a PR and I'll add them in. Just make sure they actually sound cool. Thanks!

repository: leachryanb/wesbos

repo_name: leachryanb/wesbos


text:
---
layout: post
title: "Monte-Carlo Tree Search for Simulation-based Strategy Analysis"
date: 2019-08-04 23:21:00
categories: arXiv_AI
tags: arXiv_AI
author: Alexander Zook, Brent Harrison, Mark O. Riedl
mathjax: true
---

* content
{:toc}

##### Abstract
Games are often designed to shape player behavior in a desired way; however, it can be unclear how design decisions affect the space of behaviors in a game. Designers usually explore this space through human playtesting, which can be time-consuming and of limited effectiveness in exhausting the space of possible behaviors. In this paper, we propose the use of automated planning agents to simulate humans of varying skill levels to generate game playthroughs. Metrics can then be gathered from these playthroughs to evaluate the current game design and identify its potential flaws. We demonstrate this technique in two games: the popular word game Scrabble and a collectible card game of our own design named Cardonomicon. Using these case studies, we show how using simulated agents to model humans of varying skill levels allows us to extract metrics to describe game balance (in the case of Scrabble) and highlight potential design flaws (in the case of Cardonomicon).

##### Abstract (translated by Google)

##### URL
[http://arxiv.org/abs/1908.01423](http://arxiv.org/abs/1908.01423)

##### PDF
[http://arxiv.org/pdf/1908.01423](http://arxiv.org/pdf/1908.01423)


text:
# fhq-server Cookbook Changelog

This file is used to list changes made in each version of the fhq-server.

# Notice

1. For date of version please use `date -R`
2. Please use current format, because it will be used for ppa/debian changelog

## [0.2.21] (?)

- Code refactoring
- Prepare jobs_pool mechanizm
- Integrated light web-server
- Added web-admin sources

## [0.2.20] (Fri, 08 Mar 2019 00:04:42 +0700)

- Code refactoring
- Improved working with lxd

## [0.2.17] (Fri, 30 Nov 2018 00:18:41 +0700)

- Replaced QCryptographicHas to smallsha1 implementation
- Added notification on users quest passed
- Redesign in EmployLeak for using EmployGame
- Implemented addGame by employ with cache
- Renamed methods id to localId for ModelLeak
- Improved ModelGame
- redesign answers in employ leaks
- Fixed send to all by another thread
- Prepare employ for notifies
- Added to event that game was removed
- Added model notification
- Fixed #111 Game remove - must be cleanup logo
- Added list of server developers
- Removed QCode::AppVersion from code
- Added version and handle required params on cli side
- Added first message from server: version
- Changed folder from files/games to public/games
- Fixed #108 Add employ games with check settings for public/files folder icon games
- Prepare employ_games
- Fixed #103 Game update logo must be work by uuid
- Fixed title -> name #105
- Add help func lxd in cli #94
- Added test for upload logo game
- Added test_games
- Implemented load leaks from database on start server to cache
- Redesign leaks_Add
- Removed unused files
- Moved log to utils_logger
- Redesign class error
- Start redesign leaks
- Minor changes in model_leak

## [0.2.16] (Sat, 07 Jul 2018 03:02:13 +0700)

- Fixed crash
- Added leaks handlers
- Added lxd container handlers
- Added generator python lib cli

## [0.2.15] (Fri, 27 Apr 2018 02:02:57 +0700)

- Added postinst script

repository: Sardcaster/fhq-server

repo_name: Sardcaster/fhq-server


text:
# ESBuild Server

A fast dev-server and storybook built with esbuild.

<img src="https://img.shields.io/npm/v/@dxos/esbuild-server"/>

## Getting started

To run the dev server with the examples:

```bash
yarn build

cd examples
../bin/main.js dev
```

To run the storybook within the examples:

```bash
cd examples
../bin/main.js book stories/*.stories.tsx
```

## CLI reference

Run `esbuild-server --help` or `esbuild-server <command> --help` for an always up-to-date CLI reference.

### Running apps and storybooks

```
esbuild-server <command>

Commands:
  esbuild-server build              Build the app for production.
  esbuild-server dev                Start the dev server.
  esbuild-server book [stories...]  Start the dev server with a book of components.

Options:
  --help     Show help                                                 [boolean]
  --version  Show version number                                       [boolean]
```

### Building storybooks

```
esbuild-server book --build [stories...]
```

## Config file

Config is automatically loaded from `./esbuild-server.config.js`.

```typescript
export interface Config {
  /**
   * List of entry points to bundle.
   *
   * Those are then can be requested from the dev server.
   *
   * Read more: https://esbuild.github.io/api/#entry-points
   */
  entryPoints?: string[] | Record<string, string>

  /**
   * Directory to output production build to.
   */
  outdir?: string

  /**
   * Override esapp default settings for esbuild
   */
  overrides?: BuildOptions

  /**
   * Directory with static files to be served by the dev server.
   */
  staticDir?: string

  /**
   * Esbuild plugins: https://esbuild.github.io/plugins/.
   */
  plugins?: Plugin[]
}
```

## Storybook

esbuild-server stories are compatible with storybook format, although only the very minimal features are supported.

To render a storybook run the following command (replacing with your glob for stories).

```
esbuild-server book 'stories/**/*.stories.tsx'
```

Each story file should export a set of components and optionally a default export with the title that will be displayed in the outline.

## Development

Use `yarn link` and `yarn build --watch` to use the development build of this project from another package.

## Polyfills

Currently esbuild-server does not polyfill any of the node.js modules or globals.
If your code is using them you'd need to manually include a plugin to add them.

repository: WestonSeyler/esbuild-server

repo_name: WestonSeyler/esbuild-server


text:
# frozen-berry-yogurt-syntax theme

An outrun/synthwave inspired theme meant to be easy on the eyes and to preserve the feel of One Dark syntax theme.

### Screenshots

### Supported languages
* CSS / Less / SASS / SCSS
* Docker
* Github Markdown
* Javascript
* Python
* React / JSX

If you'd like to have support for another language, please open an issue.

repository: giuband/frozen-berry-yogurt-syntax

repo_name: giuband/frozen-berry-yogurt-syntax


text:
---
layout: page
weight: 0
title: Automated Email
navigation:
  show: false
seo:
  title: Automated Email
  override: true
  description: Automated Email allows you to dynamically send relevant content to individual recipients.
  keywords: triggered email, automated email, Threads, behavior-driven email
---

Automated email, also known as [triggered email]({{root_url}}/Glossary/triggered_email.html) or behavior-driven email, is sent when a specific [triggering event]({{root_url}}/Glossary/triggering_events.html) occurs or a specific user takes an action that prompts the delivery of the email. While traditional [marketing email]({{root_url}}/Glossary/Email_Types/index.html) involves sender-initiated promotional messages sent to a list of recipients, automated email is initiated by user behavior, allowing you to dynamically send targeted, real-time promotional content that is uniquely relevant to an individual recipient.

Examples of email automation include a welcome series [drip campaign]({{root_url}}/Glossary/drip_campaign.html) that is initiated by a new user sign-up or a win-back campaign to re-engage a lapsed user.

The ability to send very relevant, timely emails directed to individual recipients makes automated email a uniquely powerful tool for building and nurturing customer relationships, enhancing the image of your brand, and increasing customer engagement.

You can use SendGrid’s automated, behavior driven email platform, [Threads](http://threads.io/), to track individual users and the actions that they take when interacting with your application or website. This information can then be used to dynamically create and send automated email.

{% info %}
Visit the [Threads Support Page](https://support.threads.io/hc/en-us) to learn more about how you can integrate Threads with your SendGrid account.
{% endinfo %}

repository: mopinion/docs

gha_language: HTML

repo_name: mopinion/docs