text:
The [RemoteSignal](https://github.com/Sleitnick/Knit/blob/main/src/Util/Remote/RemoteSignal.lua) module wraps the RemoteEvent object and is typically used within services. The only time a developer should ever have to instantiate a RemoteSignal is within the `Client` table of a service. For use on the client, see ClientRemoteSignal.

```lua
local remoteSignal = RemoteSignal.new()

remoteSignal:Fire(player, ...)
remoteSignal:FireExcept(player, ...)
remoteSignal:FireAll(...)
remoteSignal:Wait()
remoteSignal:Destroy()

local connection = remoteSignal:Connect(functionHandler(player, ...))
connection:IsConnected()
connection:Disconnect()
```

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

## [ClientRemoteSignal](https://github.com/Sleitnick/Knit/blob/main/src/Util/Remote/ClientRemoteSignal.lua)

The [ClientRemoteSignal](https://github.com/Sleitnick/Knit/blob/main/src/Util/Remote/ClientRemoteSignal.lua) module wraps the RemoteEvent object and is typically used within services. Usually, ClientRemoteSignals are created behind-the-scenes and don't need to be instantiated by developers. However, it is available for developers in case custom workflows are being used.

```lua
local remoteSignal = ClientRemoteSignal.new(remoteEventObject)

remoteSignal:Fire(...)
remoteSignal:Wait()
remoteSignal:Destroy()

local connection = remoteSignal:Connect(functionHandler(...))
connection:IsConnected()
connection:Disconnect()
```

repository: DeltaRager/Knit

repo_name: DeltaRager/Knit


text:
---
title: Docpress
repo: docpress/docpress
homepage: http://docpress.github.io
language:
  - JavaScript
license:
  - MIT
templates:
  - Markdown
description: Painless Markdown publishing
---

Docpress generates websites from your project's basic documentation; that is, at the very least, a README.md file.
It also supports multiple Markdown pages in `docs/`. Checkout our [Homepage](http://docpress.github.io) for a quick example.

## Examples

Check out the [Docpress Showcase](https://github.com/docpress/docpress/blob/master/docs/showcase.md) to see how Docpress helped developers build great-looking websites.

## Usage

Still under heavy development, consider this a preview.
See the [Getting Started](http://docpress.github.io/getting-started/quickstart.html) guide for more details.

```sh
$ npm install -g docpress
$ echo "# My project" > README.md
$ echo "Documented by Markdown files." >> README.md
$ docpress serve

  Docpress
  starting development - ^C to exit

  350ms ✓   first build
      on    watching changes
      on    livereload
      on    http://localhost:3000

  Running
```

## Screenshot

![Screenshot](https://i.imgur.com/eSXOeVw.png)

## Support

- [Documentation](http://docpress.github.io/)
- [Gitter chat](https://gitter.im/docpress/Lobby)

Let's build our first Docpress site.
[Quickstart guide →](http://docpress.github.io/getting-started/quickstart.html)

## Thanks

**docpress** © 2015+, Rico Sta. Cruz. Released under the [MIT] License.<br>
Authored and maintained by Rico Sta. Cruz with help from contributors ([list][contributors]).

> [ricostacruz.com](http://ricostacruz.com)  ·
> GitHub [@rstacruz](https://github.com/rstacruz)  ·
> Twitter [@rstacruz](https://twitter.com/rstacruz)

[mit]: http://mit-license.org/
[contributors]: http://github.com/rstacruz/docpress/contributors

license: MIT

branch_name: refs/heads/master

extension: md

gha_license_id: MIT

license_type: permissive


text:
# Deploy Cloud Foundry

>**NOTE:** All the following commands must be run in your dev-box.

1. Upload stemcell

  Get the value of **resource_pools.name[vms].stemcell.url** in [**bosh.yml**](https://github.com/Azure/azure-quickstart-templates/blob/master/bosh-setup/bosh.yml), then use it to replace **STEMCELL-FOR-AZURE-URL** in below command:

  ```
  bosh upload stemcell STEMCELL-FOR-AZURE-URL
  ```

2. Upload Cloud Foundry release v224

  ```
  bosh upload release https://bosh.io/d/github.com/cloudfoundry/cf-release?v=224
  ```

  >**NOTE:** If you want to use the latest Cloud Foundry version, the Azure part in the manifest is same but other configurations may be different. You need to change them manually.

3. Deploy

  ```
  bosh deployment YOUR-MANIFEST-FOR-CLOUD-FOUNDRY # cf_224.yml
  bosh deploy
  ```

>**NOTE:**
  * If you hit any issue, please see [**troubleshooting**](./troubleshooting.md), [**known issues**](./known-issues.md) and [**migration**](./migration.md). If it does not work, you can file an issue [**HERE**](https://github.com/cloudfoundry-incubator/bosh-azure-cpi-release/issues).

repository: haydonryan/bosh-azure-cpi-release

repo_name: haydonryan/bosh-azure-cpi-release


text:
# TemperatureReader
Temperature reader for the DS18B20

## Features
- Read from multiple DS18B20 on a single line (OneWire)
- Scan for devices dynamically
- Read temperature
- Read id

## Dependencies
- https://github.com/PaulStoffregen/OneWire

## Hookup
The example uses a DS18B20 powered by 5v and 4,7K pullup resistor between Vcc and the data pin. The data pin is connected to pin 2 on the Arduino.

repository: palsivertsen/TemperatureReader

repo_name: palsivertsen/TemperatureReader


text:
# vlt.math.phase_advance

```
   PHASE_ADVANCE - Computes phase advance from a list of angles

    ADV = vlt.math.phase_advance(ANGLES)

   Computes the advance in phase from each angle, assuming an angle does not
   advance more than pi.

```

repository: VH-Lab/vhlab-toolbox-matlab

gha_language: MATLAB

repo_name: VH-Lab/vhlab-toolbox-matlab


text:
---
published: false
title: i19
layout: post
author: Yu
categories: v08
hidden: true
---

| 项目 | 具体内容 | 链接 |
|---:|---|---|
| 作者 | Duncan Murdoch| |
| 题目 |Orientlib: An R Package for Orientation Data | [下载地址](http://www.jstatsoft.org/v08/i19/paper) |
| 参考资料 |Vol. 8, Issue 19, Dec 2003 | |
| | 提交日期 2003-07-08, 接收日期 2003-12-12| |
| 类别 | 论文| |
| 摘要 | Orientlib is an R package to facilitate working with orientation data, i.e. elements of S O(3). It provides automatic translation between different representations of orientations, including rotation matrices, quaternions, Euler angles and skew-symmetric matrices; it also has functions for fitting regression models and displaying orientations.  This paper reviews simple properties of orientation data and describes Orientlib.| |
| 论文 | Orientlib: An R Package for Orientation Data  (application/pdf, 216.7 KB)| [下载地址](http://www.jstatsoft.org/v08/i19/paper) |
| 补充材料 | | |
| |orientlib_0.7.tar.gz: R软件包源代码  (application/x-gzip, 189.9 KB)|  [下载地址](http://www.jstatsoft.org/v08/i19/supp/1) |
| 资源 | [BibTeX](http://www.jstatsoft.org/v08/i19/bibtex) [OAI](http://www.jstatsoft.org/oai?verb=GetRecord&identifier=oai.jstatsoft/v08/i19&prefix=oai_dc)| |
| |  | [返回卷目录]({{site.baseurl}}/volume/v08.html) |

repository: yulijia/jstatsoft

repo_name: yulijia/jstatsoft


text:
# Contributors

# Reporting issues
* Describe (in detail) what should have happened. Include any supporting information (stack traces, errors, etc)
* Include any steps to replicate the issue
* Indicate OS and Python versions

# Development environment setup
1. Clone repository:
```
git clone https://github.com/mitre/caldera.git --recursive
```

2. Create a virtualenv:
```
python3 -m venv venv
. venv/bin/activate
```

3. Install dependencies:
```
pip install -r requirements.txt -r requirements-dev.txt
```

4. Install the pre-commit hooks:
```
pre-commit install --install-hooks
```

# Developing
We use the basic feature branch GIT flow. Fork this repository and create a feature branch off of master and when ready, submit a merge request. Make branch names and commits descriptive. A merge request should solve one problem, not many.

* Tests should cover any code changes that you have made. The test that you write should fail without your patch.
* [Run tests](#run-the-tests)

# Run the tests
Tests can be run by executing:
```
python -m pytest
```
This will run all unit tests in your current development environment. Depending on the level of the change, you might need to run the test suite on various versions of Python. The unit testing pipeline will run the entire suite across multiple Python versions that we support when you submit your PR.

We utilize `tox` to test CALDERA in multiple versions of Python. This will only run if the interpreter is present on your system. To run tox, execute:
```
tox
```

# Code Coverage
You can generate code coverage reports manually or by running `tox`. To run them manually, you must have `coverage` installed and run the following commands:
```
coverage run -m pytest
coverage report
coverage html
```
You can find the code coverage report in `htmlcov/index.html`

repository: mitre/caldera

gha_language: Python

repo_name: mitre/caldera


text:
# Changelog

All notable changes to [`@bpmn-io/bpmn-properties-panel`](https://github.com/bpmn-io/bpmn-properties-panel) are documented here. We use [semantic versioning](http://semver.org/) for releases.

## Unreleased

___Note:__ Yet to be released changes appear here._

## 0.3.0

* `FEAT`: Implemented Camunda Platform Properties Provider ([#2](https://github.com/bpmn-io/bpmn-properties-panel/issues/2))
* `FEAT`: Support message throw and End Event in Zeebe Provider ([#114](https://github.com/bpmn-io/bpmn-properties-panel/pull/114))
* `DEPS`: bump to<EMAIL_ADDRESS>* `DEPS`: bump to<EMAIL_ADDRESS>* `DEPS`: bump to `<EMAIL_ADDRESS>
## 0.2.0

* `FIX`: prevent auto focus list behavior when switching elements ([#65](https://github.com/bpmn-io/bpmn-properties-panel/issues/65))
* `FIX`: use correct icon for signal boundary event ([#72](https://github.com/bpmn-io/bpmn-properties-panel/issues/72))
* `CHORE`: cleanup structure of BPMN properties provider ([`1a1f43ce`](https://github.com/bpmn-io/bpmn-properties-panel/commit/1a1f43ceb48a7d877511d73465693cb2719dd3ca))
* `CHORE`: update list item ids to be unique per element ([#63](https://github.com/bpmn-io/bpmn-properties-panel/pull/63))
* `CHORE`: remove unnecessary button classes ([#74](https://github.com/bpmn-io/bpmn-properties-panel/pull/74))
* `CHORE`: bump to `<EMAIL_ADDRESS>
## 0.1.1

* `FIX`: deduplicate preact dependencies during testing ([#29](https://github.com/bpmn-io/bpmn-properties-panel/pull/29))
* `FIX`: decouple `attachTo` and `render` ([#40](https://github.com/bpmn-io/bpmn-properties-panel/pull/40))
* `CHORE`: bump to `<EMAIL_ADDRESS>
## 0.1.0

* `FEAT`: initial version :tada:

repository: LinboZhao/bpmn-properties-panel

branch_name: refs/heads/main

repo_name: LinboZhao/bpmn-properties-panel


text:
# Ceratocystis nigra R.W. Davidson, 1959 SPECIES

#### Status
SYNONYM

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

#### Published in
Mycologia 50(5): 662 (1958)

#### Original name
Ceratocystis nigra R.W. Davidson, 1959

### Remarks
null

repository: mdoering/backbone

path: /life/Fungi/Ascomycota/Sordariomycetes/Ophiostomatales/Ophiostomataceae/Ophiostoma/Ophiostoma nigrum/ Syn. Ceratocystis nigra/README.md

repo_name: mdoering/backbone


text:
# Syntax Guide

`intl-codegen` supports both `fluent` and `MessageFormat`.

## Fluent

Please see the official [fluent guide](https://projectfluent.org/fluent/guide/)
as well as the [fluent playground](https://projectfluent.org/play/).

Currently, `intl-codegen` does _not_ support `attributes`, `terms` and
message references.

## MessageFormat

There are some [guides](https://formatjs.io/guides/message-syntax/) for the
MessageFormat syntax out there.

Currently, `intl-codegen` does _not_ support plural offset and the special `#`
placeholder inside plurals.

repository: eversport/intl-codegen

gha_language: TypeScript

repo_name: eversport/intl-codegen


text:
# Changelog

All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.

## [8.0.0](https://github.com/itgalaxy/robotstxt-webpack-plugin/compare/v7.0.0...v8.0.0) (2022-08-29)

### ⚠ BREAKING CHANGES

* minimum supported webpack version is `5`
* minimum supported Node.js version is `14.15.0`

### Bug Fixes

* compatibility with webpack v5 ([#131](https://github.com/itgalaxy/robotstxt-webpack-plugin/issues/131)) ([ee22312](https://github.com/itgalaxy/robotstxt-webpack-plugin/commit/ee22312daad1f0f24e2cd390943721bec49151cf))

## 7.0.0 - 2019-11-05

- Changed: minimum require Node.js version is `10.13.0`.

## 6.0.0 - 2019-07-03

- Changed: use `additionalAssets` hook for adding assets.
- Changed: minimum require Node.js version is `8.9.0`.

## 5.0.0 - 2019-01-09

### BREAKING CHANGE

- Feature: rename `RobotstxtWebpackPlugin` to `RobotstxtPlugin`.
- Feature: exports plugin as `cjs` by default (no need use `default` for `require` in `webpack.config.js`).
- Chore: minimum require `webpack` version is `4`.
- Chore: minimum require `nodejs` version is `6`.

## 4.0.1 - 2018-02-26

- Fixed: `tapable` deprecation warnings (`webpack >= v4.0.0`).

## 4.0.0 - 2017-11-15

- Chore **Breaking Changes**: minimum required `generate-robotstxt` version is
  now `^5.0.0`.

## 3.0.2 - 2017-10-10

- Chore: republish new version, because old was break.

## 3.0.1 - 2017-10-10

- Chore: republish new version, because old was break.

## 3.0.0 - 2017-10-09

- Changed: rename from `dest` to `filePath`.
- Changed: `dest` should contain file name (example - `/path/to/robots.txt`).

## 2.0.0 - 2017-06-20

- Chore: support `webpack` v3.
- Changed: minimum require `nodejs` version is now `4.3`.

## 1.0.1 - 2017-02-01

- Fixed: added `webpack` as peer dependencies.

## 1.0.0 - 2016-11-11

- Documentation: improve `README.md`.

## 1.0.0-alpha.1 - 2016-11-11

- Chore: initial public release.

repository: itgalaxy/robotstxt-webpack-plugin

gha_language: JavaScript

repo_name: itgalaxy/robotstxt-webpack-plugin


text:
# jupyter-deployment

To rebuild the instance image, re-run the ansible playbook against a fresh instance (tested with Ubuntu 18.04 LTS (gcp: `ubuntu-1804-lts`)).

First place the IP address of the instance into `inventory.ini`, and set the user of the ssh key used to authenticate to the instance.

Next pick something you want to use as the jupyter notebook token.  This should be something secure, difficult to guess, because jupyter available on the network enable trivial remote arbitrary code execution.  One way to generate a random token is:
```
$ head -c 24 /dev/urandom | base64
```

Then run the playbook:

```
$ ansible-playbook -i inventory.ini playbook.yaml
```

This playbook does a series of high level steps:
- installs jupyter and R
- installs the R jupyter kernel
- installs nginx, and port 443 host block, and creates a self-signed cert
- installs systemd service files for autostarting the jupyter server

Notes:
- The instance should have at least 1GiB of free space.
- Jupyter notebooks vary in resource demands. Those doing multi-threaded compute should choose an appropriate instance with more CPUs. Many notebooks are more query based and single-threaded, so more memory makes more sense for the instance type. Recommended resources: >= 1 vcpu, >= 4GB mem, >= 20GB disk.


text:
---
description: This template allows you to create a Logic app triggers on files in an FTP server and copies them to an Azure Blob container. You can add an additional triggers or actions to customize it to your needs.
page_type: sample
products:
- azure
- azure-resource-manager
urlFragment: logic-app-ftp-to-blob
languages:
- bicep
- json
---
# Copy FTP files to Azure Blob logic app

![Azure Public Test Date](https://azurequickstartsservice.blob.core.windows.net/badges/quickstarts/microsoft.logic/logic-app-ftp-to-blob/PublicLastTestDate.svg)
![Azure Public Test Result](https://azurequickstartsservice.blob.core.windows.net/badges/quickstarts/microsoft.logic/logic-app-ftp-to-blob/PublicDeployment.svg)

![Azure US Gov Last Test Date](https://azurequickstartsservice.blob.core.windows.net/badges/quickstarts/microsoft.logic/logic-app-ftp-to-blob/FairfaxLastTestDate.svg)
![Azure US Gov Last Test Result](https://azurequickstartsservice.blob.core.windows.net/badges/quickstarts/microsoft.logic/logic-app-ftp-to-blob/FairfaxDeployment.svg)

![Best Practice Check](https://azurequickstartsservice.blob.core.windows.net/badges/quickstarts/microsoft.logic/logic-app-ftp-to-blob/BestPracticeResult.svg)
![Cred Scan Check](https://azurequickstartsservice.blob.core.windows.net/badges/quickstarts/microsoft.logic/logic-app-ftp-to-blob/CredScanResult.svg)

![Bicep Version](https://azurequickstartsservice.blob.core.windows.net/badges/quickstarts/microsoft.logic/logic-app-ftp-to-blob/BicepVersion.svg)

[![Deploy To Azure](https://raw.githubusercontent.com/Azure/azure-quickstart-templates/master/1-CONTRIBUTION-GUIDE/images/deploytoazure.svg?sanitize=true)](https://portal.azure.com/#create/Microsoft.Template/uri/https%3A%2F%2Fraw.githubusercontent.com%2FAzure%2Fazure-quickstart-templates%2Fmaster%2Fquickstarts%2Fmicrosoft.logic%2Flogic-app-ftp-to-blob%2Fazuredeploy.json)
[![Deploy To Azure US Gov](https://raw.githubusercontent.com/Azure/azure-quickstart-templates/master/1-CONTRIBUTION-GUIDE/images/deploytoazuregov.svg?sanitize=true)](https://portal.azure.us/#create/Microsoft.Template/uri/https%3A%2F%2Fraw.githubusercontent.com%2FAzure%2Fazure-quickstart-templates%2Fmaster%2Fquickstarts%2Fmicrosoft.logic%2Flogic-app-ftp-to-blob%2Fazuredeploy.json)
[![Visualize](https://raw.githubusercontent.com/Azure/azure-quickstart-templates/master/1-CONTRIBUTION-GUIDE/images/visualizebutton.svg?sanitize=true)](http://armviz.io/#/?load=https%3A%2F%2Fraw.githubusercontent.com%2FAzure%2Fazure-quickstart-templates%2Fmaster%2Fquickstarts%2Fmicrosoft.logic%2Flogic-app-ftp-to-blob%2Fazuredeploy.json)

This template allows you to create a Logic app that listens to a folder on an FTP server and will copy it to an Azure Blob container. You can add an additional triggers or actions to customize it to your needs.

Azure Logic Apps is a cloud service that automates the execution of your business processes. You use a graphical design tool called the Logic Apps Designer to arrange pre-made components into the sequence you need. The Designer sends a definition of your workflow to the Logic Apps execution engine. The execution engine launches your app when conditions are right and manages the compute resources needed to run it.

- [Microsoft Logic Apps](https://azure.microsoft.com/services/logic-apps/)
- [Microsoft Logic Apps Documentation](https://docs.microsoft.com/azure/logic-apps/)
- [Microsoft Learn Logic App Modules](https://docs.microsoft.com/learn/browse/?term=logic%20app)
- [Microsoft Learn Logic App Module - building workflow](https://docs.microsoft.com/learn/paths/build-workflows-with-logic-apps/)

`Tags: Microsoft.Web/connections, Microsoft.Logic/workflows, ApiConnection`

repository: Azure/azure-quickstart-templates

gha_language: Bicep

repo_name: Azure/azure-quickstart-templates


text:
# Shimmer

Asset pipeline gem for generating shimmer font for icons in Sparkle CMS.

Add new svgs to `src/icons/` and run `rake font:prepare` to build the font.

## Installation

Add this line to your application's Gemfile:

    gem 'shimmer'

And then execute:

    $ bundle

Or install it yourself as:

    $ gem install shimmer

## Usage

Dependencies are fontforge, eot-utils, ttfautohint, xquartz, and svgo.

To install:

* `brew install fontforge --with-python
* `brew install eot-utils`
* `npm install -g svgo`
* `bundle install`

Configuration is in `fontcustom.yml`

## Adding new Icons
1. Add the SVG to the `src/icons` directory.
2. Run `rake font:prepare`
3. Bump gem version by one point in `lib/shimmer/version.rb`
4. Commit and push to Github
5. Update the `shimmer` gem in your target repo `bundle update shimmer`

*Tip*: Preview the generated font by opening
`src/shimmer-preview.html`

## Sketch Templates

Use `src/icon-template.sketch` for layout out icons. Guides equate to
cap-height, x-height, and baseline. Centring icons within these guides will help
them to appear centred beside any text with the same line height and font size.

repository: matthewlehner/shimmer

repo_name: matthewlehner/shimmer


text:
---
layout: post
title: Back testing with Backtrader
tags: Machine Learning, Investment, Backtesting, Portfolio Management, Technical Analysis, Technical Indicator
---

![header](https://cdn-images-1.medium.com/max/1600/0*8l5ftTfMjM03HzEH)

In one of my [older post](https://kylelix7.github.io/Trading-Strategy-Technical-Analysis-with-Python-TA-Lib/), I demonstrates how to compute technical indicators which can be combined logically to build a trading strategy. As emphasized in the post, one should validate how well the strategy does with backtesting before applying it in real market.

> Backtesting is the process of applying a trading strategy or analytical method to historical data to see how accurately the strategy or method would have predicted actual results. - from [investing answers](https://investinganswers.com/financial-dictionary/stock-market/backtesting-865)

Backtest is like cross validation in machine learning. But it’s not exactly the same. Backtest requires splitting data into two parts like cross validation. One set is for training, the other is for validation purpose. The difference is training testing split can be randomly done for cross validation. While in trading backtesting, your data is time series. Your training data must be older than your testing data. Otherwise you peek in future which results in incorrect measurement of your strategy. So dataset split cannot be random in backtesting. Backtesting involves market simulation in real world. It could be hard and error-prone to implement your own backtesting libraries. Luckily there’s Backtrader.

[Backtrader](https://www.backtrader.com/) is an awesome open source python framework which allows you to focus on writing reusable trading strategies, indicators and analyzers instead of having to spend time building infrastructure. It supports backtesting for you to evaluate the strategy you come up with too!

With that being said, it is a free and complete solution for technical people to build their own strategies. Let’s start to have a glance.

# Setup
```
pip install backtrader[plotting]
```

# Build a strategy
Backtrader has defined a [strategy](https://www.backtrader.com/docu/strategy.html) interface for you. You need to create a class with implement this interface. An important method is next() where you should make decision whether you should BUY, SELL or DO NOTHING based on the technical indicators in a specific day. A simple strategy looks like this.

```
import backtrader as bt
class MyStrategy(bt.Strategy):

    def __init__(self):
        self.sma = bt.indicators.SimpleMovingAverage(period=15)

    def next(self):
        if self.sma > self.data.close:
            # Do something
            pass

        elif self.sma < self.data.close:
            # Do something else
            pass
```

As you can see, backtrader has shipped with a set of common technical indicators. It means you don’t need to reply on your self or TA lib to compute technical indicators.

Backtrader also offers features in simulating trading in the marking. Once can factor the commission in your trading operation based on dollar or percentage.

```
cerebro.broker.setcommission(commission=0.001)
```

Below is the whole example for demonstration of backtesting with Facebook historical market data. Note that, historical trading data is downloaded from [Yahoo Finance](https://finance.yahoo.com/quote/FB/history?p=FB&.tsrc=fin-srch-v1). It also supports pandas dataframe. I have a<EMAIL_ADDRESS>about collecting trading data with pandas here. The example consists of a simple TestStrategy and a driver piece of code that kick of the backtesting. The simple strategy only considers RSI for BUY/SELL signal. You should add more logics for your selected stocks.

```python
from __future__ import (absolute_import, division, print_function,
                        unicode_literals)

import datetime
import os.path
import sys
import backtrader as bt

class TestStrategy(bt.Strategy):
    def log(self, txt, dt=None):
        dt = dt or self.datas[0].datetime.date(0)
        print('%s, %s' % (dt.isoformat(), txt))

    def __init__(self):
        self.dataclose = self.datas[0].close
        self.order = None
        self.buyprice = None
        self.buycomm = None

        self.sma = bt.indicators.SimpleMovingAverage(self.datas[0], period=15)
        self.rsi = bt.indicators.RelativeStrengthIndex()

    def notify_order(self, order):
        if order.status in [order.Submitted, order.Accepted]:
            return

        if order.status in [order.Completed]:
            if order.isbuy():
                self.log(
                    'BUY EXECUTED, Price: %.2f, Cost: %.2f, Comm %.2f' %
                    (order.executed.price,
                     order.executed.value,
                     order.executed.comm))

                self.buyprice = order.executed.price
                self.buycomm = order.executed.comm
            else:  # Sell
                self.log('SELL EXECUTED, Price: %.2f, Cost: %.2f, Comm %.2f' %
                         (order.executed.price,
                          order.executed.value,
                          order.executed.comm))

            self.bar_executed = len(self)

        elif order.status in [order.Canceled, order.Margin, order.Rejected]:
            self.log('Order Canceled/Margin/Rejected')

        # Write down: no pending order
        self.order = None

    def notify_trade(self, trade):
        if not trade.isclosed:
            return

        self.log('OPERATION PROFIT, GROSS %.2f, NET %.2f' %
                 (trade.pnl, trade.pnlcomm))

    def next(self):
        self.log('Close, %.2f' % self.dataclose[0])
        print('rsi:', self.rsi[0])
        if self.order:
            return

        if not self.position:
            if (self.rsi[0] < 30):
                self.log('BUY CREATE, %.2f' % self.dataclose[0])
                self.order = self.buy(size=500)

        else:
            if (self.rsi[0] > 70):
                self.log('SELL CREATE, %.2f' % self.dataclose[0])
                self.order = self.sell(size=500)

if __name__ == '__main__':
    cerebro = bt.Cerebro()
    cerebro.addstrategy(TestStrategy)
    cerebro.broker.setcommission(commission=0.001)

    datapath = 'FB.csv'

    # Create a Data Feed
    data = bt.feeds.YahooFinanceCSVData(
        dataname=datapath,
        fromdate=datetime.datetime(2013, 1, 1),
        todate=datetime.datetime(2018, 8, 5),
        reverse=True)

    cerebro.adddata(data)
    cerebro.broker.setcash(100000.0)
    print('Starting Portfolio Value: %.2f' % cerebro.broker.getvalue())
    cerebro.run()
    print('Final Portfolio Value: %.2f' % cerebro.broker.getvalue())
    cerebro.plot()
```

At the end of execution, you can find out your final value of portfolio. As well, you are able to plot the stock price, technical indicators, your BUY/SELL operations and your portfolio value with regard to the time.

![alt](https://cdn-images-1.medium.com/max/1600/1*2sahspHlViQ38jnH5eaBvA.png)

As you can see, this simple strategy works ok with FB as it captures a few buy and sell opportunities.

That’s it for backtesting with backtrader. If you would like to learn more about Machine Learning there is [a helpful series of courses in educative.io](https://www.educative.io/profile/view/6083138522447872?aff=VEzk). These courses cover topics like basic ML, NLP, Image Recognition etc. Happy coding and trading!

path: /_posts/2019-03-10-Back testing with Backtrader.md


text:
Bunurong Marine National Park Field Guide - Android
===========================================================

A [Field Guide](http://museumvictoria.com.au/discoverycentre/mv-bunurong-app/) specifically built for the Bunurong Marine National Park showcasing the area and its rich biodiversity. Code based on the Museum Victoria's Field Guide for Victorian Fauna.

[![Google Play](http://developer.android.com/images/brand/en_generic_rgb_wo_45.png)](https://play.google.com/store/apps/details?id=au.com.museumvictoria.fieldguide.bunurong)

## Data

Biodiversity data, specifically images, have been removed from the repository due to copyright agreements. Sample data is available for a quick build/test.

## Acknowledgements

This project uses open source libraries such as:
* [ActionBarSherlock](https://github.com/JakeWharton/ActionBarSherlock)
* [Gson](http://code.google.com/p/google-gson/)
* [ImageViewZoom](https://github.com/sephiroth74/ImageViewZoom)
* [Google Play Distribution Libraries](http://developer.android.com/google/play/dist.html)

## Licence

	The MIT License (MIT)

	Copyright (c) 2013 Museum Victoria

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

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

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


text:
# Changelog

All notable changes to `ping` will be documented in this file

## 2.1.3 - 2021-12-04

Small fixes:

- Fixed ping:install command, now when ping configuration is published the ping:install is not displayed.

Small refactoring

## 2.1.2 - 2021-11-28

Small fixes:

- Removed ending slash on url hosts.
- Sanitized ping command execution results.

## 2.1.1 - 2021-02-07

Small fixes:

- An error in the README.md file has been corrected.
- Fixed a bug when parsing the result of a ping to an unreachable host.

## 2.1.0 - 2021-01-01

Added package install command, now you can do:

```bash
php artisan ping:install
```

To publish the package configuration file.

## 2.0.0 - 2020-08-09

In this version there are important changes, because I have rewritten the class, adding a class to generate the ping commands. With this class you can also create commands for IPv4 and IPv6 addresses, and it allows you to ping domain names.

- The System.php class has been added to detect the type of Operating System.
- The IPAddress.php class has been added to perform the verification and validation of IPv4 and IPv6 addresses.
- Exceptions have been added for error handling.

In this version, an instance of PingCommandBuilder has to be created and passed to the Ping class, then execute the run method of the Ping class to obtain an object with the results.

## 1.0.0 - 2020-04-13

- Added support for Windows based servers, now it's possible to do PING on Linux/Windows based servers...

## 0.0.1 - 2020-04-12

- initial release

repository: angelcamposm/ping

gha_language: PHP

repo_name: angelcamposm/ping


text:
# NoopPublisher

This is the simplest of the publishers and it does nothing. It's simply there as a base demonstration to implement new publishers.

## Configuration

```class```: Class name implementing the publisher.

```"class": "iotconnect.publishers.noop.NoopPublisher"```

Sample config:
```
{
    "class": "iotconnect.publishers.noop.NoopPublisher"
 }
```

repository: swipswaps/IOTConnect

repo_name: swipswaps/IOTConnect


text:
# Grad Samples
An integral part of Opacus is to compute per-sample gradients. In order to make this computation as fast as possible, we provide vectorized code for each of the most common "basic modules" that are the building blocks of most ML models. If your model uses these building blocks, then you don't have to do anything!

We always welcome PRs to add nn.Modules we don't yet support, but we also support registering custom grad_sample functions that can expand support just for your project, or even override Opacus's default implementations if they don't suit your needs.

Override as following:

```python
from opacus.grad_sample import register_grad_sampler

@register_grad_sampler(nn.MyCustomClass)
def compute_grad_sample(module, activations, backprops):
    pass
```

Note that you can also pass a list to the decorator, and register one function against multiple nn.Module classes.

repository: oberqi/opacus

repo_name: oberqi/opacus


text:
---
title: Community Update from the Learning Team
author: The Ember Learning Team
tags: Recent Posts, Learning, Marketing, Roadmap, Community, 2018
responsive: true
---

Each Ember team meets in person at EmberConf. For many of us, it was our first chance to sit down in person and plan together! This is important for us because it allows us spend an entire day getting to know each other and plan for the upcoming year.

In order to keep the community updated while we move initiatives forward, we'd like to share with you the major outcomes from our face to face meeting. The learning team (and friends!) spent the day reviewing our current workload, extracting all of the ideas from `@locks`' brain, and reviewing priorities for the upcoming year.

## Goals

We had a few goals for the day:

- craft a mission statement
- identify all of the initiatives that were in the scope of the learning team
- put all of the initiatives into categories
- prioritize the categories

We were able to identify categories of work that naturally fell in to one of two directions - user support and marketing. Here are some of of those categories, with initiatives for each:

### User Support

- Guides
- API Docs (version support, modules API, Broccoli)
- Tutorials (101 Quickstart, 201 Contacts, 301 Super Rentals)
- Infrastructure (subdomains, Ember-izing the website)
- Internal Evangelism (office hours, mentoring, simplify contribution process)
- Tooling and Maintenance (Inspector, Language Servers, Twiddle)

### Marketing

- Website ("devsign", upgrades & maintenance)
- External Evangelism (tech group outreach, podcast & blog collaboration)
- Traditional Marketing (Blog, Ember Doctrine, Why Ember, Testimonials)

There's more to this list, but we hope this gives everyone a good idea of the direction we are heading. The Ember Learning Team meets every Thursday at 1pm EST. Meeting details are in the topic of the [#team-learning channel](https://embercommunity.slack.com/messages/C04KG57CF/) on Slack - we invite you to join us!

gha_license_id: NOASSERTION


text:
README COVID19excel

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

 DISCLAIMER

  This has been slapped together pretty quickly and I make no guarantees of accuracy
  nor fitness for any commercial or medical purposes. I am not and have never been
  an epedemiologist - this is purely a recreational mathematical investigation of
  whether a simple mathematical logistic equation model is a better way to represent
  the COVID19 pandemic and see where it is going.

  In the early days of an epidemic, it is clear that the limit (asymptote)
  to the logistic growth is changing (increasing) day by day. Evidence has been collected
  in the workbook of this.

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

  An excel workbook with macros that get latest confirmed cases time series from John Hopkins
  Github

  loads into the worksheet name as per gcsSeriesConf

    JH data has one column per date, and an increasing number of rows
     per country or state with reported cases...

     need to process this into a time series running down the worksheet
     one row per date...

    there are two ways this is done.

	1) The Initial Approach

	 a) tblData

	 the initial approach uses a table named tblData (an excel listobject) on
	 worksheet myData which supports automated solver calculation of logistic equation
	 fits to the data.

    myData worksheet has a large number of named ranges and a table named tblData. For
	each country implemented, there is a set of columns and named ranges created. This
	has now been automated in the AddNewCountry macro.

    tblData has 1 row per day of data

	there are numerous charts in separate sheets, one per country
    as its not easy to rearrange excel tables (listobjects) columns,
    without damaging formulas that depend on them,
    the columns might see haphazard in order

    tblData has some columns to the right on NSW test data that is
     not available in the JH datafeed. In first versions, these were
	 manually fed in on a daily basis. Later, a macro DailyNSWHealth
	 was created to scrape the NSW testing and local transmission cases
	 from the NSW Health website.

    The JH data is often not the latest available. The loading
    macro process will not overwrite any manually entered value that is
    larger than that read from JH.

    the myData worksheet has a large set of named ranges, and in particular
    dynamic named ranges that will expand as the rows of data accumulate.

	b) tblRuns

     in addition to tblData, there is a table tblRuns to the right which is
     also a listobject, consisting o a list of the parameters that the Solver process
     is estimating, and used in the logistic equation output (referred to in the
	 relevant country columns of tblData)

	 tblRuns has one row per country (or state in case of NSW). There are also
	 two non-standard rows Tests, for estimating growth in testing in NSW
	 and NSWUnknowns for tracking progression of the number of local known
	 and local unknown confirmed cases. Neither of these were published by
	 other states, and became available at later dates of the outbreak.

	 c) Generic Country

	 There are a set of defined names that allow any country to be selected
	 for retrieval into "Generic" columns of tblData, supported by special
	 generic row in tblRuns. There needs to be an entry made for the country
	 in tblPopulation (to give the population etc).

	 The names are

	 GenCountry 	= set this to the required country (eg. Ireland)
	 GenState 		= set to a specific state if you wish to extract just one states date
	 GenStart		= the date preceding first day of outbreak (day last 0), or 22/02/2020
	                  whichever is later

	 GenName 		=  concatentation of GenCountry and GenState (calculated)
	 GenMatch	    = the row of tblPopulation table where specified GenCountry found (calculated)

	 c) tblHist

     Further to the right is a tblHist for pasting the daily solutions or
	 more frequent logistic solutions. These can be sorted into order
	 so that a graph can be made showing the progression of the logistic
	 limit as data is added to tblData -- only implemented for Italy
	 and NSW.

	 In the range A1:G2 is a table of parameters that is used by the Solver
	 solution. The macro SolveAll sets the set of parameters to refer to the
	 same country-specific parameter in the tblRuns rows (et beta, delta, Po)

	 The reason this is needed is that the solver constraints could not be
	 set from VBA to refer to changing rows of tblRuns --- it was achieved
	 by setting named ranges in the A1:G2 table, and using VBA to change
	 which row of tblRuns they were set to refer to. It was found at least
	 when the number of days available was low, solver needed constraints in
	 some cases in order to solve correctly.

	 d) tblPopulation

	 There is a solveMsgs worksheet that contains a table of population data
	 and other data for determining whether the SolveAll process is run for the
	 country/state and or

	Above the tblData and tblHist are various structures for supporting labelling
	of chart series, titles and axis titles

	e) GetJHConfirmedData

	 Gets latest confirmed cases time series from John Hopkins Github
    loads into the worksheet name as per gcsSeriesConf

    JH data has one column per date, and an increasing number of rows
     per country or state with reported cases...

     need to process this into a time series running down the worksheet
     one row per date...

     this is done in the table named tblData (an excel listobject)

    then processes into a myData worksheet int
    myData worksheet has a large number of named ranges
    and a table named tblData
    tblData has 1 row per day of data
    there are numerous charts in separate sheets, one per country
    as its not easy to rearrange excel tables (listobjects) columns,
    without damaging formulas that depend on them,
    the columns might see haphazard in order

    tblData has some columns to the right on NSW test data that is
     not available in the JH datafeed. These are manually fed in on
     a daily basis.

    as well, the JH data is often not the latest available. The loading
     macro process will not overwrite any manually entered value that is
     larger than that read from JH.

    the myData worksheet has a large set of named ranges, and in particular
    dynamic named ranges that will expand as the rows of data accumulate.

     in addition to tblData, consisting of two parts.
     the top part is a list of the parameters that the Solver process
     is estimating, and used in the logistic equation output

     below is is an area (growing) for pasting the daily solutions
     and then sorting them so that the growth of the asymptotes and
     other changes can be easily seen

	 e) (i) ScrapceDailyNSWHealth

	 GetJHConfirmedData macro also invokes a call to the ScrapeDailyNSWHealth,
	 which scans back from current day, looking for .aspx files on NSW Health
	 website in which the data updates are provided. The user is prompted
	 for the number of days to scan back.

	 Web-page scraping was used because initially the datasets were not being
	 published otherwise.

	 e) (ii) GetAusTweet

	 This macro scrapes the pinned tweet on the https://twitter.com/COVID_Australia
	 twitter used page. This page is updated throughout the day with the
	 latest data published by Australian States. The WA data is not typically
	 published until after 9 pm AEST. SA, Tasmania and NT are also late in
	 the day with their stats updates.

	 This is generally more reliable than waiting for the John Hopkins data.

	 e) Sub AddNewCountry

     adds a new country to the myData worksheet table tblData,
     including creating the defined names and formulas applicable to it.
     does not yet get the tblRuns row right
     you need to put the country details in tblPopulation first, above the
     row labelled with country Tests
     also insert a row in the named range Countries (but that is now superseded
     by tblPopulation.

	2) Second Approach

	A second method was developed to support adding new countries to graphs without the
	logistic equation complexity.

	This is based on taking the time series data and transposing it into a new worksheet
	TST (or DeathsTimeS) that are row date ordered

	The one big flaw in this was that at the 21st April, the John Hopkins data for Tasmania
	from 3rd April to 21st was flawed (incorredt, compared to reading from https://twitter.com/Covid19Tas
	that directly read Tas govt data). You have to correct this every time you retrieve a new days
	data. The first approach will not overwrite existing data in myData tblData.

	The second approach has also been used to create a worksheet DeathsTimeS with deaths data.

	There is a macro which can create per capita data columns from TST (or DeathsTimeS), and the
	defined name dynamic ranges needed to track/graph the cases from 100 per capita
	confirmed cases or 100 deaths per capita.

	 TtranspSeries Macro

     Copy and transposes the time-series data sheet which have dates in column order
     across row 1 into worksheet with row-order for dates. Handles cases and
     deaths - dont feel recoveries mean enough to be useful to plot.

     Select countries to create plottable columns and range names for graphs of
     cases since Solvmsgs!mincases or deaths since Solvmsgs!MinDeaths per capita

     A set of defined names are created with dynamic ranges for each country for supporting
     graphing of the data.

     the deaths csv has a column for population of each county in the USA as dropped
     from JH github

     each time it is run, new country (or state) columns can be added, all can be rebuilt,
     or you can just have the latest data pasted into the TST or DeathsTimeS worksheets.

	AddSeriesToCht1 Sub

     This allows user to select a chart (located on a sheet, not tested for embedded chart)
     then copy the SERIES function for a particular country or state to
	 series for a new country or state, substituting the new country name in place
	 of the country/state named in the template SERIES function.

     the defined name dynamic ranges need to be set up first for this to work

	=SERIES(TST!VictoriaSeriesLabel,TST!Victoria100Days,TST!Victoria100Cases,3)

	 The required dynamic names are established by the TtranspSeries macro (for
	 TSTS and DeathsTimeS) or the AddCountry macro for tblData in myData worksheet.

    UpdateSeriesLabels Sub

    Scans for worksheet charts, starting from leftmost one (ie. chart sheet
	index order), prompting user to process that chart or not, or to
	abort (cancel) the processing.

	For each selected chart, the xy series functions are stepped through to
	find any labelled points. Only 1 is expected, giving typically the
	RH point on the series when last processed by this (or otherwise
	with XY Chart Labeller).

    Where a label is found, it is copied to the next to last RH point,
	where not found, a point label is constructed from the series function
	given label. The series label is parsed to remove any "from..."
	 suffix (which is used in this workbook to specify dates from which
	 a country had over 100 cases or 10 deaths per 10m pop)


text:
## The worldbank data interface

###### A display of the world's economic, social and health development over the past 50 years

---

1. [Data] (#the-data)
2. [Objectives] (#the-objectives)
3. [Visual] (#the-visual)

---

#### The data

The worldbank data interface used to be a dashboard I built for a broadcasting company some time ago. One of the key objectives was to compare metrics of a large number of brands from two product lines (on-demand vs. traditional television) with each other. All metrics required to be shown as a time-series. When I decided to publish the dashboard I needed to find open data to replace the proprietary data. It wasn't a long search as I wanted to work with [Worldbank data](http://databank.worldbank.org/data/reports.aspx?source=world-development-indicators) for some time as it's such a relevant and deep data-source showing trends over a comparably long time-period. Starting to wrangle the data it became apparent quite quickly that the worldbank data shared key properties with my original dataset:

* It's time-series data
* for a large number of categories (ie. countries).
* There are enough metrics and
* the metrics can be roughly clustered into a small number of categories.

and most importantly:

* The categories (= countries) can be clustered into a super-category to allow high level comparison.

In the case of the original interface this super-category was the *broadcasting type* (on-demnad vs. traditional television). For the worldbank data I could use the [*Human Development Index*](https://en.wikipedia.org/wiki/Human_Development_Index). The Human Development Index (or HDI) is colloquially well-known as we tend to refer to *highly developed* countries or countries with a *low development*. In fact the HDI establishes a grouping with 4 ordinal categories of development:

1. Very high
2. High
3. Medium and
4. Low

--

#### The objectives

As mentioned above the rather general objective for this project was to allow an intuitive comparison between the key values. After further discussions, these could be specified to the following specific objectives:

1. show trends
2. show hierarchies
3. allow comparison on individual category level (ie. countries)
4. allow comparison on super-category level (ie. development level of countries)
5. allow an easy lookup of indiviudal categories (= countries)
6. summarise the values per category (= country)
7. show associations between selected metrics - ideally over time

--

#### The visual

After some pondering and sketching I went for one central visual holding the main data corpus and ticking in fact the first 5 of above boxes. Why stick so many objectives into one visual? In this case it was just most efficient. The user doesn't have to move between different idioms while still being able to apply a set of visual analyses relatively easily.

So. to the core:

###### Displaying many trends

 ![main display](/images/readme/worldbank.png)

The core visual is - in its essence - a multiple with relatively large graphs (for multiples, that is) being navigated by scrolling. The data for each graph shows one metric and each line represents one country. The graphs are laid out horizontally in two columns. Each column represents one super-category, for example *very highly developed countries* to the left and *low developed countries* to the right. This side-by-side layout allows the user to identify general patterns over time per super-category. Highlighting of individual countries is possible by hovering over the lines as well as picking each country by a button box above the columns. I applied **linked highlighting**, across the entire column, so highlighting a country in one chart highlights the country across all charts it is present in.

This ticks boxes 1, 3, 4 and 5. Box 2 (= show hierarchies) is only partly ticked as of course the lines show different levels. However, in order to show hierarchies proper, the user can switch from a line chart to a **bar chart**. By poping up a slider at the bottom of the screen, the users can choose the year they would like to see. Box 3 ticked.

![moving bars](images/readme/worldbank_bars.gif)

As a bonus and in the spirit of redundancy and [detail on demand](http://www.infovis-wiki.net/index.php/Visual_Information-Seeking_Mantra), the user can also view the raw data in a table. We can turn the table into a heatmap to help identifying individual figures as well as downloading it in order to go wild with the semi-raw data.

![heatmap](images/readme/worldbank_heatmap.png)

Next box, number 6:

###### Displaying associations

![scatter](/images/readme/worldbank_scatter.png)

The worldbank data interface is descriptive in nature. This means our main aim is to show the data as it is without applying further analysis or modeling to it. However, looking at associations of 2 or 3 variables can inform understanding a lot if only it changes a perspective. Assocoations are incorporated within the **Explore** section in the interface showing scatterplots of 2 and bubble charts of 3 variables.

Additionally all scatterplots can be **time-animated** showing the development of the association from - in our case - 1953 to 2013. This way animation adds an additional variable: time. Also, each scatterplot has a bar chart to its side offering alternative data encoding (with re-sorting option) as well as an additional navigational panel, as linked highlighting between bars and scatterplot is enabled.

###### The summary

![summary](/images/readme/worldbank_summary.png)

![like so](images/readme/worldbank_split.png)

I consider it good practice to allow the user a summary of the data as an alternative to the deep end. One could argue an overview, reducing complexity is in this case not really needed as the data in its raw form (as in trends per country) isn't complex or shouting for simplification. In fact it's so straight forward any summary adds complexity.

Still, a summary has clear benefits. In this context it is meant to satisfay 3 purposes: First, it simplifies our view to more easily spot trends and outliers per country. Second, people without much time can get a quick overview. Third, a summary value across a number of metrics can become currency within an organisation and help more succinct communication.

In this case we are averaging a number of key metrics per country. There are in fact 2 metrics: a **Wide** Growth Index and a **Tight** Growth Index. The Wide Index averages 9 key metrics ([below](#footnote)) while the Tight Growth Index averages 3 key metrics. Both metrics focus on growth in social and health categories rather than economy which is down to economic data not being available for many countries. The views are implemented as multiples showing one graph per country. To help cognition, the countries are further ranked descendingly by positive growth rate within the past 10 years.

Metrics for indexes:

The *Wide Growth Index* represents the average yearly growth rate of the following 9 variables: GDP per capita (constant 2005 US$), Mortality rate, infant (per 1,000 live births), Mortality rate, under-5 (per 1,000 live births), Number of infant deaths, Number of under-five deaths, Mortality rate adult (per 1,000 female adults), Life expectancy at birth, total (years), Death rate, crude (per 1,000 people), Survival to age 65, female (% of cohort).

The *Tight Growth Index* represents the average yearly growth rate of the following 3 variables: Life expectancy at birth, total (years), Death rate, crude (per 1,000 people), Survival to age 65, female (% of cohort)

###### The chart builder

![chart builder](images/readme/worldbank_chart_builder.png)

The final module in this interface is the **chart-builder**. The builder allows you to focus on a particular chart showing all countries for the metric. The user has a list of all metrics allowing him to bring up the visual they want. They can then alternate between line chart and the data in a table or heatmap. Some metrics can be split in male, female like so:

![like so](images/readme/worldbank_split.png)

repository: larsvers/worldbank-data-interface

repo_name: larsvers/worldbank-data-interface


text:
[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.4415832.svg)](https://doi.org/10.5281/zenodo.4415832)

# Multilingual-PDF-OCR-on-Google-Colab by Akella Niranjan
Every day we tend to scan many hard copies for various purposes. So, one such application confronted me where the scanned literature was in an Indian language - "Hindi" where the script was in a .pdf file format and when copied to a word document couldn't be recognize, hence displaying ASCII values.

So I developed an algorithm to convert scanned Hindi documents to text files for further use like notation editing, translating to other languages etc; using Googles Tesseract Engine.

- Initially install all the necessary packages on to the Google Colab instance using the following commands
```
!pip install pytesseract
!sudo apt install tesseract-ocr
!apt-get update
!pip install pdf2image
!apt-get install poppler-utils
!sudo apt-get install tesseract-ocr-hin
```

- Then refer the algorithm in this Jupyter Notebook

## Further Usages

This algorithm can be used for a wider set of languages by installing the desired language model through the follwing command.

- Change the language from 'hin' to desired language from the language list Here.
```
#Exambple for English
!sudo apt-get install tesseract-ocr-eng
```
- Also change the "lang" parameter in the python code from 'hin' to desired language as follows,
```
#Example for English
pytesseract.image_to_string(x, lang = 'eng')
```


text:
# CryptoPie
###### CryptoPie is the Raspberry Pi Cryptowatch monitor

## Circuit
The code for cryptoPie is based around a 16x2 LCD screen.

My screen broke just before I went to test this... so let me know of any issues and I will look to test myself when a new screen comes in.

However by setting the size of screen in ```cryptowatch --config``` should allow you to use other screen size as well with no trouble at all.

I am using a Raspberry Pi 2 Model B V1.1.

Other models may be used but if the GPIO layout needs adjusting make sure to setup the correct GPIO variables in ```cryptowatch --config```

<img src="https://s26.postimg.org/4u2qontnt/Cryptowatch_First_Circuit.png" height="600px" width="700px" align= "center">

In between LCD Backlight +5V I used a 1k ohm resistor to prevent overpowering the backlight this may not be necessary but for the first attempt is definitely a good idea.

## Usage

* After installing cryptowatch run ```cryptowatch --config``` and setup your account addresses.
* Make sure the circuit is wired identical to the picture or that you have changed the config file respectively.
* Run ```cryptowatch --monitor pie``` or ```cryptowatch --monitor rpi``` to run cryptoPie
* Profit???

## License

MIT License

Copyright (c) 2017 Alex Epstein

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

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

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

repository: bellyfat/cryptowatch

repo_name: bellyfat/cryptowatch


text:
# .NET Lambda GitHub Actions
This .NET Lambda GitHub Actions repository provides an action that uses the AWS .NET Lambda tools to package and upload a .NET package to a Lambda function.

## Getting Started

Create a GitHub Action workflow in a private repository hosting a .NET project with the following code in a workflow:

```
name: Deploy to dev environment
on:
  push:
    branches:
      - develop
jobs:
  test:
    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v1

    - name: Use .NET 2.1
      uses: actions/setup-dotnet@v1
      with:
        dotnet-version: 2.1.500

    - name: .NET Lambda build and deploy
      uses<EMAIL_ADDRESS>      env:
        AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
        AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
        AWS_REGION: us-east-1
        DOTNET_LAMBDA_PACKAGE_NAME: latest.zip
        DOTNET_LAMBDA_FUNCTION_HANDLER: Host::MyLambdaDomain.Host.LambdaEntryPoint::FunctionHandlerAsync
        DOTNET_LAMBDA_FUNCTION_NAME: my-lambda-function-name
        DOTNET_LAMBDA_S3_LOCATION: my-lambda-builds-bucket/my-lambda-function-name
        DOTNET_LAMBDA_WORKING_DIR: ./src
        DOTNET_LAMBDA_CONFIG_FILE: aws-lambda-defaults.staging.json
```

## Actions

### Deploy Action

Given:

* `DOTNET_LAMBDA_WORKING_DIR`: .NET project directory
* `AWS_ACCESS_KEY_ID` & `AWS_SECRET_ACCESS_KEY`: AWS credentials
* `AWS_REGION`: AWS region *(default: us-east-1)*
* `DOTNET_LAMBDA_PACKAGE_NAME`: Filename to use for zipped package archive. *(default: latest.zip)*
* `DOTNET_LAMBDA_S3_LOCATION`: S3 bucket/key to upload package archive to *(example: <bucket_name>/<key/folder>)*
* `DOTNET_LAMBDA_FUNCTION_NAME`: Lambda function name
* `DOTNET_LAMBDA_FUNCTION_HANDLER`: Lambda function handler

This action will package the project, update the Lambda function with the packaged code, and deploy the function.

repository: SnapStreamJason/dotnet-lambda-actions

branch_name: refs/heads/develop

gha_language: Dockerfile

repo_name: SnapStreamJason/dotnet-lambda-actions


text:
# Fitchner

[![GoDoc](https://godoc.org/github.com/danielkvist/fitchner?status.svg)](https://godoc.org/github.com/danielkvist/fitchner)

Fitchner provides utilities to make HTTP requests and to extract information from the responses.

## Import

```go
import "github.com/danielkvist/fitchner"
```

## Utilities

### Fetch

Fetch makes an HTTP request and returns the response.
Receives an http.Client and an http.Request for it.
An error is returned if:

- The client fails to make the request.
- There is some problem while reading the response body.
- There is a non-2xxx response.

When there is no error, returns an io.Reader with the body of the response.

```go
func Fetch(c *http.Client, req *http.Request) (*bytes.Reader, error)
```

### Filter

Filter filters the body of an HTTP response depending on the received params.
All three params (tag, attr or val) can be an empty string. In which case a
slice of \*html.Node with all the found html.ElementNode is returned.
An error is returned if there is any problem while parsing.

> NOTE: The tag doesn't has to include "<" neither ">".

```go
func Filter(r io.Reader, tag, attr, val string) ([]*html.Node, error)
```

### Links

Links extracts all the links found on the body of an HTTP response.
It ignores the links with the prefix "tel:" and removes the "mailto:" prefix.
An error is returned if there is any problem while parsing.

```go
func Links(r io.Reader) ([]string, error)
```

repository: shammishailaj/fitchner

repo_name: shammishailaj/fitchner


text:
- ***psdle.base.js*** is the main version of PSDLE where edits should occur.
  - After making the needed edits, run `grunt compile` to generate ***psdle.includes.js***.
  - Run `grunt includes:build` to skip CSS/lang minify, ensure they're already minified first!
- ***psdle.includes.js*** is the resulting complete PSDLE before uglifying.
- ***psdle.user.txt*** is the Userscript header appended to the ***includes*** version for `grunt release`.

Versioning is done automatically to all versions both in banners and version properties (chrome/userscript, `grunt string-replace:release`) based on ***package.json***.

repository: RePod/psdle

repo_name: RePod/psdle


text:
![Logo](https://github.com/Hexworks/amethyst/blob/master/amethyst_logo_PREVIEW_shine_darkbg.png)

# Introducing Amethyst

*Amethyst* is a small library that enables you to modularize your application by letting you decompose them into
**Systems**, **Entities** and **Attributes** in an easy-to-use manner. It is similar to an[Entity Component System](https://en.wikipedia.org/wiki/Entity_component_system)
but it is a bit different in some important aspects.

The core abstraction in *Amethyst* is the **Entity** that encapsulates the internal state of our business objects and
also their related operations. By using this concept we can maintain the [Cohesion](https://en.wikipedia.org/wiki/Cohesion_(computer_science))
of our business objects while still retaining the flexibility.

`So how does this work?`, you might ask. Let's take a look at a simple example.

## Systems, Entities, Attributes

Let's say that we're creating a game with mythical creatures, and we want to add a *goblin* to our game.
If we think about how things can behave and change over time we can conclude, that there are essentially two ways:
*internal*, and *external*. For example a *goblin* can decide  that it wants to explore a dungeon, or just take a
look around (**internal change**), or the player can decide to bash the goblin to a pulpy mass with their club
(**external change**). For this Amethyst has `System`s in place:

```kotlin
/**
 * A [System] is responsible for updating the internal state of an [Entity].
 * The internal state is represented by [Attribute]s.
 */
interface System<C : Context>
```

There are several types of `System`s, and for our discussion here we need to know about `Behavior`:

```kotlin
/**
 * A [Behavior] is a [System] that performs autonomous actions whenever
 * [update] is called on them.
 */
interface Behavior<C : Context> : System<C>
```

that lets our *goblin* interact with the world and `Facet`:

```kotlin
/**
 * A [Facet] is a [System] that performs actions based on the [Message] they receive.
 * Each [Facet] only accepts a single type of [Message] of type [M]. This enforces
 * that facets adhere to the *Single Responsibility Principle*.
 */
interface Facet<C : Context, M : Message<C>> : System<C>
```

that lets whe **world** interact with our *goblin*.

> There is also `Actor` which combines `Facet` and `Behavior`. We'll talk about it later.

When changes happen over time to an entity (our *goblin* in this example) its state might change.
To represent this, *Amethyst* gives us `Attribute`s:

```kotlin
/**
 * An [Attribute] represents metadata about an entity that can change over time.
 */
interface Attribute
```

An `Attribute` can be anything that you add to your *entity*, from health points to stomach contents.
What's important is that `Attribute`s should **never have** behavior, they are supposed to be dumb data structures.

On the other hand, `System`s should never have internal state. These two *important rules* allow us to compose `System`s
and `Attribute`s into `Entity` objects that are flexible, cohesive and safe to use.

The `Entity` itself is just a bag of `Attribute`s and `System`s:

```kotlin
interface Entity<T : EntityType, C : Context> : AttributeAccessor, FacetAccessor<C>, BehaviorAccessor<C> {

    val id: UUID
    val type: T
    val name: String
    val description: String

    val attributes: Sequence<Attribute>
    val behaviors: Sequence<Behavior<C>>
    val facets: Sequence<FacetWithContext<C>>

    suspend fun sendMessage(message: Message<C>): Boolean

    suspend fun receiveMessage(message: Message<C>): Response

    suspend fun update(context: C): Boolean
}
```

What's interesting here is `sendMessage`, `receiveMessage` and `update`. It is not a coincidence that we have these in
`Facet` and `Behavior`! When an `Entity` receives a `Message` it will try to apply it to its `Facet`s, and when an `Entity`
is updated it lets its `Behavior`s interact with the world. What *world* means in this context is up to you, that's why
`update` takes a `context` object which can be anything. In our case it will contain our `World` for example.

Don't worry if this seems a bit complex, we'll see soon that the benefits of using such system outweigh the costs.

So how do these entities work together? We have `Engine` for that which handles them, so we don't have to do it by hand:

```kotlin
interface Engine<T : Context> {

    /**
     * Adds the given [Entity] to this [Engine].
     */
    fun addEntity(entity: Entity<out EntityType, T>)

    /**
     * Removes the given [Entity] from this [Engine].
     */
    fun removeEntity(entity: Entity<out EntityType, T>)

    /**
     * Updates the [Entity] objects in this [Engine] with the given [context].
     */
    fun update(context: T): Job
}
```

repository: Hexworks/amethyst

gha_language: Kotlin

repo_name: Hexworks/amethyst


text:
---
layout: post
title: Simultaneous Sparklies
subtitle: October 28, 2019
comments: true
---

# Assignment: Simultaneous Sparklies

* The assignment was to light up 3 sets of LEDs simultaneously according to 3 different patterns (flash bulb, synchronous, big dipper)
* Also lights up extra credit blue ghost LED
* Below are photos of the 4 different sets of LEDs in action

![Green/Blue](https://ephsarah.github.io/img/greenblue.jpeg)

![Yellow/Blue](https://ephsarah.github.io/img/yellowblue.jpeg)

![Red/Blue](https://ephsarah.github.io/img/redblue.jpeg)

Tip for my past self: To simplify code, take out parts that will always be true and then make a note of why I was able to omit the piece. Eg: "...I don't need timer%interval == 0 here because it will always be true!"


text:
<!--- Copyright (C) 2009-2013 Typesafe Inc. <http://www.typesafe.com> -->
# RequireJS

According to [RequireJS](http://requirejs.org/)' website

> RequireJS is a JavaScript file and module loader. It is optimized for in-browser use, but it can be used in other JavaScript environments... Using a modular script loader like RequireJS will improve the speed and quality of your code.

What this means in practice is that one can use [RequireJS](http://requirejs.org/) to modularize your JavaScript. RequireJS achieves this by implementing a semi-standard API called [Asynchronous Module Definition](http://wiki.commonjs.org/wiki/Modules/AsynchronousDefinition) (other similar ideas include [CommonJS](http://www.commonjs.org/) ). Using AMD makes it is possible to resolve and load javascript modules on the _client side_ while allowing server side _optimization_. For server side optimization module dependencies may be minified and combined using [UglifyJS 2](https://github.com/mishoo/UglifyJS2#uglifyjs-2).

By convention RequireJS expects a main.js file to bootstrap its module loader.

## Deployment

The RequireJS optimizer shouldn't generally kick-in until it is time to perform a deployment i.e. by running the `start`, `stage` or `dist` tasks.

If you're using WebJars with your build then the RequireJS optimizer plugin will also ensure that any JavaScript resources referenced from within a WebJar are automatically referenced from the [jsdelivr](http://www.jsdelivr.com) CDN. In addition if any `.min.js` file is found then that will be used in place of `.js`. An added bonus here is that there is no change required to your html!

## Enablement and Configuration

RequireJS optimization is enabled by simply adding the plugin to your plugins.sbt file when using the `PlayJava` or `PlayScala` plugins:

```scala
addSbtPlugin("com.typesafe.sbt" % "sbt-rjs" % "1.0.0-RC2")
```

To add the plugin to the asset pipeline you can declare it as follows (assuming just the one plugin for the pipeline - add others into the sequence such as digest and gzip as required):

```scala
pipelineStages := Seq(rjs)
```

A standard build profile for the RequireJS optimizer is provided and should suffice for most projects. However if you would prefer to provide your own build profile then declare an `appBuildProfile` function in your build. The following build profile is the direct equivalent of [the one recommended in the rjs documentation for whole project builds](http://requirejs.org/docs/optimization.html#wholeproject):

```scala
import RjsKeys._

appBuildProfile := s"""|({
                       |  appDir: "${appDir.value}",
                       |  baseUrl: "js",
                       |  dir: "${dir.value}",
                       |  modules: [
                       |      {
                       |           name: "main"
                       |      }
                       |  ]
                       |})""".stripMargin
```

The standard build profile we provide incorporates support for generating source maps, allows for configuration overrides in your `main.js` file and optimizes using uglify2. The standard build profile is as follows:

```scala
appBuildProfile := s"""|({
                       |  appDir: "${appDir.value}",
                       |  baseUrl: "js",
                       |  dir: "${dir.value}",
                       |  generateSourceMaps: true,
                       |  mainConfigFile: "${appDir.value / "js" / "main.js"}",
                       |  modules: [{
                       |    name: "main"
                       |  }],
                       |  onBuildWrite: ${buildWriter.value},
                       |  optimize: "uglify2",
                       |  paths: ${RjsJson.toJsonObj(webJarModuleIds.value.map(m => m -> "empty:"))},
                       |  preserveLicenseComments: false
                       |})""".stripMargin
```

Note that RequireJS performs a lot of work and while it works when executed in-JVM under Trireme, you will be best to use Node.js as the js-engine from a performance perspective. For convenience you can set the `sbt.jse.engineType` property in `SBT_OPTS`. For example on Unix:

```bash
export SBT_OPTS="$SBT_OPTS -Dsbt.jse.engineType=Node"
```

Please refer to the [plugin's documentation](https://github.com/sbt/sbt-rjs#sbt-rjs) for information on how it may be configured.

gha_language: Scala


text:
---
layout: post
title: "Episode 287: Informal favoritism and post-hoc finger pointing"
date: 2022-01-17 12:00:00 -0700
guid: fb9e61c0-0ee0-4f4d-94b7-9dfcd8818da4
duration: "22:01"
length: 20155939
file: "https://dts.podtrac.com/redirect.mp3/download.softskills.audio/sse-287.mp3"
categories: episode
enable_comments: true
---

In this episode, Dave and Jamison answer these questions:

1. Listener Sara asks,

   How can I deal with favoritism towards informal leaders in a group? The group is losing group intelligence because the informal leader's reasoning and direction is favored. Example: when member A propose an argument is dismissed, but when the informal leader proposes the same argument it is cherished.

2. How do I react to the question "why didn't you do it this way" for features already in production? I am frustrated by being asked that. I got scolded for an idea that turned out to be bad after I implemented it (in production), although I asked the Lead for his opinion ahead of time. As soon as trouble came up a.k.a performance issue in production, he pointed the finger at me. Lost all kinds of respect for him.

repository: soft-skills-engineering/website

branch_name: refs/heads/gh-pages

repo_name: soft-skills-engineering/website


text:
# ephemeral: automatically delete your old Tweets with AWS Lambda

**ephemeral** is a Twitter timeline grooming program that runs for pretty much free on AWS Lambda. The code is forked from Adam Drake's excellent [Harold](https://github.com/adamdrake/harold) butler-like bot and refactored for Lambda.

You can use ephemeral to automatically delete all tweets from your timeline that are older than a certain number of hours that you can choose. For instance, you can ensure that your tweets are deleted after one week (168h), or one day (24h).

The program will run once for each execution based on the trigger/schedule you set in AWS Lambda. It will delete up to 200 expired tweets (per-request limit set by Twitter's API) each run.

# Twitter API

You will need to [create a new Twitter application and generate API keys](https://apps.twitter.com/). The program assumes the following environment variables are set:

```
TWITTER_CONSUMER_KEY
TWITTER_CONSUMER_SECRET
TWITTER_ACCESS_TOKEN
TWITTER_ACCESS_TOKEN_SECRET
MAX_TWEET_AGE
```

`MAX_TWEET_AGE` expects a value of hours, such as: `MAX_TWEET_AGE=72h`

You can set these variables in AWS Lambda when you create your Lambda function. For a full walkthrough with screenshots on creating a Lambda function and uploading the code, read [this blog post](https://vickylai.com/verbose/aws-lambda/). Skip to setting environment variables at [this link](https://vickylai.com/verbose/aws-lambda/#2-configure-your-function).

# update.sh

This handy bash script is included to help you upload your function code to Lambda. It requires [AWS Command Line Interface](https://aws.amazon.com/cli/). To set up, do `pip install awscli` and follow these instructions for [Quick Configuration](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html).

repository: rehatkathuria/ephemeral

repo_name: rehatkathuria/ephemeral


text:
# Change log

All notable changes to this project will be documented in this file.

## 1.0.7

- Modify README, change installation directives
- Add laravel 5.3 support to composer.json

## 1.0.6

- Modify README, remove comma from composer.json part
- Fix wrong ServiceProvider name on README

## 1.0.5

- Modify README
- Fix description on composer.json
- Change require section on composer.json
- Change method sequence on ServiceProvider file

## 1.0.4

- Add custom class name to helper function

## 1.0.3

- Modify README, add real life usage
- Test on laravel 5.2 and add laravel 5.2 badge

## 1.0.2

- Change helper function active_class() to active_route()

## 1.0.1

- Modify README

## 1.0.0

- Initial release


text:
# @dated/markdown-title-case

> CLI to set your markdown titles and captions to title-case

[![Latest Version](https://badgen.now.sh/npm/v/@dated/markdown-title-case)](https://www.npmjs.com/package/@dated/markdown-title-case)
[![Node Engine](https://badgen.now.sh/npm/node/@dated/markdown-title-case)](https://www.npmjs.com/package/@dated/markdown-title-case)
[![Build Status](https://badgen.now.sh/circleci/github/dated/markdown-title-case)](https://circleci.com/gh/dated/markdown-title-case)
[![Codecov](https://badgen.now.sh/codecov/c/github/dated/markdown-title-case)](https://codecov.io/gh/dated/markdown-title-case)
[![License: MIT](https://badgen.now.sh/badge/license/MIT/green)](https://opensource.org/licenses/MIT)

## Installation

```bash
yarn add @dated/markdown-title-case
```

## Usage

```bash
markdown-title-case PATH [--recursive] [--fix] [--fail]
```

## Markers

If you want a specific line not to be processed, append the following at the end of it

```
<!-- markdown-title-case: skip-line -->
```

## Security

If you discover a security vulnerability within this package, please send an e-mail to<EMAIL_ADDRESS>All security vulnerabilities will be promptly addressed.

## Credits

-   [Edgar Goetzendorff](https://github.com/dated)
-   [All Contributors](../../contributors)

## License

[MIT](LICENSE) © [Edgar Goetzendorff](https://dated.fun)

repository: dated/markdown-title-case

repo_name: dated/markdown-title-case


text:
- Start Date: 2020-11-06
- Start Date: 2020-11-10
- Target Major Version: 2.0
- Reference Issues: *None*

# Summary

All clients may send a header in every request called "user-agent". This header must include the device type of SO or client that is calling the backend/API and also, the app version. This info will provide us some power tracing users bugs/problems/behaviors

# Basic example

We expect different user-agent by devide:
  * Android: android-com.wawmuzik.app-1.0.24-release
  * iOS: iOS-com.wawmuzik.app-1.0.6

# Motivation

When a user has a problem, without this info, we don't know exactly under which version is using the service neither the source (Android/iOS).

If we detect that some users have problem in the login/registration process, we would be able to debug the version afected or the backend if it is a general problem. Also, it adds some power if the bussiness team decides to create a marketing capaign targeting users.

The final motivation comes through the "force push" functionality. If we detect that some users are running under a very old app, we could need to alert he/she to update the app for any reason.

# Detailed design

The first step is to crea a middleware to be included in the requests to the API that you need. This middleware will be the responsible of saving the device and version in to the user info.

```js
  android-com.wawmuzik.app-1.0.24-release
  iOS-com.wawmuzik.app-1.0.6
```

The middleware has to process the given header and extract the device (android) and the app version (1.0.24).

Use a regular expresion to extract this numeric value:

```js
  const APP_VERSION = new RegExp(/\d+\.\d+\.\d+/, 'i');
```

# Drawbacks

*Nothing at this moment*

# Alternatives

*Not related*

# Adoption strategy

Mobile apps has included it on every call to the API. There isn't any problem if a client doesn't have, in this case the backend doesn't do any and the logged user won't have this info

# Unresolved questions

*Nothing at this moment*

# References

*Not related*

repository: waw-muzik/rfcs

repo_name: waw-muzik/rfcs


text:
A simple demo project for demonstrating Storm and Spark API using Twitter
data. I am a C#, JavaScript, Ruby convert and new to Storm/Spark, so I expect
criticism of some sort. Since this is intended to be used by others who are also
new to the platforms, please feel free to submit pull requests to improve upon
the quality of the project.

In order to run the demos, you must modify the sample-config.xml file (included)
with your own Twitter app values from http://dev.twitter.com and save them to a
resource file named config.xml.

repository: senfo/TwitterProcessor

repo_name: senfo/TwitterProcessor


text:
### WHAT IS HACKTOBERFEST?

**Hacktoberfest** 2020 is a month long virtual festival event to celebrate open source contributions presented by Digital Ocean, Intel and DEV. It is the easiest way to get into open source!

**Hacktoberfest** is open to everyone in our global community!

## How to Participate
1. Hacktoberfest is open to everyone in our global community. Whether you’re a seasoned contributor or looking for projects to contribute to for the first time, you’re welcome to participate.
2. Pull requests can be made in any participating GitHub-hosted repositories/projects.
3. Maintainers can opt-in to participate by classifying their projects with the hacktoberfest topic.
4. Your pull requests will count toward your participation if they are in a repository with the hacktoberfest topic and once they have been merged, approved by a maintainer or labelled as hacktoberfest-accepted.
5. Additionally, any pull request with the hacktoberfest-accepted label, submitted to any public GitHub repository, with or without the hacktoberfest topic, will be considered valid for Hacktoberfest.
6. You can sign up anytime between October 1 and October 31. Just be sure to sign up on the official Hacktoberfest website for your pull requests to count.

For participation you have some of knowledge github and git stuff. You can follow this step as well if you are now aware of it
The first thing to do is to register on the official Hacktoberfest page. Then, go check Github and start looking for projects. Here you can find the list of all the projects that voluntarily tagged themselves “Hacktoberfest”. Some maintainers also have tagged issues. You can also look at the projects you use every day, they might be open source 😉

Step 1 register or login to github[Github](https://github.com/).

Step 2 register to hacktoberfest[Hacktoberfest](https://hacktoberfest.digitalocean.com/).

Step 3 Now you have to contribue to four respostiories. You just need to fork first any repo to make your local repo then get clone of these repo.Now you can contribute these project and commit and push the code.
At last you have to create pull request for merging your code to original codebase and the maintainer review your code and can reject or merge your code.I will share you screeshot so you can understand properly.

Image | Description
------------ | -------------
  | Fork your repo
 | Clone your repo
 | Create a pull request

Step 4: Check your progress from here[Hacktoberfest](https://hacktoberfest.digitalocean.com/).

Step 5: Digital ocean will ask for shipping address via email.

Step 6: Wait for that awesome Hacktoberfest t-shirt from Github & Digital Ocean.

## Why contribute to an open-source project?
There are so many benefits to contributing to an open-source project!

1. Free swags and stickers 😉

2. Contributing to open source software will make you a better person because:

3. You expand your skillset

4. It is good for your career (don’t tell your boss, but this becomes part of your public resumé)

5. You’ll learn things you never knew, you’ll unlearn things you never knew you should

## Do's and Dont's of Hacktoberfes
* Don't: open pull requests with minor text edits on other people's repositories

* Do: Follow a repository's contribution guidelines\

* Don't: feel intimidated

repository: BryanAim/All-about-open-source

repo_name: BryanAim/All-about-open-source


text:
# Improve Keepass Default Settings

[Keepass](http://keepass.info/) isn't fully integrated into the browser like other options, but it does offer a ton of the same features under the hood.

To open Keepass, hit `super` to search for and open it. From the `Tools` menu, open the `Options` window.

On the `Interface` panel, and under the `Quick Search` header, check `Focus entry list after successful search`.

On the `Security` panel, check the box to enable `Passwords expire after 90 days`.

repository: rocheio/til

repo_name: rocheio/til


text:
parsers
=======

[![Hackage](https://img.shields.io/hackage/v/parsers.svg)](https://hackage.haskell.org/package/parsers) [![Build Status](https://github.com/ekmett/parsers/workflows/Haskell-CI/badge.svg)](https://github.com/ekmett/parsers/actions?query=workflow%3AHaskell-CI)

Goals
-----

This library provides convenient combinators for working with and building parsing combinator libraries.

Given a few simple instances, you get access to a large number of canned definitions.

Contact Information
-------------------

Contributions and bug reports are welcome!

Please feel free to contact me through github or on the #haskell IRC channel on irc.freenode.net.

-Edward Kmett

repository: ekmett/parsers

extension: markdown

gha_language: Haskell

repo_name: ekmett/parsers


text:
# Identity

| `master` | `develop` |
|----------|-----------|
| [![Scrutinizer Code Quality](https://scrutinizer-ci.com/g/PersonalGalaxy/Identity/badges/quality-score.png?b=master)](https://scrutinizer-ci.com/g/PersonalGalaxy/Identity/?branch=master) | [![Scrutinizer Code Quality](https://scrutinizer-ci.com/g/PersonalGalaxy/Identity/badges/quality-score.png?b=develop)](https://scrutinizer-ci.com/g/PersonalGalaxy/Identity/?branch=develop) |
| [![Code Coverage](https://scrutinizer-ci.com/g/PersonalGalaxy/Identity/badges/coverage.png?b=master)](https://scrutinizer-ci.com/g/PersonalGalaxy/Identity/?branch=master) | [![Code Coverage](https://scrutinizer-ci.com/g/PersonalGalaxy/Identity/badges/coverage.png?b=develop)](https://scrutinizer-ci.com/g/PersonalGalaxy/Identity/?branch=develop) |
| [![Build Status](https://scrutinizer-ci.com/g/PersonalGalaxy/Identity/badges/build.png?b=master)](https://scrutinizer-ci.com/g/PersonalGalaxy/Identity/build-status/master) | [![Build Status](https://scrutinizer-ci.com/g/PersonalGalaxy/Identity/badges/build.png?b=develop)](https://scrutinizer-ci.com/g/PersonalGalaxy/Identity/build-status/develop) |

Model to manage logins via password, or combined via a 2fa code.

## Installation

```sh
composer require personal-galaxy/identity
```

## Usage

The only entry point to use the model are the [commands](src/Command), you should use a [command bus](https://github.com/innmind/commandbus) in order to bind the commands to their handler.

You also need to implement the repository [interface](src/Repository/IdentityRepository.php) in order to persist the identities.

repository: PersonalGalaxy/Identity

repo_name: PersonalGalaxy/Identity


text:
#Annotations

This library aims to provide some non-obstructive validation to Dart properties.

**Note:** You are free to have invalid data in an object, this library does not give you warnings. You find out if there are errors when you call the objects `.isValid()` method only.

#Usage

Currently the library is not in a production ready state. *Help would be greatly appreciated.*

The only two annotations available right now are

`@required(message:"Value is required")` ensures the property is not `null` or `""` or an empty list or map.

`@range(min:10, max:20, message:"Value must be between 10 and 20")` ensures that the property's `.length` value or `num` value is between the specified range.

    import 'package:annotations/annotation.dart';

    class Person extends Object with Validatable {

      @required(message:"Please provide a name.")
      String name;

      @required()
      @range(min:13, max:99)
      int age;

      Person(this.name, this.age);

    }

You can use `required` and `range` annotations without using the `Validatable` mixin. However they will prove useless unless you implement your own way of checking for errors using the provided annotations.

`Validatable` basically adds methods to a class that allows it to check if the defined `Annotations` are valid.

repository: jamcoupe/dart-annotations

repo_name: jamcoupe/dart-annotations


text:
## Technical Resources

A collection of technical resources to help you develop your own solutions based on the U.S. Bank Innovation APIs.

#### Postman Collection
The Postman collection contains examples for all of the methods within the suite of U.S. Bank Innovation APIs being used for the hackathon.

The accompanying *environment* file contains all of the endpoints. However, you will need to add specific values corresponding to your own unique data sets.

For additional information, please see:
- [Using Postman files](https://interrogen.github.io/hackathon/APIs/using_postman.html)
- [Using authentication](https://interrogen.github.io/hackathon/APIs/security.html)

## Sample Code
Code snippets in different languages

### Api Interaction Code Samples

Here you can find some code snippets for Python and Java on how to set up your code to pull data from an API
using headers and auth tokens.

If you have any questions about this reach out to me or one of the mentors at the hackathon.

Please note that the authorization token does not work but to showcase where one would go when building your API call.

### Java Sample

Open the Java folder in an IDE of your choice.  The Java project is managed by Maven and a `mvn compile` will pull all the
needed dependencies for you to work on.

#### Other Notes

* The `GitHub.java` file has a better pattern to use for your API call.
* The `CatFact.java` file works but it's an anti-pattern.

### Python Example

The two Python files showcase the same pattern for calling an API with headers needed and a way without headers.
I am using the **requests** library for both of them, so once you've created your virtual environment and activated it
you can simply run `pip install -r requirements.txt` to get all the libraries I've used in this example.  Otherwise for your
project `pip install requests` will work.

### Node Example

In both examples I'm using the **axios** library to help build my request.  To run this project locally, just run `npm install` to
have node install the needed libraries.  To use this in your own library, make sure to run `npm install axios`.

### .NET (C#)

In this example I've showcased the same examples as above.  One with headers and one without headers.  This is using .NET 6
and should work across all platforms.  I'm using NewtonSoft Json to help parse the data.  To install this nuget package,
run the command `dotnet add package Newtonsoft.Json` in the terminal

### PHP Example

The recommended way to consume APIs in PHP is using the Guzzle HTTP client. To use it, first add it as a dependency in composer.

```php
composer require guzzlehttp/guzzle:^7.0
```

Next, follow the example in php/src/guzzle-example.php.
#### Notes

These examples are merely guides to help you get started.  There are much better ways to handle your calls and handle the data
that you want to send/consume.

repository: interrogen/hackathon

repo_name: interrogen/hackathon


text:
---
title: "Work Clothes"
created_at: Sat Dec  8 06:23:55 MST 2018
kind: article
tags:
  - work_clothes
  - clothes
  - clothing
---

Coveralls

  dickies.com
  Dickies Men's Duck Insulated Coveralls TV239

Dickies Men's Duck Insulated Coveralls TV239
SKU: CGDKTV239
MPN: TV239

  at Amazon
  Dickies Men's Premium Insulated Duck Coverall

Sat Dec  8 06:59:01 MST 2018 - ordered
medium/short black $73.99 at amazon
Dickies Men's Premium Insulated Duck Coverall

  at Amazon
  Dickies Men's Premium Insulated Duck Coverall

Sat Dec  8 06:50:52 MST 2018
medium/short not available

Dickies pants

  dickies.com/pants
  Loose Fit Double Knee Work Pants, Charcoal Gray

Eagles Nest amazon review

Just say no to the defective "Made in Honduras" model. Insist on the "Made in Mexico / Nicaragua", and accept nothing less.

Color: BlackSize: 32W x 34LVerified Purchase

If you get the "Made in Honduras", just send them back. They are nothing
but defective. You want the "Made in Mexico / Nicaragua." Settle for
nothing less. I have been wearing these for years and when I put these
on, I immediately noticed a coarse rough fabric that I have never
experienced with my "Made in Mexico / Nicaragua" models which I have
4 pairs of. They fold oddly and they hang on the hanger oddly, because
the fabric was processed differently, is of a different quality, and is
cut to different specifications. I typically see no difference between
the Made in Mexico or Made in Nicaragua. For some reason their Honduran
production is way off. I almost thought I received counterfeits due to
the differences being so dramatic. I then read the comments and noticed
several others have had the same gosh darn problem.

I ordered 2 pairs of this exact same model from this exact same link
in the exact same 32/34 size, but this time I got the terrible "Made
in Honduras" which had rough fabric and a weird fit. On top of that,
one pair was sewn incorrectly on the right pant leg so badly that I
can't believe it made it past quality control. It's a strong indication
that whomever is running the Honduras production for Williamson-Dickie
is doing a very poor job of ensuring quality control. In any event,
I have returned both pair as defective and will continue to do so until
I receive "Made in Mexico."

 Who
wants to do this return and wait nonsense all the time just because a
clothing manufacturer can't produce a consistent product regardless of
the point of manufacture.? Not this freaking guy...

Also, the "Made in Honduras" were a full 5 ounces lighter than the "Made
in Mexico", so there's your proof right there that they are skimping
on cotton in the Honduras factory and most likely skimping on every
other aspect of their production within that facility.

gha_language: HTML