text:
## Administration App

A simple, *slightly* dated, but fully-functional administration app can be used to manage LiteStore data stores. This app can simply be imported into a data store file and then run via LiteStore.

### Obtaining and Running the Administration App

There are two ways to get the Administration App:

* Using a pre-populated data store file
* Manually importing the [admin](class:dir) directory into any data store file

#### Using a Pre-populated Data Store File

If you are using the [data.db](class:file) data store file distributed with the pre-built LiteStore binaries, you don't have to do anything: the Administration App is already bundled in the datastore file. You simply have to run LiteStore and access the app at the following address: <http://localhost:9500/docs/admin/index.html>.

#### Importing the admin directory

If you are using your own data store file, you can still import the Administration App in it by downloading the LiteStore source files or cloning the LiteStore repository from [Github](https://github.com/h3rald/litestore) and running LiteStore with the following arguments and options from the top-level directory of the LiteStore repository:

[litestore -d:admin import](class:cmd)

Once the import is completed, you can run litestore and access the app at the following address: <http://localhost:9500/docs/admin/index.html>.

### Main Functionalities

The LiteStore Administration App is a single-page application built using the [Mithril](https://lhorie.github.io/mithril/) Javascript framework and other open source software like [Bootstrap](http://getbootstrap.com/) and the [ACE Editor](http://ace.c9.io/).

It can be used to easily access and explore any LiteStore data store (provided that it has been loaded in it) and access most of LiteStore functionalities via its HTTP API.

#### View Data Store Information

When first loaded, the app loads the _Info_ page by default. This pages contains useful information on the currently-loaded LiteStore data store, some stats on documents and tags, and links to access documents by tag.

![Info Page](images/app_info.png)

#### Read LiteStore Documentation

The **Guide** section of the Administration App contains the official LiteStore User Guide, conveniently split into separate pages by section.

> %note%
> Note
>
> If the data store is loaded in read/write mode (default), you'll see some **Edit** buttons on the Guide pages. Clicking them will open the corresponding Markdown source document for editing -- Such links have been very useful to update the docs in-place!

![Guide](images/app_guide.png)

#### Display Documents by Tag

By clicking any of the tag links on the _Info_ page or by accessing the **Tags** menu in the navigation bar you can browse all documents tagged with a specific tag. Currently, it is only possible to specify only one single tag at a time although the API allows several tags to be specified at once.

![Display documents by tag](images/app_tags.png)

#### Search Documents

You can search for documents using the search box in the navigation bar. The Administration App lets you search through all the textual/searchable documents loaded in the currently open data store.

![Search](images/app_search.png)

#### View, Preview, Delete, Create and Edit Documents

You can view, edit and delete any document loaded in the data store using the bundled [ACE Editor](http://ace.c9.io/) component. Additionally:

* It is possible to upload local files instead of creating them by hand.
* Preview is available for images and HTML documents
* Source code highlighting is available for Javascript, CSS, HTML, JSON and Markdown files.

![Document](images/app_document.png)

gha_language: Nim


text:
SpreeGopayIntegration
=====================

Spree integration with GoPay offsite payment gateway.

Spree 4.2

**note: This is my very first gem for my first project with Spree, so please have an understanding if something is not perfect. Your contribution or advice what to improve is very welcome!**

- Support only for the standard payment (https://doc.gopay.com/en/#standard-payment)
- Inline payment gateway is working only on https sites (on http works with redirect)
- There is avialable only the "Variant A" of EET handling (https://help.gopay.com/cs/tema/propojeni-do-eet/jak-funguje-napojeni-gopay-do-eet#zakladni) for the stores from Czech Republic.

## Installation

1. Add this extension to your Gemfile with this line:
  ```ruby
  gem 'spree_gopay_integration', github: '[your-github-handle]/spree_gopay_integration'
  ```

2. Install the gem using Bundler:
  ```ruby
  bundle install
  ```

3. Copy & run migrations
  ```ruby
  bundle exec rails g spree_gopay_integration:install
  ```

4. Config your Gopay account

  Don't forget to insert seller account details into `config/initializers/gopay.rb`

5. Restart your server

  If your server was running, restart it so that it can find the assets properly.

## Customisation

Payment button (and the information about payment status) is added via Deface (so you can adjust the placement of button with your own Deface rule) on the orders#show page:
```ruby
Deface::Override.new( :virtual_path => "spree/orders/show",
                      :insert_before => "#order",
                      :name => 'add_gopay_payment_button',
                      :partial => "spree/orders/gopay_status" )
```
You can also simply adjust this partial by creating your own one in app/views/spree/orders/_gopay_status.html.erb .

## Testing

**!!!

First bundle your dependencies, then run `rake`. `rake` will default to building the dummy app if it does not exist, then it will run specs. The dummy app can be regenerated by using `rake test_app`.

```shell
bundle
bundle exec rake
```

When testing your applications integration with this extension you may use it's factories.
Simply add this require statement to your spec_helper:

```ruby
require 'spree_gopay_integration/factories'
```

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
The YOLOv5（shufflev2-yolov5） object detection

This is a sample ncnn android project, it depends on ncnn library and opencv

https://github.com/Tencent/ncnn

https://github.com/nihui/opencv-mobile

## how to build and run
### step1
https://github.com/Tencent/ncnn/releases

* Download ncnn-YYYYMMDD-android-vulkan.zip or build ncnn for android yourself
* Extract ncnn-YYYYMMDD-android-vulkan.zip into **app/src/main/jni** and change the **ncnn_DIR** path to yours in **app/src/main/jni/CMakeLists.txt**

### step2
https://github.com/nihui/opencv-mobile

* Download opencv-mobile-XYZ-android.zip
* Extract opencv-mobile-XYZ-android.zip into **app/src/main/jni** and change the **OpenCV_DIR** path to yours in **app/src/main/jni/CMakeLists.txt**

### step3
* Open this project with Android Studio, build it and enjoy!

## some notes
* Android ndk camera is used for best efficiency
* Crash may happen on very old devices for lacking HAL3 camera interface
* All models are manually modified to accept dynamic input shape
* Most small models run slower on GPU than on CPU, this is common
* FPS may be lower in dark environment because of longer camera exposure time
* Phone heating or insufficient battery will cause the detection speed to decrease
* Prone to misdetection under low light conditions
*
## screenshot

This is a Redmi phone, the processor is Snapdragon 730G, and shufflev2-yolov5 is used for detection. The performance is as follows:

This is the quantized int8 model:

Outdoor scene example:

## reference
https://github.com/nihui/ncnn-android-yolov5

https://github.com/FeiGeChuanShu/ncnn-android-yolox

https://github.com/ppogg/shufflev2-yolov5

license: MIT


text:
# opendroneid-core-c

## Open Drone ID Core C Library

This repository provides a C-code function library for encoding and decoding (packing/unpacking) Open Drone ID messages, as the format is defined in the ASTM F3411 Remote ID and the ASD-STAN prEN 4709-002 Direct Remote ID specifications.
See further details in the [specifications](#relevant-specifications) section below.

Please note that both specifications have been updated during the first half of 2021 and the updated documents are not yet published (September 2021).
However, this implementation is already compliant with these updates.

The opendroneid-core-c code is meant for implementations that will broadcast the Remote ID information via Bluetooth or Wi-Fi.
If you are looking for code related to Network Remoted ID (via the internet), please take a look at https://github.com/interuss and https://github.com/uastech/standards.

Work is ongoing by the IETF DRIP (Drone Remote ID Protocol) task force to define how security could be supported in the context of the ASTM Remote ID specification:
https://datatracker.ietf.org/wg/drip/documents/ and https://github.com/ietf-wg-drip.

MAVLink messages for drone ID are available at https://mavlink.io/en/messages/common.html#OPEN_DRONE_ID_BASIC_ID and documentation on how to use them is available at https://mavlink.io/en/services/opendroneid.html.

## Receiver examples

### Android
For an example Android receiver application supporting Bluetooth and Wi-Fi, see https://github.com/opendroneid/receiver-android.

### iOS
Currently there is no open source iOS receiver application for Apple devices.
However, reception of Bluetooth 4 Legacy Advertising drone ID signals have been demonstrated to work on iOS.
Apple currently does not expose suitable APIs to receive any other transmission method for drone ID signals than BT4 legacy advertising. I.e. current versions of iOS (up to and including 15) do not support receiving BT5 Long Range + Extended Advertising, Wi-Fi NaN nor Wi-Fi Beacon.

### WireShark
Examples on how to use the WireShark PC application to pick up and dissect open drone ID messages are available here: https://github.com/opendroneid/wireshark-dissector.

## Transmitter examples

### ESP32
An example library for transmitting Open Drone ID signals from ESP32 HW can be found at https://github.com/sxjack/uav_electronic_ids.
The implementation supports simultaneous transmission via Bluetooth Legacy Advertising, Wi-Fi NaN and Wi-Fi Beacon.

Please note that the ESP32 HW only supports transmitting Bluetooth Legacy Advertising signals. Bluetooth Long Range and Extended Advertising are not supported.
Please check if this is sufficient to comply with the rules that apply in the area in which you are flying.
The [ESP32-C3](https://www.espressif.com/en/news/ESP32_C3) and [ESP32-S3](https://www.espressif.com/en/news/ESP32_S3) chips will both support Long Range and Extended Advertising but this has not yet been tested.

### Linux
A Wi-Fi NaN transmitter implementation for Linux is available [here](https://github.com/opendroneid/opendroneid-core-c/blob/master/wifi/sender/main.c).
Better documentation is needed on what exact HW + SW environment this is functional.

A simple application for sending static drone ID data via Bluetooth 4 and 5 and via Wi-Fi Beacon is available [here](https://github.com/opendroneid/transmitter-linux).
This has tested to work reasonably okay on one CometLake motherboard and partly okay on RaspberryPi 3B and 4 HW.

### nRF and TI Bluetooth chipsets
Transmitter implementations for Bluetooth 4 and 5, based on either the TI CC2640 or the nRF52480 SoCs are known to exist, but so far none have been open sourced.
Please open an issue if you have an implementation you are willing to share.
A new repository under opendroneid can be made.

## How to Build

To build the library and the sample app on Linux:

```
sudo apt-get install libgps-dev libnl-genl-3-dev
git submodule update --init
mkdir build && cd build
cmake ../.
make
```

The outputs will be `libopendroneid/libopendroneid.so` and the `test/odidtest` sample application.

The sample application will do a test encode/decode, then continuously generate sample messages.

The intended architecture is to take whatever input you wish, and to put it into the nominal structures as defined in `libopendroneid/opendroneid.h`.

## Build Options

### Memory reductions

Some embedded systems might require a smaller memory footprint than what by default is used by opendroneid-core-c.
The following compile time options exists for reducing the memory consumption:
- ODID_AUTH_MAX_PAGES is by default configured to support 16 pages/messages of authentication data.
  See the beginning of [opedroneid.h](libopendroneid/opendroneid.h).
  If authentication messages are not used, this value can be configured between 1 and 16, e.g. by adding `-DODID_AUTH_MAX_PAGES=1` when calling cmake.

- When including MAVLink in the build (see below), if MAVLink's virtual channel functionality is not used, some memory can be saved by defining MAVLINK_COMM_NUM_BUFFERS to be equal to 1, before including mavlink_types.h
  See further details in the beginning of [mav2odid.c](libmav2odid/mav2odid.c).

### MAVLink

MAVLink OpenDroneID support is included by default.

To disable, use the ```BUILD_MAVLINK``` parameter, i.e.:

```
cmake -DBUILD_MAVLINK=off .
```

MAVLink support requires the mavlink_c_library_v2 to be installed in the respective folder

### Wi-Fi NaN example implementation

The Wi-Fi NaN example implementation is built by default.

To disable, use the ```BUILD_WIFI``` parameter, i.e.:

```
cmake -DBUILD_WIFI=off .
```

It requires the libgps, libnl-3 and libnl-genl-3 support. Install the dependencies on your build host, e.g. on Debian/Ubuntu use

```
sudo apt-get install libgps-dev libnl-genl-3-dev
```

If available, the Wi-Fi reference implementation will link against libnl-tiny instead of libnl*-3 if available.

## Architecture

![Core SDK Scope](img/core-arch.png "Core SDK Scope")

These are nominal (non-encoded) structures:

```
ODID_BasicID_data
ODID_Location_data
ODID_Auth_data
ODID_SelfID_data
ODID_System_data
ODID_OperatorID_data
ODID_MessagePack_data
```

The SDK functions will encode to (or decode from) the following structures:

```
ODID_BasicID_encoded
ODID_Location_encoded
ODID_Auth_encoded
ODID_SelfID_encoded
ODID_System_encoded
ODID_OperatorID_encoded
ODID_MessagePack_encoded
```

Once you have the encoded data, then you are ready to assemble and transmit over any of the acceptable broadcast methods in Open Drone ID.

The primary SDK calls are the following:

```
int encodeBasicIDMessage(ODID_BasicID_encoded *outEncoded, ODID_BasicID_data *inData);
int encodeLocationMessage(ODID_Location_encoded *outEncoded, ODID_Location_data *inData);
int encodeAuthMessage(ODID_Auth_encoded *outEncoded, ODID_Auth_data *inData);
int encodeSelfIDMessage(ODID_SelfID_encoded *outEncoded, ODID_SelfID_data *inData);
int encodeSystemMessage(ODID_System_encoded *outEncoded, ODID_System_data *inData);
int encodeOperatorIDMessage(ODID_OperatorID_encoded *outEncoded, ODID_OperatorID_data *inData);
int encodeMessagePack(ODID_MessagePack_encoded *outEncoded, ODID_MessagePack_data *inData);

int decodeBasicIDMessage(ODID_BasicID_data *outData, ODID_BasicID_encoded *inEncoded);
int decodeLocationMessage(ODID_Location_data *outData, ODID_Location_encoded *inEncoded);
int decodeAuthMessage(ODID_Auth_data *outData, ODID_Auth_encoded *inEncoded);
int decodeSelfIDMessage(ODID_SelfID_data *outData, ODID_SelfID_encoded *inEncoded);
int decodeSystemMessage(ODID_System_data *outData, ODID_System_encoded *inEncoded);
int decodeOperatorIDMessage(ODID_OperatorID_data *outData, ODID_OperatorID_encoded *inEncoded);
int decodeMessagePack(ODID_UAS_Data *uasData, ODID_MessagePack_encoded *pack);
```

Specific messages have been added to the MAVLink message set to accommodate data for Open Drone ID implementations:

https://mavlink.io/en/messages/common.html#OPEN_DRONE_ID_BASIC_ID

The functions in `mav2odid.c` can be used to convert these MAVLink messages into suitable `opendroneid.h` data structures and back again. See the example usages in `test/test_mav2odid.c`.

Recommendations on how to utilize the MAVLink messages for UAS internal distribution of Open Drone ID data of an Unmanned Aircraft System (UAS) can be found here:
https://mavlink.io/en/services/opendroneid.html

## Relevant specifications

### United States

The ASTM F3411 Specification for Remote ID and Tracking has been defined to specify how Unmanned Aircraft (UA) or Unmanned Aircraft Systems (UAS) can publish their ID, location, altitude etc., either via direct broadcast (Bluetooth or Wi-Fi), or via an internet connection to a Remote ID server.

Version 1.0 (F3411-19) of the specification is currently [available](https://www.astm.org/Standards/F3411.htm).
An updated version 1.1 (F3411-21?) is in the final stages of being finalized (September 2021).
It contains smaller changes/additions to make the message content etc. better suited to meet the [rule](https://www.regulations.gov/document/FAA-2019-1100-53264) defined by the [FAA](https://www.faa.gov/uas/getting_started/remote_id/) (Federal Aviation Administration) for [UAS flights](https://www.faa.gov/uas/commercial_operators/operations_over_people/) in the United States.
Additionally, a Means of Compliance document (MoC) is being drafted by the ASTM, containing further implementation requirements and test specifications.
Together, the two documents will allow manufacturers of UAS and remote ID broadcast modules/Add-ons (for retro-fit on UAs without built-in remote ID support) to implement remote ID support and create the necessary Declaration of Compliance (DoC) document, which must be submitted to the FAA for approval.

### European Union

To meet the European Commission Delegated Regulation [2019/945](https://eur-lex.europa.eu/eli/reg_del/2019/945/2020-08-09) and the Commission Implementing Regulation [2019/947](https://eur-lex.europa.eu/eli/reg_impl/2019/947/2021-08-05), ASD-STAN has developed the prEN 4709-002 Direct Remote Identification specification.
It specifies broadcast methods for Remote ID (Bluetooth and Wi-Fi) that are compliant with the ASTM F3411 specification.
See the summary [whitepaper](https://asd-stan.org/wp-content/uploads/ASD-STAN_DRI_Introduction_to_the_European_digital_RID_UAS_Standard.pdf) and the recording of this [webinar](https://www.cencenelec.eu/news-and-events/events/2021-02-09-european-workshop-on-uas-direct-remote-identification/).
The final version is not yet published (September 2021).
An earlier draft is available [here](https://asd-stan.org/downloads/din-en-4709-0022021-02/).
Be aware, that multiple changes were done after this draft version was made available and it should not be used as a reference for any implementations.

### Comparison

A comparison of some of the more detailed parts of each specification and rule is given in the table below.
If a field is left blank, nothing specific is mentioned in the particular document related to that part.

The rules are what is defined by law and must be followed (the FAA rule in the United States and the EU rule in the European Union).
The ASTM Means of Compliance (MoC) document overrides certain parts of the ASTM specification to meet the FAA rule requirements.

| | FAA rule | ASTM v1.1 | ASTM MoC | EU rule | ASD-STAN DRI |
| --- | --- | --- | --- | --- | --- |
| Serial ANSI/CTA-2063-A | M1 |  M1 | M1 | M | M |
| Session ID | M1 | M1 | M1 |  | O |
| UA dynamic position | M | M |  | M | M |
| UA altitude WGS-84 | M | M |  |  | O |
| UA altitude AGL/Take-off |  | O |  | M | M |
| Timestamp | M | M |  | M | M |
| Operational/Emergency status | M2 | O | M2 | M2 | M2 |
| Track direction | M | M |  | M | M |
| Horizontal speed | M | M |  | M | M |
| Vertical speed | M | M |  |  | O |
| Operator registration ID |  | O |  | M | M |
| EU Category & Class |  | O |  |  | R |
| Operator dynamic position | M3 | O | M3 | M3 | M3 |
| Operator altitude WGS-84 | M | O | M |  | O |
| Transmission interval4 (seconds) | 1 | 1 or 3 | 1 |  | 1 or 3 |
| Transmission time | Take-off to shutdown |  | Take-off to shutdown |  | When airborne |
| BT4 Legacy Advertising |  | M5 | M6, 7 |  | O |
| BT5 Long Range |  | O | M6, 7 |  | M5 |
| Wi-Fi NaN 2.4 GHz |  | M5 |  |  | M5 |
| Wi-Fi NaN 5 GHz |  | O |  |  | M5 |
| Wi-Fi Beacon 2.4 GHz8 |  | M5 | M7 |  | M5 |
| Wi-Fi Beacon 5 GHz8 |  | M5 | M7 |  | M5 |

M: Mandatory. O: Optional. R: Recommended

1. Either the Serial Number or the Session ID must be transmitted.
    Add-ons are not allowed to use Session ID.
2. Not required for Add-ons.
3. For Add-ons under EU rule: the Take-off location can be used instead.
    For Add-ons under FAA rule: The Take-off location is required instead.
4. Concerns only the Basic ID, Location and System messages.
    Location is always with 1 second intervals.
    Basic ID and System intervals can be 3 seconds in the specifications.
5. Only one of the Mandatory broadcast methods is required.
6. Both BT4 and BT5 must be transmitted simultaneously.
7. Only Bluetooth (BT4 + BT5 simultaneously) or Wi-Fi Beacon (2.4 GHz or 5 GHz) are allowed.
8. If any other channel than Channel 6 on 2.4 GHz or Channel 149 on 5 GHz is used, a faster transmission rate of 5 Hz is required.

repository: DheerajJadhav/opendroneid-core-c

repo_name: DheerajJadhav/opendroneid-core-c


text:
# ApkPure Api Enpoint ✨
Search, Simplify detail & Downloadable from Apkpure.com

[![Python](https://img.shields.io/badge/Python-3.6%20%7C%203.7-brightgreen.svg)](pytho.org)
[![License](https://img.shields.io/badge/MIT-License-blue.svg)](https://opensource.org/licenses/MIT)
___
## Features
1. Simply to use
2. Readable
3. Using async request & multithreading for really fast request (not really sure)
4. Easy accessing dictionary

## Installing
- `git clone https://github.com/kurodenjiro/api.apkpure`
- `cd api.apkpure`
- `pip3 install -r requirements.txt`

## Start Server
```python
python3 main.py
```
## API document
### Search
```Http
GET localhost:5000/query?search=<query string>
```

### Get Detail
```Http
GET http://localhost:5000/appDetail?url=<url app>

#Example : /pubg-tencent-1i/com.tencent.ig
```
### Get Trending
```Http
GET http://localhost:5000/trending
```

## How to
```python
from apis import ApkPure

apk = ApkPure(return_as="dict")
#set 'dict' or 'rpc' for returning as
```
### Search Application
```python
search = api._search("pubg")
print(search)
```

### Get Details from giving url
```python
details = api.detail_from_url(search.results[0].url)
print(details)

# or you can get position of array when return data
search = api._search("pubg")
detail = api._detail(search, 1)
print(detail)
```
### Get Trending
```python
trending = api._trending()
print(trending)
```

### Download application
```python
download = api._download(url=detail.url_download, name=detail.title, ex=detail.extension, path="/downloads)
```

# Author
Kuro / [Kuro](https://github.com/kurodenjiro)
=======
# api.apkpure


text:
# VIMzheimer

VIMzheimer is a ideas repository local, about how can you use vim everyday.
https://log.andresaquino.sh/

## Everyday working with VIM

## History (yes, wikipedia)

## VIMLovers

## 01. Everyday working with VIM: Vertical Split

## 02. Everyday working with VIM: Horizontal Split

## 03. Everyday working with VIM: Scrollbinding

## 04. Everyday working with VIM: Automagical Headers

## 05. Everyday working with VIM: EditorConfig

## 06. Everyday working with VIM: Ultisnips + SuperTab

## 07. Everyday working with VIM: CtrlP

## 08. Everyday working with VIM: DelimitMate + VIM-Matchup

## 09. Everyday working with VIM: IndentLine + VIM-Autoformat

## 10. Everyday working with VIM: VIM-fugitive + Gist + VIM-gitgutter

## 11. Everyday working with VIM: Using Diff and merge

## 12. Everyday working with VIM: A more confortable information tool

## VIM Cheatsheet

## References

repository: andresaquino/VIMzheimer

repo_name: andresaquino/VIMzheimer


text:
# react-webpack-babel
How to use ReactJS with Webpack 4, Babel 7, and Material Design by Nazare Emanuel Ioan

source:
https://medium.freecodecamp.org/how-to-use-reactjs-with-webpack-4-babel-7-and-material-design-ff754586f618

repository: kjonathante/react-webpack-babel

gha_language: HTML

gha_license_id: MIT

repo_name: kjonathante/react-webpack-babel


text:
# README

Breakdown: Used Shodan API to take advantage of many query functions. Built on REST API which allows for collection of information

 - Started August 28, 2020

Different webcam technologies have different default usernames and passwords

List of many different accessible shodan cameras: default username / default password

  ACTi: admin/123456 or Admin/123456

  Axis (traditional): root/pass,

  Axis (new): requires password creation during first login

  Cisco: No default password, requires creation during first login

  Grandstream: admin/admin

  IQinVision: root/system

  Mobotix: admin/meinsm

  Panasonic: admin/12345

  Samsung Electronics: root/root or admin/4321

  Samsung Techwin (old): admin/1111111

  Samsung Techwin (new): admin/4321

  Sony: admin/admin

  TRENDnet: admin/admin

  Toshiba: root/ikwd

  Vivotek: root/<blank>

  WebcamXP: admin/ <blank>

Searching for countries with the layoung country:"2 letter country code"

Iran = "IR"
China = "CN"
Russia = "RU"

- August 31, 2020

Familiarized myself with Node.js syntax and structure, have never programmed in Node.js before

Links for practice:

https://www.w3schools.com/nodejs/

https://www.tutorialsteacher.com/nodejs/nodejs-tutorials

- September 1, 2020

Cloned the Shodan API and began understanding what was going on

With the generation of the API key for an account, started with tests folder and different async tasks
Focusing on webcamx webcameras that have open port
Filtering on countries and retaining the IP address

async search function was very crucial in early development
query -> string that normally would type into the search bar of shodan.io

returns host results which allowed for async host to be used

async hosts returns the services

- September 2, 2020

Began writing tests in the test directory to search for webcamxp
Results were not what was expected as output was returned to Terminal but in an unconventional format
Tried to find a way to parse the information so it is readable to the user

Essentially was trying to output a file that would contain:

Country of Origin
IP Address
Available ports
Webcam technologies used at each port

This would then allow whoever is lookin for webcams to get a list of all valid potential cameras with all the information required to look up in the URL search bar

Type in the IP address followed by the port number, to the lead to potential camera. With the type of webcam listed user would just have to input default username and password
in hopes of logging in if credentials required

- September 3, 2020

Ran into 2 issues
 1. All tries for trying to make the information readable lead to crashes in code, I myself wasn't sure if my tests were working properly because of it. I was going to try to
    continue debugging the code until a file with all the information was readable but realized Shodan-API is not applicable to CTHULU machine. Script requires a large
    repositiry of files to run. From what I remembered from the CTHULU machine, all scripts were a single file capable of performing the task.
 2. Had to restart the process using Shodan CLI but now have to relearn the features and functionalities;
    New Repository created for this.


text:
# Scroll-Action

## Feature

Allows the user to scroll through all the levels (lower, current, and higher).

## Acceptance Criteria

### Scenario: The user wants to see the completed levels or wants to see the locked levels

  Given the user is on levels screen

  When user scrolls up or down

  Then display lower/higher levels based on scroll direction.


text:
## VERA platform screenshots

You can see this in action
* at [demo.vera.jobs](https://demo.vera.jobs);
* watch [screencast](https://www.youtube.com/playlist?list=PLGRpxDadlmTP4SHkzDI_bu3AGFySxHipb) covering the entire hiring cycle (no sound, sorry).

**[back to README](README.md)**
___
Index page and login form
![Index and login form](img/screenshots/00_Index.png)

___
Vacancies search result
![Vacancies search result](img/screenshots/01_Vacancies.png)

___
Vacancy details
![Vacancy details](img/screenshots/02_Vacancy.png)

___
Candidate's blockchain artifacts
![Candidate's blockchain artifacts](img/screenshots/03_Profile_Blockchain_info.png)

___
Candidate's facts and their confirmations

To be refactored to claims/badges principles in v3.0
![Candidate's facts](img/screenshots/04_Profile_facts.png)

___
Candidate's profile
![Candidate's profile](img/screenshots/05_Profile.png)

___
Candidate's blockchain transactions
![Candidate's blockchain transactions](img/screenshots/06_User_transactions.png)

___
Vacancy details represented for the candidate.

Vacancy pipeline shown and **Apply** button is available.
![Vacancy pipeline](img/screenshots/07_Vacancy_Blockchain_info.png)

___
Blockchain artifact of the company - smartcontract.
![Company smartcontract](img/screenshots/08_Company_Blockchain_Info.png)

___
Company profile
![Company profile](img/screenshots/09_Company.png)

___
New vacancy form, 1st step.
![New vacancy](img/screenshots/10_New_Vacancy.png)

___
Quizz constructor (available for company's recruiter)
![Quizz constructor](img/screenshots/11_Quizzes.png)

**[back to README](README.md)**

repository: iamgrewal/VeraWebApp

repo_name: iamgrewal/VeraWebApp


text:
# 2048

[![Build Status](https://travis-ci.org/Robert-96/2048.svg?branch=master)](https://travis-ci.org/Robert-96/2048)

2048 is played on a gray 4×4 grid, with numbered tiles that slide when a player moves them using the four arrow keys.

[Play it here!](https://robert-96.github.io/2048)

## Screenshot

![Screenshot](./src/public/screenshot.png)

## License

This project is licensed under the [MIT License](./LICENSE).


text:
# heroku-buildpacks-sourceversion
Writes the SOURCE_VERSION variable (usually the Git SHA) to a file for use by the app.

Originally created by @sreid – with very minor updates by @cristiano2lopes – out of the need to show which Git commit version of an app was running on a Heroku instance. Made possible by the [addition of the SOURCE_VERSION variable during the build process](https://devcenter.heroku.com/changelog-items/630). This variable is available during the build process, but not available to a running app, making this approach neccessary. Suggestions and improvements appreciated!

## Usage
To use this buildpack, the app should already be successfully running the [multi buildpack](https://github.com/heroku/heroku-buildpack-multi).

Then just add this buildpack in addition to the existing buildpacks in the `.buildpacks` file:

	https://github.com/cristiano2lopes/heroku-buildpack-sourceversion.git

In the application code, read the `.commit_hash` file that will be created on deployment.

## License
MIT

gha_language: Shell


text:
Arduino library for creating hexdumps from program memory and view these on the serial monitor.

Initially designed for ESP8266, therefore uses `printf()` instead of standard Arduino `print()` and `println()` methods.
`printf()` is more flexible and more powerful but uses more memory which should be less of an issue on modern 32-bit microcontrollers.

For some microprocessor platforms / Arduino cores `printf()` needs to be explitly enabled. For others like ESP32 and ESP8266 this is default enabled.

repository: lnlp/Hexdump

repo_name: lnlp/Hexdump


text:
resque-unique-job
===============
Depends on [Resque](http://github.com/defunkt/resque/) 1.8

About
-----
This is a gem that will prevent multiple of the same job being enqueued
with resque.

It works by overriding the JobClass.enqueue method so you need to define a base
class that defines self.enqueue before extending the plugin.

Examples
--------

    class BaseJob
      def self.enqueue(*args)
        Resque.enqueue(self, *args)
      end
    end

    class MyJob < BaseJob
      extend Resque::Plugins::UniqueJob

      def self.perform(*args)
        #do stuff
      end
    end

Requirements
------------
* [resque](http://github.com/defunkt/resque/) 1.8

repository: engineyard/resque-unique-job

extension: markdown

repo_name: engineyard/resque-unique-job


text:
# Coding Website

This is a coding website build only from Html and Css.

## Installation

I made this back in 2018 using Visual Studio Code. You guys can use any ide of your choice. But Visual Studio Code is recommended for all.

## Usage
I build this website from scratch using Html and CSS only. This was a good opportunity for me to review and practice my skills which I learned in HTML and CSS chapters.
## Features
Header\
Search Box(Style input color)\
Icons\
Menu (Background + Links + Transitions)\
Complete concepts of padding and margins\
Beautiful Content Box (Header + Paragaraph + Styling)\
Side Bars including list of items
Footer

```

## Contributing
Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.

Please make sure to update tests as appropriate.

## License
[MIT](https://choosealicense.com/licenses/mit/)

repository: iQaiserAbbas/CodingWebsite

repo_name: iQaiserAbbas/CodingWebsite


text:
# typescript-library-starter-kit

This starter kit contains a basic Typescript project for creating a Javascript library

# Prerequisites

Install NodeJs
```
brew install node
```

Install Typescript
```
npm install typescript -g
```
Install Typescript lint
```
npm install tslint
```

Install dependencies:
```
npm install
```
# Tests

Includes
- Joi (https://github.com/hapijs/joi) for object schema validation and
- Rosie (https://github.com/rosiejs/rosie) for test events generation

To run:
```
npm test
```
To check coverage:
```
npm run test:coverage-check
```

# Build Steps

This starter kit uses Rollup (https://rollupjs.org/guide/en) for module bundling

Build library. NOTE: Update test coverage requirements
```
npm run build
```

This will build the

Publish library
```
npm publish

```
This will publish a CommonJS module and a ES module in the `./dist` directory

# Library Usage

CommonJS:
```
const Test = require('typescript-library-starter-kit').Test

Test.test(payload)
```

ES:
```
import { Test } from 'typescript-library-starter-kit'

Test.test(payload)
```

# License

This project is released under The Unlicense, your free to copy this and do what you like.

license: Unlicense

repository: ryanwkan/typescript-library-starter-kit

repo_name: ryanwkan/typescript-library-starter-kit


text:
**NOTE:** This package has been consolidated into the [`vega/vega`](https://github.com/vega/vega) repository, where future development and issues will be handled. This repository has been archived and is now read-only.

# vega-projection-extended

Extended projections for cartographic mapping.

This module extends Vega's set of cartographic projections with those provided by the [d3-geo-projection](https://github.com/d3/d3-geo-projection) library. See the `index.js` file for the complete list of imported projections.

## Usage Instructions

To use this module in a web application, include the appropriate compiled JavaScript file as a script import on a web page. The library produces two output files:

1. `vega-projections.js` contains all extended projections plus required methods from the [d3-array](https://github.com/d3/d3-array) and [d3-geo](https://github.com/d3/d3-geo) libraries.
2. `vega-projections-core.js` contains the extended projections only and expects a stand-alone version of D3 to have already been imported.

If you are using the standard `vega.js` or `vega.min.js` builds, include the following _after_ Vega has been imported:

```html
  <script src="vega-projections.js"></script>
```

If you are using a standalone version of D3 (for example, alongside `vega-core.js` or `vega-core.min.js`), you can use the smaller file instead:

```html
  <script src="vega-projections-core.js"></script>
```

repository: vega/vega-projection-extended

repo_name: vega/vega-projection-extended


text:
# header

pico?

* I have a pen.

- I have a apple.

+ **apple pen.**

- [ ] I have a pen.

1. I have pineapple.

- [x] pineapple pen.

_____________________________________

```java
String hoge = "apple pen?";
```

> pineapple pen?

| _one_ | **two** | ~~three~~ | [four] |
|:---:|:---:|:---:|:---:|
| pen | pineapple | apple | pen |

h2
-----------------------------------------------

dt
: dd
: dd

    HOGE
    hogege

h1
==============================================

* one
  * two
    * three
      * four
        * five
          * six
            * seven
              * eight
                * nine
                  * ten

repository: uduki-oh-yeah/atom-gl-md-syntax

repo_name: uduki-oh-yeah/atom-gl-md-syntax


text:
# MobX CrossTab

A tiny [MobX] module to synchronize state between browser tabs.

The size is only 249 bytes. It uses [Size Limit] to control size.

[mobx]:https://github.com/mobxjs/mobx
[size limit]: https://github.com/ai/size-limit

## Install
This module has peer dependencie of `mobx` which will has to be installed as well.
```sh
npm install mobx-crosstab
```

## How to use

By default `crossTab` function accept your state and apply it to `observable` function of `mobx` so you don't need to do it by yourself. This function return observable like `observable` function of `mobx` does

```javascript
import { observable } from 'mobx';
import crossTab from 'mobx-crosstab';

const store = crossTab('count', { count: 0 });
```

If you need to use another type of observation (ex. `deep`, `box`) you can create `observable` separately and pass it to the `crossTab` function

```javascript
import { observable } from 'mobx';
import crossTab from 'mobx-crosstab';

const store = observable.deep({ count: 0 });
crossTab('count', store);
```

Also, you can use `crossTab` functions with class properties

```javascript
import { observable } from 'mobx';
import crossTab from 'mobx-crosstab';

class TodoStore {
  todos = crossTab('todos', []);
}
```

```javascript
import { observable } from 'mobx';
import crossTab from 'mobx-crosstab';

class TodoStore {
  @crossTab('todos')
  @observable
  todos = [];
}
```

```javascript
import { observable } from 'mobx';
import crossTab from 'mobx-crosstab';

class TodoStore {
  @crossTab
  @observable
  todos = [];
}
```

## API Reference

repository: distolma/mobx-crosstab

gha_language: JavaScript

repo_name: distolma/mobx-crosstab


text:
# NotHotdog

Detects hotdogs or not hotdogs.

![alt text](jinjiang.jpg "ISSA HOTDOG!")

## Install dependencies

```
npm install
```

## Setup

Edit `config.js` with:

Add a random string here `FACEBOOK_VERIFY_TOKEN`. It is needed to set the webhook if you don't know how to deal with the verification process.

`FACEBOOK_PAGE_TOKEN` is needed to give your bot permission to response with a message.

`AWS_ACCESS_KEY_ID` and `AWS_SECRET_ACCESS_KEY` is needed to talk to the amazon API.

*Btw you need a AWS account.*

## Run it

```
node index.js
```

*If you dont have nodejs installed, you should take care of that first.*

repository: gravmatt/nothotdog

repo_name: gravmatt/nothotdog


text:
# sit22005-201801-midterm
> Note: Please read and follow these instructions carefully. Failure to follow the instructions may result in penalties for your grades.
> 1. This exam is open everything, but you shall not communicate with anyone using any means such as talking, email, chatting, etc.
> 2. Answers submitted after the exam are not accepted.
> 3. Read and follow the instructions for each question.
> 4. There are five problems. Read the problem description carefully and give the right answer.

# Important!!
If your code has syntax errors so that the TA cannot compile your code, you will get 0 point.
Please make sure that your code does not have compile errors.
If your code can be compiled and executable, which means it does not have runtime error, you will get 5 points.

## Problem01
True/False Questions.

## Problem02
Programming Problem: Fixing syntax error.

## Problem03
Programming Problem: Fix the semantic error.

## Problem04
Computational Thinking

## Problem05
Develop the program.


text:
---
parent: Commands
title: modular build
---

# `modular build [options] [packages...]`

Search workspaces based on their `name` field in the `package.json` and build:

- Modular packages them according to their respective `modular.type`.
- Non-Modular packages (i.e. packages without a `modular` configuration) only if
  they have a `build`
  [script](https://docs.npmjs.com/cli/v9/configuring-npm/package-json#scripts),
  by running `yarn build` on the package's
  [workspace](https://classic.yarnpkg.com/en/docs/cli/workspace).

Packages are always built in order of dependency (e.g. if a package `a` depends
on a package `b`, `b` is built first). Packages may be built concurrently when
possible. The maximum concurrency level defaults to the number of CPUs available
on the machine, but can be set by the user (see the `--concurrencyLevel`
option).

The output directory for built artifacts is `dist/`, which has a flat structure
of modular package names. Each built app/view/package is added to the `dist/` as
its own folder.

When `packages` is empty and no selective options have been specified (for
example when running `yarn modular build`), all packages in the monorepo will be
built. When `packages` contains one or more non-existing package name, the
non-existing packages will be ignored without an error. If any package or
selective option have been defined but the final set of regular expressions is
empty, Modular will write a message to `stdout` and exit with code `0`.

For views and packages, package names are transformed to `Param case` (e.g.
this-is-param-case) in `dist/`

(i.e. `modular build @scoped/package-a` will output built artifacts into
`dist/scoped-package-a`)

## Options:

`--private`: Allows the building of private packages.

`--preserve-modules`: Preserve module structure in generated modules.

`--changed`: Build only the packages whose workspaces contain files that have
changed. Files that have changed are calculated comparing the current state of
the repository with the branch specified by `compareBranch` or, if
`compareBranch` is not set, with the default git branch.

`--compareBranch <branchName>`: Specify the comparison branch used to determine
which files have changed when using the `changed` option. If this option is used
without `changed`, the command will fail.

`--descendants`: Build the packages specified by the `[packages...]` argument
and/or the `--changed` option and additionally build all their descendants (i.e.
the packages they directly or indirectly depend on) in dependency order.

`--ancestors`: Build the packages specified by the `[packages...]` argument
and/or the `--changed` option and additionally build all their ancestors (i.e.
the packages that have a direct or indirect dependency on them) in dependency
order.

`--concurrencyLevel <level>`: Limit the concurrency of build processes that are
executed in different processes within build batches. 0 or 1 means no
concurrency. If not specified, this option defaults to
[the number of logical CPUs](https://nodejs.org/api/os.html#oscpus) available on
the machine, or 1 if that information is not available.

## Dependency selection and build order examples

We'll be using this package manifests in our Modular monorepo for the following
examples:

```js
{
  "name": "a",
  "dependencies": {
    "b": "*",
    "c": "*",
    "react": ">16.8.0",
    // ...
  }
}

{
  "name": "b",
  "dependencies": {
    "c": "*",
    "react": ">16.8.0",
    // ...
  }
}

{
  "name": "c",
  "dependencies": {
    "d": "*",
    // ...
  }
}

{
  "name": "d",
  "dependencies": {}
}

{
  "name": "e",
  "dependencies": {
    "a": "*",
    // ...
  }
}
```

Which internally are filtered into this set of `WorkspaceDependencyObject`s:

```js
{
  a: { workspaceDependencies: ['b', 'c'] },
  b: { workspaceDependencies: ['c'] },
  c: { workspaceDependencies: ['d'] },
  d: { workspaceDependencies: undefined },
  e: { workspaceDependencies: ['a'] }
}
```

### Example: local workflow with descendants

Let's say we just pulled an update to our monorepo and we want to work on
workspace `b`. To be able to work with the last modifications we pulled, we want
to build `b` and all the other workspaces that `b` depends on (descendants),
either directly or indirectly. We can tell Modular that we want to build `b` and
its all descendants by using this command:

`modular build b --descendants`

Modular will first select all the descendants of `b` (according to the previous
graph: `c` because it'a direct dependency and `d` because it's a dependency of
`c`), then build them in the correct build order, where workspaces depended on
are built before workspaces that depend on them, recursively. In this example:

- `d` gets built first, because it has no dependencies
- `c` can now get built, because it only depends on `d`, that got built in the
  previous step.
- `b` can now get built, because it only depends on `c`, that got built in the
  previous step.

### Example: incremental builds with ancestors

Let's suppose we're building a PR of our monorepository on a CI pipeline, and we
want to incrementally build the workspaces that have code changes compared to
the base branch. Since those workspaces will generate new, different build
artefacts, we can't just build them and call it a day; we also need to re-build
all the workspaces that depend on the changed workspaces, and those who depend
on them, and so on. In other words, we need a way to tell Modular to build the
ancestors of the changed workspaces. This command:

`modular build --changed --ancestors`

will identify all the workspaces that have changed compared to the
`--compareBranch` (which is the repository's base branch by default), then
identify all the workspaces which directly or indirectly depend on them
(ancestors) and build the resulting set of packages in the correct build order,
where workspaces depended on are built before workspaces that depend on them,
recursively. If we suppose that workspaces `b` and `c` have changed, Modular
will:

- Select all ancestors of `b` and `c`, which are `a` (because it depends on
  both) and `e` (because it depends on `a`).
- Build `c` first, because it doesn't depend on any package that has changed (it
  only depends on `d`, which is not in the changed set).
- Build `b`, because it only depends on `c`, that got built in the previous
  step.
- Build `a`, because it depends on `b` and `c`, that got built in the previous
  steps.
- Build `e`, because it only depends on `a`, that got built in the previous
  step.

## Non-Modular packages

Packages without a `modular` configuration are built only if they have a `build`
[script](https://docs.npmjs.com/cli/v9/configuring-npm/package-json#scripts) in
their `package.json`. For example, if you have a Modular package named "app" of
type `app` that imports a simple non-Modular package called
"non-modular-buildable" that is able to build itself using `tsc`:

### packages/non-modular-buildable/package.json

```json
{
  "name": "non-modular-buildable",
  "private": false,
  "scripts": {
    "build": "tsc --skipLibCheck"
  },
  "files": ["dist", "src"],
  "main": "./dist/index.js",
  "version": "1.0.0"
}
```

### packages/non-modular-buildable/src/index.ts

```ts
export default function add(a: number, b: number): number {
  return a + b;
}
```

### packages/non-modular-buildable/tsconfig.json

```json
{
  "include": ["src"],
  "compilerOptions": {
    "target": "es2018",
    "outDir": "dist",
    "lib": ["dom", "esnext"],
    "declaration": true,
    "moduleResolution": "node",
    "sourceMap": true,
    "strict": true,
    "esModuleInterop": true
  }
}
```

### packages/app/src/App.tsx

```tsx
import * as React from 'react';
import sum from 'non-modular-buildable';
import logo from './logo.svg';
import './App.css';

function App(): JSX.Element {
  return (
    <div className="App">
      <header className="App-header">
        <img src={logo} className="App-logo" alt="logo" />
        <p>This is the sum:</p>
        <p>
          <code>7 + 7 = {sum(7, 7)}</code>
        </p>
        <a
          className="App-link"
          href="https://reactjs.org"
          target="_blank"
          rel="noopener noreferrer"
        >
          Learn React
        </a>
      </header>
    </div>
  );
}

export default App;
```

`yarn modular build` will, in this order:

1. Build `non-modular-buildable` by calling
   `yarn workspace non-modular-buildable build` and waiting for the spawned
   process to terminate successfully
2. Build `app` using Modular's build scripts and configuration, bundling the
   previously built `non-modular-buildable` dependency

Please note that Modular merely works as a task runner when building non-modular
packages: it's your responsibility to ensure that the `build` script works and
that your `package.json` is correctly configured to export the right functions
in the right format.

repository: jpmorganchase/modular

branch_name: refs/heads/main

gha_language: TypeScript

repo_name: jpmorganchase/modular


text:
# CDN Cache Invalidation Tool
[![Go Report Card](https://goreportcard.com/badge/github.com/artemnikitin/cci)](https://goreportcard.com/report/github.com/artemnikitin/cci)   [![codebeat badge](https://codebeat.co/badges/41e5be9d-a578-4bd0-87d4-5ffc564e38f0)](https://codebeat.co/projects/github-com-artemnikitin-cci)   [![Build Status](https://travis-ci.org/artemnikitin/cci.svg?branch=master)](https://travis-ci.org/artemnikitin/cci)

#### Description
Tool for invalidating cache for several CDN providers.
Currently supports:
```
Cloudfront (AWS)
Cloudflare
```

#### Get it
```
go get -u github.com/artemnikitin/cci
```

#### Use it
```
cci -config /path/to/config
cci -config https://example.com/config.json
```
Parameters:
- ``config`` specified path to config on hard drive or URL
- ``debug`` print additional info for debug, **optional**

#### Config
Should be present as JSON file.
```json
{
	"cloudfront" : [{
		"access_key": "AWS access key",
		"secret_key": "AWS secret key",
		"distribution_id": "Cloudfront distribution ID",
		"resources": [
			"List of files for invalidation, optional",
			"Format: /index.html or /folder/*"
		]
	},
	{
		"access_key": "AWS access key",
		"secret_key": "AWS secret key",
		"distribution_id": "Cloudfront distribution ID"
	}],
	"cloudflare" : [{
		"email": "Cloudflare email",
		"key": "Cloudflare API key",
		"zone_id": "Cloudflare Zone ID",
		"purge_all": true
	},
	{
		"email": "Cloudflare email",
		"key": "Cloudflare API key",
		"zone_id": "Cloudflare Zone ID",
		"resources": [
			"List of files for invalidation, optional",
			"Format: http://example.com/index.html"
		]
	}]
}
```

repository: artemnikitin/cci

repo_name: artemnikitin/cci


text:
---
templateKey: article-page
title: React React Scroll toTop
path: /react-scroll-toTop
slug: /react-scroll-toTop
date: 2019-04-22T20:20:43.942Z
category: 'React'
cover: '/images/top.jpg'
tags:
  - toTop
  - Scroll
meta_title: Scroll toTop or Bottom
meta_description: React React Scroll toTop. Built with React Hooks, Styled Components and Love
secure_url: https://www.youtube.com/watch?v=Qid-_4hXo_s
tweet_id: '1118651504674725888'
showToc: true
showTags: true
showAdds: false
showStack: true
---

## Scroll toTop or Bottom

> 🔝 Have you tried Scroll to the top of the page react module's, I have and all of them use the .window function to go to top.
Which does not work in React without a work around.

```js
import Scroll from 'react-scroll'
```

Then tell React that, `window !== undefined`.

```js
// eslint-disable-next-line valid-typeof
if (typeof window !== undefined) { require('react-scroll') }
```

Such as the errors I got from react-scroll, and the workaround I used, "Which Works", but I did not like the implementation

So I came up with my own digging through React Repos. With React we can use handleScroll and window.pageYOffset to go to top or bottom of the page or anything.

```js
import React, { useState, useEffect } from 'react'

// and then use handleScroll and window.pageYOffset to go to top or bottom

const scroll = ({ mode, to }) =>
    window[`scroll` + mode]({ top: to, behavior: `smooth` })

  const handleScroll = () => {
    if (window.pageYOffset > showBelow) {
      if (!show) setShow(true)
    } else {
      if (show) setShow(false)
    }
  }
```

### styled icon styledArrow

```jsx{1-2,5}:title=src/components/Scroll
import React, { useState, useEffect } from 'react'
import { Arrow } from './styles'

const Scroll = ({
  direction = `up`,
  by,
  to,
  showBelow,
  className,
  size = `1.7em`,
}) => {
  if (![`up`, `down`].includes(direction))
    throw TypeError(
      `Scroll component's direction prop must be either 'up' or 'down'`
    )
  if (to && (typeof to !== `number` || to <= 0))
    throw TypeError(`Scroll component's to prop must be a positive number`)
  if (by && typeof by !== `number`)
    throw TypeError(`Scroll component's by prop must be a number`)

  const [show, setShow] = useState(showBelow ? false : true)

  const scroll = ({ mode, to }) =>
    window[`scroll` + mode]({ top: to, behavior: `smooth` })

  const handleScroll = () => {
    if (window.pageYOffset > showBelow) {
      if (!show) setShow(true)
    } else {
      if (show) setShow(false)
    }
  }

  const handleClick = () => {
    if (to) scroll({ mode: `To`, to: to * window.innerHeight })
    else if (by) scroll({ mode: `By`, to: by * window.innerHeight })
    else if (direction === `up`) scroll({ mode: `To`, to: 0 })
    else scroll({ mode: `To`, to: document.body.scrollHeight })
  }

  useEffect(() => {
    if (showBelow) {
      window.addEventListener(`scroll`, handleScroll)
      return () => window.removeEventListener(`scroll`, handleScroll)
    }
  })

  const arrowProps = { show, direction, className, size }
  return <Arrow onClick={handleClick} {...arrowProps} />
}

export default Scroll

```

### styles.js Code

```jsx:title=src/components/Scroll/styles
import styled from 'styled-components'
import { ArrowDownCircle as Down } from '@styled-icons/feather/ArrowDownCircle'
import { ArrowUpCircle as Up } from '@styled-icons/feather/ArrowUpCircle'

export const Arrow = styled(Down).attrs(({ direction, size }) => ({
  as: direction === `up` && Up,
  size,
}))`
  ${({ theme, show, size }) => `
  z-index: 2;
  background: ${theme.darkOrange};
  color: ${theme.textColor};
  border-radius: 50%;
  transition: ${theme.shortTrans};
  position: fixed;
  bottom: 2.5em;
  opacity: ${show ? 1 : 0};
  visibility: ${show ? `visible` : `hidden`};
  :hover {
    transform: scale(1.15);
    background: ${theme.orange};
  }
  right: calc(1vw - ${size} / 1);`}
`
```

### Add Scroll

```jsx:title=src/components/Scroll
  <Scroll
    showBelow={1500}
    css='position: fixed; right: 1.3em; bottom: 1.3em;'
  />
```

### Scroll Down

```jsx:title=src/components/ScrollDown
import React, { useState, useEffect } from 'react'
import { Arrow } from './styles'

const ScrollDown = ({
  direction = `down`,
  by,
  to,
  showBelow,
  className,
  size = `1.7em`,
}) => {
  if (![`up`, `down`].includes(direction))
    throw TypeError(
      `Scroll component's direction prop must be either 'up' or 'down'`
    )
  if (to && (typeof to !== `number` || to <= 0))
    throw TypeError(`Scroll component's to prop must be a positive number`)
  if (by && typeof by !== `number`)
    throw TypeError(`Scroll component's by prop must be a number`)

  const [show, setShow] = useState(showBelow ? false : true)

  const scroll = ({ mode, to }) =>
    window[`scroll` + mode]({ top: to, behavior: `smooth` })

  const handleScroll = () => {
    if (window.pageYOffset > showBelow) {
      if (!show) setShow(true)
    } else {
      if (show) setShow(false)
    }
  }

  const handleClick = () => {
    if (to) scroll({ mode: `To`, to: to * window.innerHeight })
    else if (by) scroll({ mode: `By`, to: by * window.innerHeight })
    else if (direction === `up`) scroll({ mode: `To`, to: 0 })
    else scroll({ mode: `To`, to: document.body.scrollHeight })
  }

  useEffect(() => {
    if (showBelow) {
      window.addEventListener(`scroll`, handleScroll)
      return () => window.removeEventListener(`scroll`, handleScroll)
    }
  })

  const arrowProps = { show, direction, className, size }
  return <Arrow onClick={handleClick} {...arrowProps} />
}

export default ScrollDown
```

#### Scroll styles.js

```jsx:title=src/components/ScrollDown/styles
export const Arrow = styled(Up).attrs(({ direction, size }) => ({
  as: direction === `down` && Down,
  size,
}))`
  ${({ theme, show, size }) => `
  z-index: 2;
  background: ${theme.darkOrange};
  color: ${theme.textColor};
  border-radius: 50%;
  transition: ${theme.shortTrans};
  position: fixed;
  top: 4.5em;
  opacity: ${show ? 1 : 0};
  visibility: ${show ? `visible` : `hidden`};
  :hover {
    transform: scale(1.15);
    background: ${theme.orange};
  }
  right: calc(1vw - ${size} / 1);`}
`
```

### Post Template

Only my post's are long enough to need scroll down

```js:title=add to template
  <ScrollDown
    direction='down' to={15}
    showAbove={1500}
    css='position: fixed; right: 1em; top: 4.5em;'
  />
```

Scroll down is visible at the top of the page and is fixed. I think its cool and somewhat original. Not static like the Netlify build page has scroll to bottom of the build log or back to top which is pretty Cool.

repository: igevchuk/publiuslogic

repo_name: igevchuk/publiuslogic


text:
# v1.1.6 (Mar 29, 2019)

 * Updated dependencies.

# v1.1.5 (Jan 16, 2019)

 * Updated `getActiveHandles()` to gracefully work in the event Node.js deprecates
   `process._getActiveHandles()`.
 * Gracefully handle calls to `process.binding()` should Node.js deprecate it or any of the
   requested bindings.
 * Added `trackTimers()` function in lieu of `getActiveHandles()` no longer being reliable for
   determining active timers in Node.js 11. `trackTimers()` uses async hooks which where added in
   Node.js 8.1.0.
   [(DAEMON-268)](https://jira.appcelerator.org/browse/DAEMON-268)
 * `tailgate()` no longer forces asynchronous execution of the callback using `setImmediate()`.
 * Refactored promises to async/await.
 * Updated dependencies.

# v1.1.4 (Nov 26, 2018)

 * Updated dependencies.

# v1.1.3 (Nov 26, 2018)

 * Updated dependencies.

# v1.1.2 (Sep 17, 2018)

 * Added `osInfo()` function to get operating system name and version.
 * Removed unused variables in tests.
 * Updated dependencies.

# v1.1.1 (May 24, 2018)

 * Updated dependencies:
   - appcd-fs 1.1.1 -> 1.1.2
   - appcd-gulp 1.1.1 -> 1.1.5
   - source-map-support 0.5.4 -> 0.5.6

# v1.1.0 (Apr 9, 2018)

 * Added ability to cancel a pending `debounce()`.
   [(DAEMON-238)](https://jira.appcelerator.org/browse/DAEMON-238)
 * Improved readme.
 * Updated dependencies:
   - appcd-gulp 1.0.1 -> 1.1.1
   - source-map-support 0.5.0 -> 0.5.4

# v1.0.1 (Dec 15, 2017)

 * Updated dependencies:
   - appcd-gulp 1.0.0 -> 1.0.1

# v1.0.0 (Dec 5, 2017)

 - Initial release.

repository: whitfin/appc-daemon

repo_name: whitfin/appc-daemon


text:
# PointNet++: Deep Hierarchical Feature Learning on Point Sets in a Metric Space
> [PointNet++: Deep Hierarchical Feature Learning on Point Sets in a Metric Space](https://arxiv.org/abs/1706.02413)

## Model description
Few prior works study deep learning on point sets. PointNet by Qi et al. is a pioneer in this direction. However, by design PointNet does not capture local structures induced by the metric space points live in, limiting its ability to recognize fine-grained patterns and generalizability to complex scenes. In this work, we introduce a hierarchical neural network that applies PointNet recursively on a nested partitioning of the input point set. By exploiting metric space distances, our network is able to learn local features with increasing contextual scales. With further observation that point sets are usually sampled with varying densities, which results in greatly decreased performance for networks trained on uniform densities, we propose novel set learning layers to adaptively combine features from multiple scales.

## Installing packages
```
## install libGL
yum install mesa-libGL

## install zlib
wget http://www.zlib.net/fossils/zlib-1.2.9.tar.gz
tar xvf zlib-1.2.9.tar.gz
cd zlib-1.2.9/
./configure && make install
cd ..
rm -rf zlib-1.2.9.tar.gz zlib-1.2.9/
```
```
pip3 install -r requirements/runtime.txt
MMCV_WITH_OPS=1 python3 setup.py develop
```

## Prepare S3DIS Data
```
cd data/s3dis/
```
Enter the data/s3dis/ folder, then prepare the dataset according to readme instructions in data/s3dis/ folder.

## Training
Single GPU training
```
python3 train.py configs/pointnet2/pointnet2_msg_16x2_cosine_80e_s3dis_seg-3d-13class.py
```
Multiple GPU training
```
bash dist_train.sh configs/pointnet2/pointnet2_msg_16x2_cosine_80e_s3dis_seg-3d-13class.py 8
```

## Training Results
| Classes | ceiling | floor  | wall   | beam   | column | window | door   | table  | chair  | sofa   | bookcase | board  | clutter | miou   | acc    | acc_cls |
| --------| ------- | -----  | ------ |------ |------ |------ |------ |------ |------ |------ |------ |------ |------ |------ |------ |------ |
| Results |  0.9147 | 0.9742 | 0.7800 | 0.0000 | 0.1881 | 0.5361 | 0.2265 | 0.6922 | 0.8249 | 0.3303 | 0.6585   | 0.5422 | 0.4607  |  0.5483 | 0.8490 | 0.6168  |

## Reference
https://github.com/open-mmlab/mmdetection3d

repository: Deep-Spark/DeepSparkHub

gha_language: Python

repo_name: Deep-Spark/DeepSparkHub


text:
---
layout: shows/episode
title: "Mobile web lessons learned from analyzing websites at scale"
description: "We've analyzed tens of thousands of mobile websites to figure out what works and what doesn't when it comes to performance and user experience on mobile devices. Here's our list of best practices and dos and don'ts, with insight from engineers into the algorithms we use to determine what is a 'good' mobile website."
youtubeID: UEfZ3aeCjoY

published_on: 2015-03-30
updated_on: 2015-03-30
---

We've analyzed tens of thousands of mobile websites to figure out what works
and what doesn't when it comes to performance and user experience on mobile
devices. Here's our list of best practices and dos and don'ts, with insight
from engineers into the algorithms we use to determine what is a "good"
mobile website.

repository: JcChimjj/WebFundamentals

repo_name: JcChimjj/WebFundamentals


text:
# Language-enhanced Object Reasoning Networks for Video Moment Retrieval with Text Query

## Introduction

This is the implementation code and instruction of the proposed work  *"Language-enhanced Object Reasoning Networks for Video Moment Retrieval with Text Query"* (LEORN).

## Environment Requirements

Our code runs based on the following dependencies:
- python3
- torch
- numpy
- tqdm
- h5py
- argparse
- tensorboard
- easydict
- torchtext
- terminaltables

## Training

### Datasets Preparation
The datasets we used for training and evaluation are listed as follow:

- TACoS: https://www.mpi-inf.mpg.de/departments/computer-vision-and-machine-learning/research/vision-and-language/tacos-multi-level-corpus
- Charades-STA: https://prior.allenai.org/projects/charades

### Running
Using the following command to train and evaluate our model.

TACoS
```
python -m torch.distributed.launch --nproc_per_node=2 moment_localization/train_muti.py --gpus 0,1 --cfg experiments\tacos\LEORN-128x128-K5L8.yaml --verbose
```

Charades-STA
```
python -m torch.distributed.launch --nproc_per_node=2 moment_localization/train_muti.py --gpus 0,1 --cfg experiments/charades/LEORN-64x64-K9L4.yaml --verbose
```

## Main Idea
We propose a novel Language-enhanced Object Reasoning Networks (LEORN) for video moment retrieval with text query, as shown in the figure below.

1. The proposed LEORN uses the object features extracted by the object detection network and incorporates the language features to model the relation between the objects within the frame.
2. Besides, we design a temporal context shift mechanism to model the temporal relationship of objects while reducing the noise from irrelevant objects in the adjacent frames.
3. Furthermore, as a general video understanding networks for object-level features, the proposed LEORN shows great potential on migrating to other cross-modal video understanding tasks.

### Insight of Our Work

1. We propose a novel model termed Language-enhanced Object Reasoning Networks (LEORN) for video moment retrieval, which leverages object-level features for cross-modal object reasoning. The fully-reasoned features contain abundant implicit information with good compatibility so as to better understand the video content.
2. We design an attentive feature query extraction mechanism to extract relational query feature which is more consistent with the object reasoning process.
3. We conduct extensive experiments on two public datasets: TACoS and Charades-STA. The experimental results show that our proposed method with object-level features can achieve competitive results and the model in a comparable experimental setting outperforms other state-of-the-art approaches that demonstrate the effectiveness of our proposed method with object features.
4. Our proposed LEORN shows great potential on migrating to other cross-modal video understanding tasks.

## Overall Results

### Results on TACoS Dataset

### Results on Charades-STA Dataset

### Visualization of Video Moment Retrieval


text:
# firehose

Java EE 7+ metrics gateway for prometheus

The firehose service (16kB Thin WAR) gathers metrics emitted from JSON / text (currently only JSON is supported) HTTP endpoint and converts them into prometheus compliant [metrics](https://prometheus.io/docs/practices/naming/).

The prometheus metrics are exposed via the: `http://[HOST]:[8080]/firehose/resources/metrics/{metrics-name}` uri in prometheus format.

Metrics from all registered endpoints can be fetched at once via HTTP `http://[HOST]:[8080]/firehose/resources/metrics/`

## Installation

Start `firehose` in the same docker network as the monitored resources and start it with
`docker run -d -p 8080:8080 --name firehose airhacks/firehose` or deploy the WAR to a Java EE 7 container running on Java 8.

A sample configuration is used for testing. Prometheus, a sample-service and firehose
are started:

```yaml
version: '3.0'
services:
  prometheus:
    build: prometheus-firehose
    ports:
    - "9090:9090"
    links:
    - firehose
  firehose:
    image: airhacks/firehose
    env_file: metrics.env
    ports:
    - "8080:8080"
    links:
    - sample-service
  sample-service:
    image: airhacks/sample-service
    ports:
    - "8282:8080"
```

sample-service is configured in an `metrics.env` file and provided at starttime:

```
# Sample service configuration
firehose.sample-service.uri=http://sample-service:8080/sample-service/resources/metrics
# prometheus does not allow dashes -> name changed to sampleservice
firehose.sample-service.application=sampleservice
```

## Configuration management

To gather a remote metric at least the `uri` with the fully qualified value, e.g.: `http://sample-service:8080/sample-service/resources/metrics` is required.

The properties (required by [prometheus](https://prometheus.io/docs/practices/naming/)):

1. application  (e.g. "sampleservice"
2. component  (e.g. "MetricsResource"")
3. units (e.g. "requests")
4. suffix (e.g. "total")

are usually provided by the monitored endpoint as json, but can be overriden with environment entries, like e.g.

`sampleservice.application=sample`

at startup time.

The properties can be also passed as JSON via configuration, e.g.

`curl -i -H"Content-type: application/json" -XPUT -d'{"uri":"http://sample-service:8080/sample-service/resources/metrics","application":"sample", "component":"jobprocessing","units":"jobs","suffix":"total}' http://localhost:8080/firehose/resources/configurations/sample-service`

Also an extractor script can be configured to extract the data from an incompatible data source. The following script uploads a JavaScript file, which extracts the used heap in bytes from
the GlassFish / Payara monitoring endpoint:

`curl -i -XPUT -H"Content-type: text/plain" -H"uri: http://localhost:4848/monitoring/domain/server/jvm/memory/usedheapsize-count.json"  --upload-file usedheapsize.js http://localhost:8080/firehose/resources/configurations/payarausedheap`

The content of the file is:

```
function apply(input) {
    var metric = JSON.parse(input);
    var value = metric.extraProperties.entity["usedheapsize-count"].count;
    var output = {
        suffix: "size",
        units: "bytes",
        component: "jvmusedheapsize",
        application: "firehosest",
        value: value
    };
    return JSON.stringify(output);
}
````
(see firehose-st/src/test/resources)

The following request: `curl http://localhost:8080/firehose/resources/metrics/payarausedheap`

will return a prometheus-consumable metric:

`firehosest_jvmusedheapsize_bytes_size 150629368`

The environment variables can be overriden again by the REST configuration endpoint:

1. create or update a metric

Setup "sample-service" metric to be fetched from `http://sample-service:8080/sample-service/resources/metrics` and exposed
via `http://[HOST]:[8080]/firehose/resources/metrics/sample-service`:

`curl -i -H"Content-type: application/json" -XPUT -d'{"uri":"http://sample-service:8080/sample-service/resources/metrics"}' http://localhost:8080/firehose/resources/configurations/sample-service`

This endpoint return 201 for creation and 204 for update.

2. list all metrics

`curl -i http://localhost:8080/firehose/resources/configurations/`

3. delete a metric

delete a metric with the name "sample-service"

`curl -XDELETE http://localhost:8080/firehose/resources/configurations/sample-service`

## Prometheus endpoint

The preconfigured endpoint are available under the URI: `http://[HOST]:[8080]/firehose/resources/metrics/{metrics-name}`

test it with: e.g. `curl -i http://localhost:8080/firehose/resources/metrics/sample-service`

You can also fetch all metrics via a single URI:
`curl http://localhost:8080/firehose/resources/metrics/`, what does not require any changes in prometheus configuration in case an additional endpoint is added.

## Build

1. `git clone https://github.com/AdamBien/firehose`
2. `cd firehose && mvn clean install && docker build -t airhacks/firehose .`
3. `cd sample-service && mvn clean install && docker build -t airhacks/sample-service .`
4. `docker-compose up -d`

Base image for firehose and sample apps were taken from [docklands](https://github.com/AdamBien/docklands)

## Screencasts

Java EE Monitoring With firehose and prometheus.io:

[![Java EE Monitoring With firehose and prometheus.io](https://i.ytimg.com/vi/_FW5472xTmQ/mqdefault.jpg)](https://www.youtube.com/embed/_FW5472xTmQ?rel=0)

Monitoring Payara with Firehose, Prometheus and Grafana:

[![Monitoring Payara with Firehose, Prometheus and Grafana](https://i.ytimg.com/vi/Pww-8WxsXJA/mqdefault.jpg)](https://www.youtube.com/embed/Pww-8WxsXJA?rel=0)

See you at [Java EE Performance, Monitoring and Troubleshooting](http://workshops.adam-bien.com/performance.htm) and/or [Java EE Microservices](http://workshops.adam-bien.com/microservices.htm) workshops

repository: grommitz/firehose

repo_name: grommitz/firehose


text:
# Pizza Order Form

### _Build your own pizza and calculate the cost!_

###### Made by Emily Wells Jimenez - 9/29/17

### Description

This app is intended to show how to take user input, place it in an object, build a constructor, and alter the information through prototypes

1. User enters information on app's form
2. After submitting the information, a details result is shown of what the user selected
3. Based on what the user selected, a cost is calculated and displayed.

### Setup

Go to [https://github.com/emilyjimenez/pizza-tim](https://github.com/emilyjimenez/pizza-time) and clone the project using your preferred shell, then open the content into a text editor of your choice to check out the code. After cloning, you can also open the index.html file in your browser to test functionality.

### Specs

| Behavior       | Input        | Output |
| ------------- |:-------------:| -----:|
| will take user input and convert to an object| | |
| will display slected items user chose| Emily, small, etc... |Order for: Emily, You ordered a small pizza...|
|will calculate cost based on size |small|$5|
|will calculate cost based on toppings|bell peppers, bacon|$3|
|will add up costs and display total cost|small, marinara, pepperoni|$8.50|

### Technology Used

Javascript and jQuery

### Legal

Copyright (c) 2017 Emily Wells Jimenez

This software is licensed under the MIT license.

repository: emilyjimenez/pizza-time

repo_name: emilyjimenez/pizza-time


text:
The visual metaphors continue. Peco's enthusiasm is so infestious it begins infest Kazama, leading to a wonderfully symbolic scene. Kazama is constantly depicted as climbing an infitely tall wall, his monologue in the episode describing the detail the burden of winning. His path has no discrete goal or finish line, only the possibility of failure. Thus when he sees Peco fly past him, he finally ceases the endless climbing and tries something new. He breaks the cycle, and finally sees the hero.

(clip of peco kazama scene)

Except the Hero cannot help him directly, only show him the way. Kazama sprouts wings and escapes his self-imposed mental prison. Finally taking flight marks the resolution of another thread, mimiced in the final line of the episode. "People can fly"

(screenshot)

Kazama adamantly declares throughout the episode: "people can't fly". This both summarizes his feeling trapped in the cycle of endless victories, as well as deeper emotional trauma surrounding his father. The flashback imply Kazama's father commited by suicide, and this combined with intense familiar pressure to conform to a specific role bind him to the earth.

Yet even as he's about to lose Peco, he no longer cares. Not due to depression or an invalidation of his beliefs, but rather the epiphany that he doesn't have to be shackled. He can be so much more. Life can be so much more. "People really can fly"

repository: mpaulweeks/bookmarks-jekyll

repo_name: mpaulweeks/bookmarks-jekyll


text:
# Article Deduplication App

A simple app that reports near duplicate articles using distance in a vector-space model.

Currently, the repository is missing example articles as well as examples of the filter and replacement word lists necessary for running the code. However, I hope that the code will serve as a useful example.

# Instructions

Build:

    $ ./sbt assembly

A jar (`dedup-assembly-0.1.jar`) will be created under `target/scala_2.10`.

Import data:

Create a directory called `workdir` for intermediate files.

    $ spark-submit --master local[20] \
    --executor-memory 200G \
    --driver-memory 200G \
    --class com.redhat.et.DedupApp
    target/scala_2.1.0/dedup-assembly-0.1.jar \
    --work-dir workdir \
    import-data \
    --articles /path/to/article.json \
    --filter-words /path/to/filter-words.txt \
    --replacement-words /path/to/replacement-words.txt \
    --min-word-count 5

Compute Histogram:
Histogram document pairs based on distances.

repository: rnowling/article-deduplication

gha_language: Scala

repo_name: rnowling/article-deduplication


text:
## Trait objects

* in order to perform dynamic dispatch, Formula trait need to be a 'Trait Object'
* in order for a trait to be a 'Trait Object' it has to be 'Object Safe'
---
* the trait is 'Object Safe' if
    * it MUST NOT require that 'Self : Sized'
    * all of its methods are 'Object Safe'
* all its methods MUST require that 'Self : Sized' ... or:
    * MUST NOT have any type parameter (<T>)
    * MUST NOT use 'Self'

[📒](https://doc.rust-lang.org/1.17.0/book/trait-objects.html#object-safety)

repository: beltram/rs-training

repo_name: beltram/rs-training


text:
---
title: Create an In-App delivery within a workflow
description: Learn how to use the In-App delivery activity to automate sending an In-App message to a target audience calculated in a workflow.
feature: In App
jira: KT-2500
thumbnail: 26226.jpg
doc-type: feature video
activity: use
team: TM
exl-id: 9d5b1769-9f04-45d0-bbce-38cd33c65bb0
role: User, Developer
level: Beginner, Intermediate
---
# Create an [!UICONTROL In-App] delivery within a workflow

Learn how to use the In-App delivery activity to automate sending an In-App message to a target audience calculated in a workflow.

>[!VIDEO](https://video.tv.adobe.com/v/26226?quality=12&learn=on)


text:
# Udacity front-end-nanodegree: Classic Arcade Game Clone

In this game you have a Player and Enemy. You are the Player, the goal is the Player reaches to the water without colliding with the enemies. If you are colliding with the enemies, the game will reset. On the other hand, if the Player reaches to the water, you won! You can move left, right, up or down with arrow keys.

## Demo

[Live](https://krittiyaclark.github.io/Udacity-Front-End-Arcade-Game/)
![Princess](https://github.com/krittiyaclark/Udacity-Front-End-Arcade-Game/blob/master/images/char-princess-girl.png)
![Enemy](https://github.com/krittiyaclark/Udacity-Front-End-Arcade-Game/blob/master/images/enemy-bug.png)

## Usage

Instructions how to download/clone this code and run the application locally.

1. Clone project:

    ```
    $ [sudo] git clone git@github.com:krittiyaclark/Udacity-Front-End-Arcade-Game.git
    ```

2. Serve the application:
   Open the terminal (Mac and Linux) or command prompt (Windows). ```cd``` to a directory where you've saved an HTML file. Run ```python --version```. If you have Python 2, run

    ```
    $ [sudo] python -m SimpleHTTPServer
    ```

3. Open the game:

    ```
    $ open "http://localhost:8000"
    ```

## License

[MIT License](http://brenopolanski.mit-license.org/)


text:
---
title: "Tweetstorm: Bitcoin as SoV"
permalink: "/tweetstorm-bitcoin-as-sov"

author: danheld

tags:
  - CY19 Q1
  - Dan Held

defaults:
  - scope:
      path: ""
      type: posts
---

{% include donation.md %}

# [Tweetstorm: Bitcoin as SoV](https://twitter.com/danheld/status/1084848063947071488?lang=en)
## By [Dan Held](https://twitter.com/danheld)
## Posted January 14, 2019

**1)** Satoshi's Vision™ is a silly endeavor, as it doesn't matter what it was, we are where we are now. However, those pushing the "Bitcoin was first made for payments" narrative insist on cherry-picking sentences from the white paper and forum posts to champion their perspective.

**2)** The following tweetstorm is a categorical repudiation of this tired narrative. Bitcoin was purpose-built to first be a Store of Value (SoV), a thread:

**3)** How do we determine Satoshi's intention? We need to look at his ideology, description of functionality/architecture, timing, and audience. Let's start with how Satoshi describes the problem Bitcoin solves. In his first public comms after the whitepaper, in the first paragraph:

**4)** "The root problem with conventional currency is all the trust that's required to make it work. The central bank must be trusted not to debase the currency, but the history of fiat currencies is full of breaches of that trust." - Satoshi

**5)** He later expands on that Libertarian thought in his other writings:
"[with Bitcoin] we can win a major battle in the arms race and gain a new territory of freedom for several years." — Satoshi Nakamoto

**6)** How does Satoshi describe Bitcoin? His forum posts provide insight through his consistent gold/metal analogy:
"Bitcoin [is] more like a collectible or commodity." - Satoshi

**7)** "In this sense, it's more typical of a precious metal. Instead of the supply changing to keep the value the same, the supply is predetermined and the value changes. As the number of users grows, the value per coin increases" - Satoshi

**8)** "As a thought experiment, imagine there was a base metal as scarce as gold but with the following properties: [not useful/no utility]. And one special, magical property: can be transported over a communications channel" - Satoshi

**9)** "If there were nothing in the world with intrinsic value that could be used as money, only scarce but no intrinsic value, I think people would still take up something. (I'm using the word scarce here to only mean limited potential supply)" - Satoshi

**10)** "It might make sense just to get some in case it catches on. If enough people think the same way, that becomes a self fulfilling prophecy." - Satoshi
Satoshi here clearly highlights that Bitcoin's scarcity gives it value... as a SoV. Limited supply is meaningless for VISA

**11)** So we now have an idea of Satoshi's motivations, and how he describes Bitcoin, but what does his timing tell us?
Bitcoin's launch during the 08' financial crisis was not coincidental. Satoshi had been coding Bitcoin for the last 2 years. Let's look at the sequence of events

**12)** Jan - July: Fed tries to stop the housing bust: Fed bails out Bear Sterns. Paulson explains the need to bail out Fannie Mae, Freddie Mac the two agencies that held or guarantee 50% of the $12T in US mortgages.

**13)** Aug 18: Satoshi registers [org](http://Bitcoin.org)
Sept 15: Lehman Brothers files for bankruptcy, the largest in U.S. history ($600B)
Sept 17: Investors withdrew a record $144B from their money market accounts. During a typical week, only about $7B is withdrawn

**14)** Oct 3: Bitcoin whitepaper PDF likely created
Oct 13: Treasury Secretary Paulson talks with 9 major bank CEOs. The total bailout package ~$2.25T
Oct 21:  Fed lends $540B to bail out money market funds
Oct 31: Satoshi publishes the Bitcoin whitepaper

**15)** With the 2008 financial crisis, trust had been lost in a world that ran on trust. Bitcoin was launched in a time of absolute necessity, Satoshi planted the seed at precisely the right moment. The world didn't need a new VISA, they needed an alternative to banks.

**16)** So we now have an idea of Satoshi's motivations, how he describes Bitcoin, and his timing, what about this initial audience for the whitepaper? How did he market his message?

**17)** Satoshi crafted the whitepaper as a call to arms for his target audience: the Cypherpunks on the cryptography mailing list. Key components of their ideology are privacy and finality. His message needed to resonate with them as they would have to help him build it.

**18)** "Therefore, privacy in an open society requires anonymous transaction systems. An anonymous system empowers individuals to reveal their identity when desired and only when desired; this is the essence of privacy." - A Cypherpunk's Manifesto

**19)** Many point to this in the whitepaper "peer-to-peer version of electronic cash would allow online payments" as proof that Satoshi meant for Bitcoin's main purpose is to disrupt VISA. However, "cash" represents a pseudonymous push payment in contrast to a credit-based system

**20)** Cash is a bearer asset. Let's look at the whitepaper with that in mind: _"A purely peer-to-peer version of electronic [bearer assets] that would allow online payments to be sent directly from one party to another without going through a financial institution."_

**21)** Note that the origin of the word "cash" is "caisse" (French) meaning money-box. So cash is by definition store-of-value. Other Cypherpunks had used the word cash in their whitepapers to reflect that functionality, like "HashCASH", "eCASH", etc"

**22)** In the other part of the whitepaper sentence the phrase "peer-to-peer" has been used as well against the SoV narrative. Charlie Lee has a great tweet storm that addresses this point of contention:

**23)** "Bitcoin isn't "peer-to-peer." Payments are sent from sender to miners, who record it on a distributed ledger. The recipient receives the payment when it's recorded. BUT, this is facilitated by a p2p network where transactions are broadcasted."[@SatoshiLite](https://twitter.com/SatoshiLite)

**24)** "Lightning network payments, on the other hand, are p2p payments. They are sometimes direct p2p, sometimes indirect p2p. LN payments have to be sent from p2p to get from the sender to the recipient. Both have to be online, just like other p2p networks like BitTorrent"

**25)** "Bitcoin with Lightning Network more closely fits the Bitcoin whitepaper's title: "A Peer-to-Peer Electronic Cash System." This is Satoshi's Vision." -[@SatoshiLite](https://twitter.com/SatoshiLite)

**26)** He wrote the paper to fit his target audience, but the source code implementation were his product specs. "If the Bitcoin Whitepaper is the Declaration of Independence, the Source Code is the Constitution" -[@pierre_rochard](https://twitter.com/pierre_rochard)

**27)** "The functional details are not covered in the paper, but the sourcecode is coming soon." — Satoshi Nakamoto

Aka the whitepaper was marketing, the important details are coming.
**28)** In true Cypherpunk fashion, Satoshi's whitepaper was quickly followed by code release in January 2009. The notion that good ideas need to be implemented, not just discussed, is very much part of the culture of the mailing list.

**29)** Just focusing on the whitepaper is a gross misinterpretation, here are the things not described in the whitepaper, but included in the source code or later defined by Satoshi: 21M hard cap, 10 minute blocks, 1 mb block caps.

**30)** If Satoshi wanted Bitcoin to first be used as a medium of exchange to purchase goods and services, he would have made it inflationary. People don't spend deflationary currencies when they can make the same purchase in infl. curr. There's even a name for It, Gresham's Law

**31)** Which is entirely intuitive. Why would any average consumer spend their Bitcoin with the perception that it will be worth more in the future when they can spend their fiat that they KNOW will be worth less?

**32)** So far that doesn't sound like he's trying to disrupt VISA now does it? And if that wasn't made perfectly clear, he permanently etched this message into the Genesis Block: _"The Times 03/Jan/2009 Chancellor on brink of second bailout for banks"_

**33)** To take it a step further, as a subtle jab to central banks, he chose his birthday as the date the US made gold ownership illegal through EO 6102 April 5th. He chose 1975 as his year of birth which is the year when the US citizens were allowed to own gold again

**34)** And finally, why did Satoshi choose to be anonymous if he were just disrupting payments?

What he was trying to accomplish was clear, he wanted to build a new backbone for the financial system. Bitcoin isn't merely digital cash, but an alternative to banks.

**35)** And how does a new money get created? A new money comes into existence through stages: Collectible, SoV, MoE, and UoA.
SoV and MoE aren't mutually exclusive. It's about where in the cycle of appreciation we're in. At maturity, the payment use case finally makes sense.
![Bitcoin Evolution](/assets/images/cy19q1/dan-held-btc-evolution.png){: .align-center}*Bitcoin evolution over time*

**36)** Some may balk at the SoV terminology for Bitcoin since the price fluctuates. However, nothing in this life has a "stable" value, the longest running fiat currency, GBP, has lost 99% of its value since inception. Bitcoin has all the traits of a good SoV

**37)** Bitcoin is stable. The protocol has a 99.99989% uptime which is higher than USD. The "fluctuation" you see is the volatility of the world flowing into the stability of Bitcoin in ebbs and flows.

**38)** When applying "The Szaboian Theory of Money Origins" to Bitcoin, it is reasonable to conclude we just barely left the "collectible phase" and are now witnessing it's first steps into "Proto-money"[@Willem_VdBergh](https://twitter.com/Willem_VdBergh) [@NickSzabo4](https://twitter.com/NickSzabo4)

**39)** This phase, which is characterized by its primordial exploration of the SoV properties of the commodity, can easily take a decades to properly mature. Volatility is part of this maturing process.

**40)** People pushing the MoE narrative at this moment in time are counterproductive to adoption. By creating these expectations, which are unattainable at the moment, many people will get burned or disillusioned. This is a big loss for adoption and for the affected individuals
![Merchant Revenues from BTC](/assets/images/cy19q1/dan-held-tweetstorm-btc-amount.png){: .align-center}

**41)** "Only by informing people correctly about the use case Bitcoin has *at this moment* can we maximize it's adoption and prevent a lot of people from making the biggest financial mistake of their life."[@Willem_VdBergh](https://twitter.com/Willem_VdBergh)

**42)** So how did the payments narrative become a thing?
A/ Satoshi used it to attract the cypherpunks
B/ HODLing isn't good for business. In order to command higher valuations, startups latched onto narratives that VCs would fund. And in 2013-2016 that was "merchant processing."

**43)** Background on me: I was the first PM [@Blockchain](https://twitter.com/blockchain) and [@ChangeTip](https://twitter.com/ChangeTip), both attempted to get people to use Bitcoin for payments. Consumers couldn't care less, which is entirely intuitive: right now it's not faster, cheaper, or easier to use for 99.99% of use cases.

**44)** After all of this do you really think Bitcoin was primarily built for payments at this stage in its lifecycle?

**45)** If you enjoyed this tweet storm, please sign up for an e-mail newsletter which will include more of my thoughts like these. (at a date far in the future when I have time)

**46)** Special thanks for the insight and inspiration:

[@real_vijay](https://twitter.com/real_vijay), [@nwoodfine](https://twitter.com/nwoodfine), [@saifedean](https://twitter.com/saifedean), [@NickSzabo4](https://twitter.com/NickSzabo4), [@MustStopMurad](https://twitter.com/MustStopMurad), [@pierre_rochard](https://twitter.com/pierre_rochard), [@nic__carter](https://twitter.com/nic__carter), [@hugohanoi](https://twitter.com/hugohanoi), [@MartyBent](https://twitter.com/MartyBent), [@francispouliot_](https://twitter.com/francispouliot_), [@TuurDemeester](https://twitter.com/TuurDemeester), [@arjunblj](https://twitter.com/arjunblj), [@jimmysong](https://twitter.com/jimmysong), [@hasufl](https://twitter.com/hasufl), @prestwich, [@CremeDeLaCrypto](https://twitter.com/CremeDeLaCrypto), [@SatoshiLite](https://twitter.com/SatoshiLite), [@MrHodl](https://twitter.com/MrHodl)

gha_language: CSS


text:
![SolrSwan Logo](assets/SolrSwan-Color.jpg)

SolrSwan
========

[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
[![CircleCI](https://circleci.com/gh/o19s/SolrSwan.svg?style=svg)](https://circleci.com/gh/o19s/SolrSwan)

SolrSwan is a query parser and highlighter for Solr that accepts proximity and Boolean queries. The syntax is designed to be compatible with the search syntax in use at the U.S. Patent and Trademark Office. In addition to a changed fielded query syntax, the additional operators are:

* Same
* With
* Adjacent
* Near
* XOR

Each operator takes an optional quantifier, such as "SAME3", that restricts the range over which it operates. In order to make sense of paragraphs and sentences, the searched fields need to index special tokens that identify the breaks. The test schema has an example of how to do that with solr.PatternReplaceCharFilterFactory.

The included highlighter is a modified version of the FastVectorHighlighter that is currently the default in Solr. It supports semantically accurate, multi-colored highlighting. (The Phrase highlighter in Solr supports the first, while FVH supports the second, but neither support both).

# Building
SolrSwan uses Maven dependency management and Java 7. Once those are installed, building the plugin JAR is done with:
```
mvn package
```
This will build both the plugin jar as well as a webapp that can be used to parse queries without executing them. Both packages will be in the ./target folder.

# Installation
There are a few steps needed to get Swan syntax working in Solr. First, add the new jars to solrconfig.xml like:
```xml
  <lib path="../../apache-solr-4.0/contrib/SwanParser-1.0-SNAPSHOT.jar" />
  <lib path="../../apache-solr-4.0/contrib/parboiled-core-1.0.2.jar" />
  <lib path="../../apache-solr-4.0/contrib/parboiled-java-1.0.2.jar" />
  <lib path="../../apache-solr-4.0/contrib/asm-all-3.3.1.jar" />
```
Then define the new query parser:
```xml
  <queryParser name="swan" class="com.o19s.solr.swan.SwanQParserPlugin">
    <str name="fieldAliases">fieldAliases.txt</str>
  </queryParser>

```
And then use the new parser in a request handler:
```xml
  <requestHandler name="swan" class="solr.SearchHandler" default="true">
    <lst name="defaults">
      <str name="defType">swan</str>
      <str name="sm">xxxsentencexxx</str>
      <str name="pm">xxxparagraphxxx</str>
      <str name="df">text_html</str>
```

The sm, pm, and df parameters are required. sm and pm are the sentence and paragraph markers you'll need to insert with an analyzer, and df can be whatever you want your default search field to be.

Next, in schema.xml you'll need to insert a couple charFilters into the analysis chain for whatever fields you want to use with Swan:
```xml
    <!-- HTML based fields. -->
    <fieldType name="html" class="solr.TextField" positionIncrementGap="100">
      <analyzer type="index">
        <!-- find p h1 h2 h3 h4 h5 elements and add in paragraph token -->
        <charFilter class="solr.PatternReplaceCharFilterFactory"
                    pattern="^|(<(?:[pP]|[hH]\d)>)"
                    replacement="$1 xxxparagraphxxx xxxsentencexxx "/>
        <!-- find pattern "[sentence ending punctuation][space][Cap letter or number]
             and replace punctuation with sentence token -->
        <charFilter class="solr.PatternReplaceCharFilterFactory"
                    pattern="[.!?]\s+([A-Z0-9])"
                    replacement=" xxxsentencexxx $1"/>
        <charFilter class="solr.HTMLStripCharFilterFactory"/>
        <tokenizer class="solr.StandardTokenizerFactory"/>
        <filter class="solr.LowerCaseFilterFactory" />
      </analyzer>
      <analyzer type="query">
        <tokenizer class="solr.StandardTokenizerFactory"/>
        <filter class="solr.LowerCaseFilterFactory" />
      </analyzer>
    </fieldType>
```
This inserts the paragraph and sentence markers based on matching regular expressions. I'm not really sure what would happen if you only did sentence markers over a plain text field. The two possibilities are SAME and WITH operators would treat everything as if it was in the same paragraph, or they would never identify a paragraph in which to match.

Lastly, you need to create a text file that maps "dot" field aliases to the actual fields in your schema. For example, the following tells the parser to treat "ab" or "AB" as aliases for the abstract_html schema field:
```ruby
ab,AB => abstract_html
```
This will translate "device.ab." as a query for the term "device" over the abstract_html field. I don't remember at the moment whether or not the Swan field is still case-sensitive. Our whole fieldAliases.txt file looks like this:
```ruby
pn,PN,did,DID => id
pd,PD,isd,ISD => date_publ_i
ab,AB => abstract_html
ti,TI => invention_title
bsum,BSUM,detd,DETD,spec,SPEC => description_html
clm,CLM,clms,CLMS,dclm,DCLM => claims_html
ccls,CCLS,clas,CLAS,ccor,CCOR => uspc_code_fmt
```
Put that file alongside schema.xml and solrconfig.xml.

# Swan Operators

Op | Description
---- | -----------
ADJ | TermA next to TermB in the order specified in the same sentence
ADJ[n] | Two terms must occur within [n] terms of each other, in order, and within the same sentence.
NEAR | TermA next to TermB in any order in the same sentence
NEAR[n] | TermA within [n] words of TermB, in any order within the same sentence
WITH | TermA in the same sentence with TermB
WITH[n] | TermA within [n] sentences of TermB
SAME | TermA in the same paragraph with TermB
SAME[n] | TermA within [n] paragraphs of TermB
XOR | TermA OR TermB, but not both

gha_language: Java


text:
# Overview

-----------------------
### Contents

#### [Plot](readme.md)

#### [Getting Started](getting_started.md)

#### [Overview & Tables](overview.md)

#### [Shop Routes and Pages](shop_routes_pages.md)

#### [Donut Routes and Pages](donut_routes_pages.md)
-------------------------

Your app consists of three resources: shops, employees, and donuts.  Employees are able to login and edit their own information, but not other employees.

Business Rules:

 - Shops have many donuts, many donuts belong to many shops.
 - *Shops have many employees, employee belongs to a shop.
 - *Employee has one favorite donut

* employees is bonus
*plot stuff: the donuts for all the shops are stored and distributed from one factory.*

## Tables

|Shop
|----------------
|id
|name (text)
|city (text)

|Donut
|----------------
|id
|name (text)
|topping (text)
|price (int)

|Shop_donut
|----------------
|id
|shop_id (fk)
|donut_id (fk)

|Employee
|----------------|
|id
|first_name (text)
|last_name (text)
|email (text)
|hashed_password
|favorite_donut (fk)

#### [⇐ Previous (Getting started)](getting_started.md) | [Next (Shop Routes & Pages) ⇒](shop_routes_pages.md)


text:
# Remote Deluge

Provides quick overview of torrent information in Chrome for the torrent client Deluge.

## Request for help

I develop this in my spare time, which is very limited. Pull requests will be gratefully accepted where possible.

## Screenshot

![](webstore/screenshot1.png)

## Version History

2017-04-10 v1.2.4
* Fix for Deluge v1.3.14

2016-06-22 v1.2.3
* Fix bug for first-time users.

2016-06-22 v1.2.2
* Fix a couple niggling bugs and added a donate button. Please donate if you find my work useful! :)

2016-01-27 v1.2.1
* Fixed broken settings from v1.2.0

2016-01-26 v1.2.0
* Fix context menu
* Fixed possible connections issue
* Various other code improvements

2015-06-04 v1.1.0
* Fix for connectivity problem introduced in last version

2015-06-03 v1.0.0
+ Add an option to settings for a base path for reverse-proxied connections.

repository: newsky/chrome-deluge-remote

repo_name: newsky/chrome-deluge-remote