text:
# akaze

[![Discord][dci]][dcl] [![Crates.io][ci]][cl] ![MIT/Apache][li] [![docs.rs][di]][dl] ![LoC][lo] ![Tests][btl] ![Lints][bll]

[ci]: https://img.shields.io/crates/v/akaze.svg
[cl]: https://crates.io/crates/akaze/

[li]: https://img.shields.io/crates/l/specs.svg?maxAge=2592000

[di]: https://docs.rs/akaze/badge.svg
[dl]: https://docs.rs/akaze/

[lo]: https://tokei.rs/b1/github/rust-cv/akaze?category=code

[dci]: https://img.shields.io/discord/550706294311485440.svg?logo=discord&colorB=7289DA
[dcl]: https://discord.gg/d32jaam

[btl]: https://github.com/rust-cv/akaze/workflows/unit%20tests/badge.svg
[bll]: https://github.com/rust-cv/akaze/workflows/lints/badge.svg

AKAZE feature extraction algorithm for computer vision

Implementation of AKAZE based on the one by indianajohn. He gave me permission to copy this here and work from that, as his job conflicts with maintainership. The crate is greatly changed from the original.

See `tests/estimate_pose.rs` for a demonstration on how to use this crate.

This crate adds several optimizations (using ndarray) to the original implementation and integrates directly into the rust-cv ecosystem for ease-of-use. This crate does not currently use threading to speed anything up, but it might be added as a Cargo feature in the future.

The original implementation can be found here: https://github.com/pablofdezalc/akaze

The previous rust implementation can be found here: https://github.com/indianajohn/akaze-rust

The main site for the algorithm is normally [here](http://www.robesafe.com/personal/pablo.alcantarilla/kaze.html), but it was down, so I found another link to the paper: http://www.bmva.org/bmvc/2013/Papers/paper0013/paper0013.pdf

repository: rust-cv/akaze

repo_name: rust-cv/akaze


text:
Tests {#tests}
=====

libopenmpt provides some basic unit tests that check the platform for general
sanity and do some basic internal functionality testing. The test suite
requires a special libopenmpt build that includes file saving functionality
which is not included in normal builds.

### Running Tests

#### On Unix-like systems

Compile with

    make $YOURMAKEOPTIONS clean
    make $YOURMAKEOPTIONS

and run

    make $YOURMAKEOPTIONS check

.
As the build system retains no state between make invocations, you have to
provide your make options on every make invocation.

#### On Windows

Using Visual Studio 2010, compile

    libopenmpt\libopenmpt_test.sln

and run

    bin\$ARCH\libopenmpt_test.exe

from the root of the source tree.

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
# Cercoseptoria oxyriae (Trail) Gjaerum, 1971 SPECIES

#### Status
SYNONYM

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

#### Published in
Norw. Jl Bot. 18(2): 111 (1971)

#### Original name
Ramularia oxyriae Trail, 1887

### Remarks
null

repository: mdoering/backbone

path: /life/Fungi/Ascomycota/Dothideomycetes/Capnodiales/Mycosphaerellaceae/Pseudocercosporella/Pseudocercosporella oxyriae/ Syn. Cercoseptoria oxyriae/README.md

repo_name: mdoering/backbone


text:
# Hangman Helper
Hangman Helper is an assistant for the person holding a hangman word that others are trying to guess. Enter the word and the letters guessed so far, and it gives you back the text to tell other players.

Written for my wife, who sometimes plays with friends over email.

It also remembers the word and guesses. Unfortunately, that means it doesn't handle participating in more than one game at once, unless you use a separate copy for each one.

You can also download it and run it from a local hard drive. No installation needed, just grab the files, and double click index.html.

## Credits
Hangman Helper was written by Dave Merrill, (c) 2014-2019.
It's free software, released under the MIT license.

It uses Marcus Westin's wonderful store.js library to remember things.

license: MIT

repository: davemerrill/HangmanHelper

repo_name: davemerrill/HangmanHelper


text:
[Perspective API documentation](../README.md) > [API Reference Docs](README.md) > **Key concepts**

# Key concepts

To best understand the reference documentation, you must first understand these
key concepts.

## Attribute

An **attribute** is a comment label used for review. The most popular attribute
is `TOXICITY`.

Attribute was previously known as "model".

#### Why did we make this name change?

Machine Learning is a fast-moving discipline, with a lot of community-driven and historical terminalogy. It's our belief that the community has rough consensus on the term "machine learning model (ML model)". This term, meaning a neural net architecture together with the weights that result from training that neural net, defines something that can take inputs ("features") and produce outputs (class labels, regression scores, sometimes known as targets). Models generally can produce multiple outputs.

Our current API design chooses to expose each of these outputs as a separate name. We call these outputs "attributes".

## Comment

A **comment** is the text to be scored. Each API request contains a single
comment. A comment could be a single post to a web page's comments section,
a forum post, a message to a mailing list, a chat message, etc.

## Context (coming soon)

_(Coming soon)_ **Context** is a representation of the conversation context
for the comment, such as an article that is being commented on, or another
comment that is being replied to. It is used in the analysis of the
comment text, such as when determining the `OFF_TOPIC` model score.

**Note**: you can send context with your requests, however our current
attributes are not making use of it. At this time, sending context won't
change an attribute's scores.

## Method

A **method** is a procedure associating a message (or request) with an
object (which consists of data and behavior). A method request will return
a new object.

For example, the [`AnalyzeComment` method](methods.md#scoring-comments-analyzecomment)
sends a request to score the comment object. The comment object includes
comment text, context, and more. The method then return the attribute span
scores.

### Score types

**Score types** are different formats for the API to return attribute
scores. Currently, the only score type supported is the probability score
type with a value between 0 and 1. Higher values indicating greater likelihood
of the attribute label.

## Span

A **span** is a continuous section of text. The API can return span scores,
which are attribute scores for particular subparts of the request's comment.

### Span scores

A **span score** is a score type for subparts of the request's comment.

For example, if the API only found one sentence in a paragraph to be "toxic",
it could return a high "toxic" span score for the span corresponding to that
sentence while giving a low "toxic" span score to the rest of the comment.
This score is only available for some attributes.

### Summary Score

An attribute's **summary score** provides an overall score for the entire
comment. While the API may return multiple span scores for a given input, it
will always return exactly one summary score.

## `TOXICITY`

**`TOXICITY`** is an attribute which Perspective can score. `TOXICITY` is defined
as "a rude, disrespectful, or unreasonable comment that is likely to make you
leave a discussion."

## All reference materials

Read more about the Perspective API and how to use it.

* **Key concepts**
* [Attributes](models.md)
   * [Model cards](model-cards/README.md)
* [Methods](methods.md)
   * [Scoring comments](methods.md#scoring-comments-analyzecomment)
   * [Sending feedback](methods.md#sending-feedback-suggestcommentscore)
* [API client libraries](clients.md)
* [Limits and errors](limits.md)

repository: foreverest/perspectiveapi

repo_name: foreverest/perspectiveapi


text:
# Conekta::UpdateCustomer

## Properties

| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **antifraud_info** | [**UpdateCustomerAntifraudInfo**](UpdateCustomerAntifraudInfo.md) |  | [optional] |
| **default_payment_source_id** | **String** | It is a parameter that allows to identify in the response, the Conekta ID of a payment method (payment_id) | [optional] |
| **email** | **String** | An email address is a series of customizable characters followed by a universal Internet symbol, the at symbol (@), the name of a host server, and a web domain ending (.mx, .com, .org, . net, etc). | [optional] |
| **name** | **String** | Client's name | [optional] |
| **phone** | **String** | Is the customer's phone number | [optional] |
| **plan_id** | **String** | Contains the ID of a plan, which could together with name, email and phone create a client directly to a subscription | [optional] |
| **default_shipping_contact_id** | **String** | It is a parameter that allows to identify in the response, the Conekta ID of the shipping address (shipping_contact) | [optional] |
| **corporate** | **Boolean** | It is a value that allows identifying if the email is corporate or not. | [optional][default to false] |
| **custom_reference** | **String** | It is an undefined value. | [optional] |
| **fiscal_entities** | [**Array<CustomerFiscalEntitiesRequest>**](CustomerFiscalEntitiesRequest.md) |  | [optional] |
| **metadata** | **Hash<String, Object>** |  | [optional] |
| **payment_sources** | [**Array<CustomerPaymentMethodsRequest>**](CustomerPaymentMethodsRequest.md) | Contains details of the payment methods that the customer has active or has used in Conekta | [optional] |
| **shipping_contacts** | [**Array<CustomerShippingContacts>**](CustomerShippingContacts.md) | Contains the detail of the shipping addresses that the client has active or has used in Conekta | [optional] |
| **subscription** | [**SubscriptionRequest**](SubscriptionRequest.md) |  | [optional] |

## Example

```ruby
require 'conekta'

instance = Conekta::UpdateCustomer.new(
  antifraud_info: null,
  default_payment_source_id: src_1a2b3c4d5e6f7g8h,
  email<EMAIL_ADDRESS>  name: miguel,
  phone: +5215555555555,
  plan_id: plan_987234823,
  default_shipping_contact_id: ship_cont_1a2b3c4d5e6f7g8h,
  corporate: false,
  custom_reference: null,
  fiscal_entities: null,
  metadata: null,
  payment_sources: null,
  shipping_contacts: null,
  subscription: null
)
```

repository: conekta/conekta-ruby

gha_language: Ruby

gha_license_id: MIT

repo_name: conekta/conekta-ruby


text:
Your words can be sacred,

if you back them up with sacred acts.

The laughs are no other

than particles in the air,

don't let them make you cry, or swear,

or take yourself less seriously.

You can take yourself

as seriously as you want.

Who told you having faith was a sin?

Maybe the ones who saw it as hope;

but there are wrongs that look right;

faith shows certainty in one's acts.

They will laugh, talk and then forget,

so don't look for their acceptance,

because their focus never lasts,

so please, I beg to myself,

don't look for their acceptance,

but your own; learn to be alone;

being real, being whole,

and dying proud, at last;

isn't that what you wanted?

Dying with a smile.

repository: LuisArmando-TestCoder/Chubascos

gha_language: TypeScript

repo_name: LuisArmando-TestCoder/Chubascos


text:
# packer-template
Template for packer to build automated image

## How to run template from this repository.
# Creating lxc/lxd image.
We assume the target node has git and packer already installed.
1. Clone this repo into the lxd node where image will be build.
2. pwd to lxd directory in the repository
3. Next we need to findout fingerprint of the image we want to dowload. Dont download image for virtual-machine.
4. `sudo lxc image list images: centos | grep -i centos/7` for centos7 image.
5. Similarly find fingerprint for ubuntu/centos/archlinux/others lxd image.
6. Download that centos7 image to local image directory
```
sudo lxc image copy images:f603184f60a0 local: --alias centos7-base
```
7. Do same for centos8
```
sudo lxc image copy images:d6f1ddce4258 local: --alias centos8-base
```
8. And same for others like archlinux
```
sudo lxc image copy images:5308133149fd local: --alias archlinux-base
```
9. And same for ubuntu16/18/20
```
sudo lxc image copy images:9dcbcd968453 local: --alias ubuntu-xenial
sudo lxc image copy images:208453f095e0 local: --alias ubuntu-bionic
sudo lxc image copy images:c8d5f27751e6 local: --alias ubuntu-focal
```
10. Now you can run template to build lxd image.
11. Ubuntu `sudo packer build ubuntu16/18/20.json`
12. CentOS7 `sudo packer build centos7.json`
13. CentOS8 `sudo packer build centos8.json`
14. Archlinux`sudo packer build archlinux.json`

# Creating VM for esxi.
## Running packer is vital on from where we are running this command.
For centos7.
1. pwd.
```/Users/mac/Documents/github/packer-template/vm/centos/centos-7```
2. ls.
```centos-7-x86_64-ansible.json```
3. Now run.
```packer build -only=esxi-iso centos-7-x86-64-ansible.json```

For Freebsd12.
1. pwd.
```/Users/mac/Documents/github/packer-template/vm/freebsd```
2. ls.
```build_all.bat  build_all.sh  freebsd-12.0-release-ansible.json  install.sh```
3. Now run.
```packer build -only=esxi-iso freebsd-12.0-release-ansible.json```

## more from
https://github.com/upperstream/packer-templates


text:
# SubZero Workshop

## Monitoring

Secure the application API using a Cognito User Pool.

### AWS Services / Features

- X-Ray
- CloudWatch
- ServiceLens?

### Module Challenges

- Create a Cloudwatch Dashboard via the AWS GUI.
- Create graphs or tables of metrics that would be useful to track (i.e. # of invocations, Error Codes, Latency, X-Ray Metrics)
- Export dashboard information to json and use it to add a `AWS::CloudWatch::Dashboard` to your CloudFormation template.

repository: brysontyrrell/SubZero-Workshop

gha_language: Python

repo_name: brysontyrrell/SubZero-Workshop


text:
CherwellAPI is a suite of Python modules that abstract the Cherwell REST API and simplify the process of connecting to, and interacting with Cherwell business objects.

Base Functionality Included
===========================

1. AdHoc searching
2. Encrypting the password and client_key
3. Instantiating a connection object with Encryption
4. Instantiating a connection object without Encryption
5. Creating new business objects
6. Updating existing business objects
7. Deleting existing business objects
8. Running a Saved Search
9. Logging out of Cherwell

The modules also cater for caching of commonly used items such as templates, summaries and business object id's as well as self-managing the expiry and refreshing of the Bearer token used for authorisation. Additionally Tokens can be cached and reused.

Encrypting the password and client_key
======================================

Only needs to be executed once, or when credentials change.

All interaction typically takes place the CherwellCredentials Library which can be instantiated as follows:

```python
from CherwellAPI import CherwellCredentials

CherwellCredentials.create_encrypted_cherwell_credentials(<password>,<api_key>)
```
*Replace the parameters between '<>' with appropriate values from your own Cherwell instance.*

Instantiating a connection object with Encryption
=================================

Step 2 "Encrypting the password and client_key" must be completed once before this step is executed.

All interaction typically takes place through a **_Connection_** object which can be instantiated as follows:

```python
from CherwellAPI import CherwellClient

cherwell_client = CherwellClient.Connection(<base_uri>,None,<username>,None)
```
*Replace the parameters between '<>' with appropriate values from your own Cherwell instance.*

This will search for the stored encryption files you created when running the

Instantiating a connection object without Encryption
=================================

All interaction typically takes place through a **_Connection_** object which can be instantiated as follows:

```python
from CherwellAPI import CherwellClient

cherwell_client = CherwellClient.Connection(<base_uri>,<api_key>,<username>,<password>)
```
*Replace the parameters between '<>' with appropriate values from your own Cherwell instance.*

Creating a new business object
==============================

A new Incident could be created as follows:

```python
from CherwellAPI import CherwellClient

# Create a new CherwellClient Connection
cherwell_client = CherwellClient.Connection(<base_uri>,<api_key>,<username>,<password>)

# Create a new instance of an Incident business object
Incident = cherwell_client.get_new_business_object("Incident")

# Set the properties of the new Incident
Incident.CustomerDisplayName = "John Allard"
Incident.Description = "This is a test Incident"
Incident.Priority = 5
Incident.Service = "IT Service Desk"
Incident.Category = "Report Outage or Error"
Incident.Subcategory = "Submit Incident"
Incident.Source = "Event"

# Save the new Incident
Incident.Save()

# Show the new business object record id
print("RecId for new Incident: {}".format(Incident.busObRecId))
print("PublicId for new Incident: {}".format(Incident.busObPublicId))

```
Output from executing the script above would likely looks as follows:

*RecId for new Incident: 944cccbc07cde32400bea6482a8c3dd1f36dc57d6b*

*PublicId for new Incident: 102401*

**Note:** *Depending on how your Cherwell instance is configured, you might need to supply more or less property values, or even different values*

Updating a business object
==========================

The following code snippet, show an example of how to get an instance of the Incident we created in the previous step and update it.

For this we need to import and use the **_SimpleFilter_** object, which we can populate with one or more filters to aid in searching.

```python

from CherwellAPI import CherwellClient
from CherwellAPI import Filter

# Create a new CherwellClient Connection
cherwell_client = CherwellClient.Connection(<base_uri>,<api_key>,<username>,<password>)

# Create a new SimpleFilter object instance,
# indicating the filter is applicable for the Cherwell 'Incident' business object
search_filter = Filter.SimpleFilter("Incident")

# Add some search filters - we are looking for the Incident created previously
search_filter.add_search_fields("IncidentID", "eq", "102401")
search_filter.add_search_fields("Status", "eq", "New")
search_filter.add_search_fields("Description", "contains", "test")

# Pass the Simple filter object to the CherwellClient - 'get_business_objects' method
# This method returns the number of matching business objects as well as the list of matching business objects
num_records, business_objects = cherwell_client.get_business_objects(search_filter)

# Print number of records returned
print("Number of records: {}".format(num_records))

# Loop through the records returned
index = 0
for business_object in business_objects:
    index = index + 1
    print("Record: {}".format(index))
    print("Public Record Id: {}".format(business_object.busObPublicId))
    print("Status: {}".format(business_object.Status))

    # Change the Incident description
    business_object.Description = "Updated the description"

    # Save the updated business object
    business_object.Save()

```

Deleting the previously created Incident
========================================

Deleting an object is just as easy, see below for an example of deleting the Incident record we updated in the previous step.

```python

from CherwellAPI import CherwellClient
from CherwellAPI import Filter

# Create a new CherwellClient Connection
cherwell_client = CherwellClient.Connection(<base_uri>,<api_key>,<username>,<password>)

# Create a new SimpleFilter object, indicating the filter is applicable for the Cherwell Incident business object
search_filter = Filter.SimpleFilter("Incident")

# add a search filter where we are looking for the Incident created previously
search_filter.add_search_fields("IncidentID", "eq", "102401")

# Pass the SimpleFilter object instance to the CherwellClient
# This method returns the number of matching business objects as well as the list of matching business objects
num_records, business_objects = cherwell_client.get_business_objects(search_filter)

if num_records == 1:

    # We should only have 1
    business_objects[0].Delete()

```

Running a Saved Search
==========================

The following code snippet, show an example of how to run a saved search on the Cherwell Platform.

```python

from CherwellAPI import CherwellClient

# Create a new CherwellClient Connection
cherwell_client = CherwellClient.Connection(<base_uri>,<api_key>,<username>,<password>)

# Pass the association, scope, saved search name to the CherwellClient's get_saved_search_results
# This method returns the results of the saved search
num_records, business_objects = cherwell_client.get_saved_search_results("FederationRegistration","Global","All Active Federation Sources")

# Print number of records returned
print("Number of records: {}".format(num_records))

# Loop through the records returned
for business_object in business_objects:
    print(business_object)

```

For more examples, refer to our GitHub project [here](https://github.com/streamline-partners/CherwellAPI/tree/master/Examples).

Full source code can be found [here](https://github.com/streamline-partners/CherwellAPI).

To find out more about Streamline Partners and how we could assist you with future projects, click [here](http://www.streamlinepartners.com.au/)

repository: streamline-partners/CherwellAPI

repo_name: streamline-partners/CherwellAPI


text:
# Known Issues
This page lists the known issues and potential next steps when deploying OpenShift (OCP) in Power Systems Virtual Server (PowerVS)

-  **Terraform apply returns the following error**

    > **"Error: timeout - last error: Error connecting to bastion: dial tcp
    > <IP_ADDRESS>:22: connect: operation timed out"**
    >
    > **Cause:** The public network attached to bastion is not reachable.
    >
    > Ping to the public/external IP of bastion node (eg. <IP_ADDRESS>)
    > will not return any response
    >
    > **Workaround**: Re-run TF again and if it doesn't help, destroy the TF resources and re-run.
    >
    > If it doesn't work, then please open a support case with IBM Cloud to fix issue with reachability of public IP for PowerVS instance.

-  **RHCOS instances in dashboard shows \"Warning\" Status**

    > **Cause**: This is due to RSCT daemon not being available for RHCOS
    >
    > **Workaround**: None
    >
    > You can ignore this. This will be fixed soon.

-  **Terraform apply fails with instance is not reachable error**

    > **Cause**: Sometimes the instances don't boot and and accessing the instance console from IBM Cloud dashboard shows  *grub rescue*
    >
    > **Workaround**: Rebooting the instance helps. If still facing the same
    > issue, try destroying the TF resources and re-running the deployment
    >

- **Terraform apply fails with instance is not reachable error**

    > **Cause**:  Sometimes the instances don't boot and and accessing the instance console from IBM Cloud dashboard shows  *connect:   network is unreachable*
    >
    > **Cause**: Unknown
    >
    > **Workaround**: Rebooting the instance helps.
    >

- **Terraform provisioning fails with the following error**

    > **Error: Failed to get the instance Get https://eu-de.power-iaas.cloud.ibm.com/pcloud/v1/cloud-instances/d239797b-7b2e-     > 4790-a29d-439567556c83/pvm-instances/7d836f7d-8f21-4bef-9e10-ae6d8c2167a1: context deadline exceeded
    > on modules/4_nodes/nodes.tf line 92, in resource "ibm_pi_instance" "master":
    > 92: resource "ibm_pi_instance" "master" {**
    >
    >**Reapply will also fail**
    >
    >**module.nodes.ibm_pi_instance.master[0]: Creating...
    >Error: Failed to provision {"description":"bad request: invalid name server name already exists for cloud-     instance","error":"bad request"}
    >on modules/4_nodes/nodes.tf line 92, in resource "ibm_pi_instance" "master":
    >92: resource "ibm_pi_instance" "master" {

    > **Cause**: IBM Cloud API failed but resource got created and TF doesn't know that the resource got created.
    >
    > **Workaround**: Manually delete the resource from the dashboard and re-apply
    >

- **Terraform destroy fails with the following error**

    > **Error: {"description":"an error has occurred; please try again: unable to delete subnet for network 30dab9c3-  0e4b->     > 41b0-94b2-d865769b8056 for cloud instance b88bf8fc4d3349ffa4d1497e24996b1f: Expected HTTP response code [] when  accessing [DELETE https://<IP_ADDRESS>:9696/v2.0/subnets/7776ef27-bb9f-4358-a5d3-564f33a3201f], but got 409  instead\n{\"NeutronError\": {\"message\": \"Unable to complete operation on subnet 7776ef27-bb9f-4358-a5d3-564f33a3201f: One  or more ports have an IP allocation from this subnet.\", \"type\": \"SubnetInUse\", \"detail\": \"\"}}","error":"internal  server error"}**
    >
    > **Cause**: A previous failed apply resulting in inconsistency where the instance is created but TF is unaware of the same
    >
    > **Workaround**: Delete the instance and the associated network from the dashboard and re-run destroy

- **Accessing IBM Container Registry fails with the following error**

    > **TLS handshake timeout**
    >
    > **Cause**: This is due to the MTU settings of the underlying GRE tunnel used for public internet access.
    >
    > **Workaround**: Set MTU of the public interface in bastion to 1450.
    >
    > Let's say env3 is the public interface then set MTU to 1450 by running the following command
    > `ifconfig env3 mtu 1450`


text:
# CloudApp/Google Drive Webhook on Heroku

This project creates a webhook for [CloudApp][cloudapp] to upload video and
images to a company Google Workspace Google Drive API running on a Heroku
Python server.

## Install

### Virtual Environment

```console
$ pipenv run python3 -m pip install --upgrade pip
$ pipenv install
$ pipenv sync --sequential
```

### Shell Envrionment

```console
$ pipenv shell
```

Optionally, run a command without being in shell:

```console
$ pipenv run [OPTIONS] COMMAND [ARGS]
```

End session:

```console
$ deactivate
```

## Configuration

There is a [`settings.py`][settings] file which contains all the configuration
settings you may need. Please go through this file and change these settings
to your environment.

### CloudApp

You will need a paid [CloudApp][cloudapp] account in order to use this webhook.
Within CloudApp you will also need to configure a custom domain and endpoint
which will need to be configured in the `settings.py` file where you see the
[HTTP_URL][appurl] environment setting.

### Heroku

This application is set up to work with a [Heroku][heroku] virtual server and
you will need to add your Google Drive API details to the
[`heroku.json` file here][heroku-config].

### Using rclone

If you're going to use `rclone` be sure to change your Team Drive ID
(`team_drive`) in the `rclone.conf` file.

## Deployment

Deployment to a Heroku server is out scope for this README and you will
need to set up and configure your own workflow and pipelines in Heroku.

I do use a [Fabric][fabric] file which you'll find at `./fabfile.py` for
deployments to GitHub, and Heroku, using Heroku Git. You can work off this file
to configure your own deployments to Heroku.

### Heroku Buildpacks

When you do configure your server in Heroku you will need to add two buildpacks
to your server. Click on **Settings** within your app
(e.g. `https://dashboard.heroku.com/apps/cloudapp-python/settings`) and scroll
down to the Buildpacks section.

Click the **Add buildpack** button and add these two buildpacks:

1. `heroku/python`
2. `https://github.com/22digital/heroku-gdrive-buildpack.git`

The second buildpack [found at 22 Digital][buildpack] has been
tailored and customised to work with this app. This buildpack
will install all the dependencies you need on Heroku.

## Webhook Endpoint

The webhook endpoint is configured to be the domain you set in `settings.py` as
your `HTTP_URL` and the endpoint only accepts a `POST` request.

Consider the following `cURL` request:

```
curl -X POST --location "https://cloudapp-python.herokuapp.com" \
    -H "Accept: application/json" \
    -H "Content-Type: application/json" \
    -d "{
            \"event\": \"post\",
            \"payload\": {
                \"item_name\": \"Test Image\",
                \"item_url\": \"https://cloudapp.com/image.jpg\",
                \"created_at\": \"2021-06-22 22:22:22\"
            }
        }"
```

CloudApp will send a `POST` request to `https://cloudapp-python.herokuapp.com`
and it should always contain the `event` and `payload` properties. The app will
use these and save the `event`, `item_name`, `item_url`, and `created_at` in the
SQLite database and return a `success` message with a `200` response code.

```
HTTP/1.1 200 OK
Connection: keep-alive
Server: nginx
Date: Wed, 23 Jun 2021 23:18:27 GMT
Content-Type: application/json
Transfer-Encoding: chunked
Via: 1.1 vegur

{
  "event": "success",
  "code": 200,
  "payload": {
    "id": "207",
    "item_name": "Test Image",
    "item_url": "https:\/\/cloudapp.com\/image.jpg"
  }
}

Response code: 200 (OK); Time: 1890ms; Content length: 125 bytes
```

The app will also send out an email to the email address configured in
`settings.py` confirming the new media upload.

## License

Copyright (c) 2020-2021, Justin Hartman <https://justinhartman.co>.

This project is licensed under an [`MIT`][mit] and details can be found in the
[LICENSE][license] file.

[heroku]: https://heroku.com
[fabric]: https://getfabric.com
[cloudapp]: https://getcloudapp.com
[license]: LICENSE
[mit]: https://opensource.org/licenses/MIT
[buildpack]: https://github.com/22digital/heroku-gdrive-buildpack
[settings]: https://github.com/justinhartman/cloudapp-webhook/blob/master/settings.py
[appurl]: https://github.com/justinhartman/cloudapp-webhook/blob/master/settings.py#L34
[heroku-config]: https://github.com/justinhartman/cloudapp-webhook/blob/master/.config/heroku.json

repository: justinhartman/cloudapp-webhook

branch_name: refs/heads/main

repo_name: justinhartman/cloudapp-webhook


text:
# DataLoader mongoose

## Synopsis

Default mongoose loader for Facebook dataloader https://github.com/facebook/dataloader

## Code Example

```
const { dataLoaderMongoose } = require('dataloader-mongoose');

const shipDefaultLoader = new DataLoader(ids => dataLoaderMongoose(mongoose.model('Ship'), ids));

```

## Installation

```
npm install mongoose dataloader dataloader-mongoose
```

## Tests

TODO: add some tests

## License

Graphql relay mongoose is released under the [MIT License](https://opensource.org/licenses/MIT).

repository: geekcups-team/dataloader-mongoose

repo_name: geekcups-team/dataloader-mongoose


text:
---
title: Making Twitter Bot with R
author: ~
date: '2017-10-29'
slug: making-twitter-bot-with-r
categories: [R,Twitter,Automation]
tags: [R,httr,rtweet,twitter,bot]
thumbnailImagePosition: "right"
thumbnailImage: http://res.cloudinary.com/dstcxl6nt/image/upload/v1509295892/bot-icon_kc9ghk.png
draft: yes
---

I was just playing with Twitter API so that I could automatically like Tweets from certain twitter account (for example twitter account of my workplace). And then I realized
you can do quite more than just like the tweet. You can re-tweet the tweet, follow people, send messages and lot more. In this post I am going to show the basics of how to set-up the twitter automation and you can add your own tricks on top of my basic scripts.
<!--more-->

Before we fire R-studio or R console first you need to set up the twitter app and get the API credential.The R package that we also be using is Rtweet and the package page in git-hub has a detail instruction on how to set up your twitter API [here](http://rtweet.info/articles/auth.html).

Once everything is done let's load the required packages.

```
library(rtweet)
library(httr)

```
*Rtweet* is a wonderful package to do data mining task using data from twitter API, it also has ability to use
twitter live streaming API which allows access to real-time tweets. And I am using *httr* in addition to rtweet as I couldn't find some certain post request so I am going to post tweet using *httr* post function.

Let's authenticate the app so that we can pull tweets from twitter. Once you run the code below it should redirect you to browser so that you can authenticate the app to use your twitter account.

```
#    Register an application at https://apps.twitter.com/
#    Make sure to set callback url to "http://<IP_ADDRESS>:1410/"
#
#    Replace key and secret below

appname <- "appname"

## api key (example below is not a real key)
key <- "Ea...."

## api secret (example below is not a real key)
secret <- "rIaxx....."

myapp <- create_token(app = appname,
                  consumer_key=key, consumer_secret=secret)
```

Once authentication is successful now we can get the search tweet that has hash-tag *Rstudio*, if you don't specify the number then by default search_tweets function from *rtweet* will give 100 tweets and since options helps us to filter the tweets so that we collect the tweet of today.

```
rt2 <- search_tweets("#Rstudio", token = twitter_token,include_rts = TRUE,type = "recent",since_id=Sys.date())
```
Now once you do that **rt2** will return a nice data-frame containing the text of tweet,date, user who tweeted and many other interesting data. Here all I am after is **status_id**, I need status id order to re-tweet the particular tweet. The only problem was that I couldn't find the **Post Retweet** request in the *rtweet* package so I am going to create my own using package *httr*.

We need to authenticate the app again using *httr*. If you have been using R to connect to API then you might not need any introduction but for others who've not used *httr* this is an excellent package by Hadley, see more [here](https://github.com/r-lib/httr/blob/master/demo/oauth1-twitter.r)

```
auth_endpoints("twitter")

myapp2 <- oauth_app("twitter",
  key = key,
  secret = secret)

# 3. Get OAuth credentials
twitter_token <- oauth1.0_token(oauth_endpoints("twitter"), myapp2)

```
Once authentication is successful now we can automate the re-tweet.

```
POST(paste0("https://api.twitter.com/1.1/statuses/retweet/",rt2$status_id[1]),config(token = twitter_token))
```
This should re-tweet the first tweet from the data-frame rt2. If you want to re-tweet all tweet, then we can just write a loop.

```
# Here I am going to retweet the original tweet not the retweet and I will also pause for a whilte before I retweet next tweet so that I wouldn't fire all the retweet in a fraction of seconds(so that my tweet doesn't look suspicious)

for(n in 1:nrow(rt2)){
  if (rt2$is_retweet[n] == FALSE) {
    POST(paste0("https://api.twitter.com/1.1/statuses/retweet/",rt2$status_id[n]),config(token = twitter_token))
    print(paste0("Retweeted: ",rt2$text[n]))
  } else {
    print(paste0("is retweet: ",rt2$text[n]))
  }
  sleep_time <- runif(1, min=0, max=10)
  print(sleep_time)
  Sys.sleep(sleep_time)
}
```
As I said earlier you can do more than re-tweet. Now using the *rtweet* package you can follow or favorite the tweet without leaving your R console. See all the trick on the git-hub page pf [rtweet](http://rtweet.info/index.html)

```
# If you want to follow the user
post_follow(rt2$user_id[1])
# Post Favourite
post_favorite(rt2$status_id[1])
# or tweet palin text tweet
plain_tweets("txt")
```

Okay there we go, the above script will give you a basic skeleton to automate your re-tweet or tweet. You can schedule the script to run during certain time using cron job or create a loop that keeps finding a new tweet and keeps re-tweeting it. You can automate however you want to, I hope you'd find my script helpful.


text:
---
layout: post
title: "FastKat 2"
description:
image: 'https://www.omiod.com/gfx/fastkat/fastkat-2-logo.png'
category: 'Fun'
tags:
- FastKat
- Speed
- Fast
- BrainPower
---

<button onclick="openFullscreen()">Fullscreen</button>

# Instructions

Controls: Mouse

# Description

soon


text:
# PySOE v0.03a
Python Simulated Operating System Environment or PySOE is a closed sandbox environment that runs inside *any* Python Interpreter. It's main purpose is to run it's own small ecosystem of apps specifically created for it.

//You probably shouldn't be here//

//Unless you're developing apps//

//Then you can stay//

# Application Ecosystem Library
*IF YOU NEED A TUTORIAL ON HOW TO USE THESE, THIS PROGRAM IS NOT FOR YOU*
#
Apps made by Carson Goodwin (LTEGaming)

-SOEgraph (Adapted from Py-Graph) *Incomplete as of 12/11/16*

-SOEvm *Incomplete as of 12/11/16*

-SOEcalc *Incomplete as of 12/11/16*
#

Yes, you can infact sell this. Or take the source code and turn it into your own program with minimal work.

I don't care that much. It's a BSD license, do what you want.

# How do i use this?

1. Create a directory (Preferably on desktop for easy access)
2. Install Programs you want to use from either Applications-Dev or Applications-Stable into the same directory with Shell, Login, Main, and progs.txt files.
3. Use your Python Interpreter to open main.py

# Current Commands
As of 0.03a:

-listcommands: Lists Commands

-help: Lists Commands

-time: Shows System Time

-ver or -version: Shows OS version

-print or -pr: Prints to display

-prog or -programs: Lists all available integrated programs

-ext or -extras: Extra side commands

-inst or -install: Installs a new program into your program list.

# Extra Commands:
As of 0.03a

-his or -history: History of PYOS

-beep: Beep

repository: LTEGaming/PySOE

repo_name: LTEGaming/PySOE


text:
# 1. environments

Date: 2018-04-16

## Status

Pending

## Context

We want to have separate environments for running our software at different stages of release.
This will be used to provide a location where changes can be tested without impacting
production work and our users.

## Decision

We have decided to have two separate environments, staging and production. The staging
environment will be where the tools team and other people working on monitoring
and metrics itself will test their changes. The production environment will run
all of our users monitoring and metrics and poll each of their environments.

## Consequences

Keeping the two environment separate reduces the chance of a core change impacting
our users and will allow us to test aspects of our system such as handling load,
fail over testing and new, possibly behaviour changing, version upgrades. Users will
test their prometheus related changes in our production environment and will not have access
to the staging environment.

repository: timmow/monitoring-doc

repo_name: timmow/monitoring-doc


text:
# Core

Licence: [MIT](https://opensource.org/licenses/MIT)

---

[![npm version](https://badge.fury.io/js/superhero.svg)](https://badge.fury.io/js/superhero)

This is the source code of the Superhero Core Library.

You can read the [Superhero Core Library documentation](https://superhero.github.io/documentation.html#superhero-core) to gain a more comprehensive understanding of each specific component.

Or you can familiarize yourself with [the essential ideas that drive the Superhero Core Library](https://superhero.github.io/book/process-design-with-eventual-consistency.html), and learn to adeptly apply the Superhero Core in coordination with other key components in the Superhero Tool Chain, to achive a simple process design, based on an eventual consistency model, using event sourcing.

gha_language: JavaScript


text:
# XCF: Web Application

This is both the front- and backend for the XCF-Web-Application.

## Related repositories

The actual XCF itself is contained in the [`xcf` Git repository](https://github.com/IRT-Open-Source/xcf) and
provides necessary helper files.

## Running the application

### First time run

To run the application you can either use the provided `config.default.xml` or create your own config file or by copying the deafult config:

```bash
cp backend/app/config.default.xml backend/app/config.xml
```

> **By default:** `config.default.xml` is used and no further steps are required.

### About the config file

Applications can be run from arbitrary URLs, local installations are possible.
Just point the engine and rules to a local folder. Please use absolute paths or even better
`file://`-URLs.

```xml
<config>
  <xcf-engine>https://subtitling.irt.de/xcf_sample/engine/</xcf-engine>
  <xcf-rules>https://subtitling.irt.de/xcf_sample/rules/</xcf-rules>
</config>
```

Make sure your `engine` & `rules`-folders contain at least the following files:

```bash
├── engine
│   └── reportview.xsl
└── rules
    ├── constraints.xml
    ├── rules_compiled.xsl
    └── rules_config.xml
```

For more information on what these files do, please refer to:

In short:

* `rules_compiled.xsl` contains a transformation that performs the actual checking
* `constraints.xml` contains detailed information for a given error, that will be added to the report
* `reportview.xsl` is used to convert a report a more user friendly format
* `rules_config.xml` can be used to configure which checkboxes in the web-fronted are initially checked

### Development

For development start `webpack-dev-server`:

```bash
cd frontend && npm -s install && npm run dev
```

alongside the `basexhttp`-backend:

```bash
cd backend/app && bin/basexhttp
````

The frontend will be served at [localhost:8080](http://localhost:8080) and requests to the BaseX HTTP backend will be proxied automatically by webpack.

### To Build from Source and run in production

```bash
# Build the frontend
cd frontend && npm -s install && npm run build && cd ..
cp frontend/dist/index.html backend/app/webapp/
cp -r frontend/dist/assets backend/app/webapp/
# Start basexhttp
cd backend/app && bin/basexhttp
```

### To build a docker container

```bash
# Build the frontend
cd frontend && npm -s install && npm run build && cd ..
docker build -t xcf-check . && docker run -p 80:8984 xcf-check
```

## License

The web frontend is offered by [BaseX GmbH](https://www.basex.org) and licensed under the [MIT license](LICENSE).

repository: ctalau/xcf-webapp

repo_name: ctalau/xcf-webapp


text:
#jsbridge

JSBridge for jsvascript

- request format: `protocol://host:port/url[params]`
    - eg: `jsbridge://kjc/{"type":"action","name":"share","callback":"callback_1466131023000"}`
    - eg: (supposed) `jsbridge://kjc/action/share?callback=callback_1466131023000&title=title`
- params
    - `protocol`:
        - customize protocol name
        - cannot use protocols like `http` `https` `ftp` etc.
    - `host` & `port` & `url`
        - for dispatch
        - `host` and `port` can be empty
    - `params`
        - data you want to send
        - can be key-value string like original url

## Readme

This is a very-base realization of JSBridge.

It is mainly for pages embedded in native app to communicate with their host by breaking `webview`;

## Description

The package provides two methods, `invoke` for javascript and `callback` for native app.

The Communication only could be called up in javascript,and then native app can reply sth. with callback.

(Calling up in native app would support in the next version);

## Usage
- Javascript side
```js
// node environment (webpack or es6)
const JSBridge = require('jsbridge').init('jsbridge','localhost');

JSBridge.invoke('action',{key: value},(params) => { console.log(params) });

// original javascript
// <script src='node_modules/jsbridge/dist/index.js'></script>

JSBridge.invoke('action',{key: value},(params) => { console.log(params) });
```
## API methods

- init(protocol,hostname,port,isjson)
    - init url preferences(try not to call it again, it would cover globally)
    - if `isjson` is true, all params would padding by json-object instead of `key-value`
- invoke(url,params,callback)
    - call up a communication with native app
- callback(callbackname,params)
    - callback a function pass by `invoke`

repository: yeliex/jsbridge

repo_name: yeliex/jsbridge


text:
# Reboot CMS

A Bootstrap concentric, flat file, Markdown CMS in PHP, inspired by [Pico](http://picocms.org) and [Redaxo](https://redaxo.org/).

A minimal CMS without needing a database, but with the support
of `Blocks`.

## Sites using reboot-cms

- www.wukies.de

## Install

Download this repository, [install composer](https://getcomposer.org/download/),

and run `./composer.phar install`

## Main Objects

In short:

- `Page` = `Template` (look) + `Article` (content)
- `Article` = `Markdown file` (with blocks) or `PHP file`

### Article

Folder: `/local/articles`

An `Article` contains the content of a `Page`.

It can be a **flat Markdown** file, can contain multiple `Blocks` or
also can be a **PHP-File**, where everything is possible.

`Articles` are auto-routed on web-requests:

- `index.md` or `index.php` will be shown on requesting `/`
- `NAME.md` or `NAME.php` will be shown on requesting `/NAME`
- `FOLDER/index.md` (or .php) will be shown on requesting `/FOLDER`
- `FOLDER/NAME.md` (or .php) will be shown on requesting `/FOLDER/NAME`

Example for a Markdown `Article` with `Blocks`:

``` markdown
<!--
block: jumbotron
values:
    headline: Reboot CMS
    lead: A Bootstrap concentric, flat file, markdown CMS in PHP
    buttonText: Learn more
    buttonLink: /documentation
-->
The main idea is, to have a minimal CMS without needing a database, but with the support
of Blocks.

<!-- block: markdown -->
## This is a markdown block

Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod
tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam,
quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea
commodo consequat.
```
This `Article` contains two `Blocks`, "jumbotron" and "markdown". It will render to
this:

![](https://shaack.com/projekte/assets/img/cms_blocks.png)

Markdown files without blocks will render as a flat Markdown Article.

### Block

Folder: `/local/blocks`

A `Block` is a mostly horizontal section in an `Article`.
Blocks are written in PHP.

The code for the "jumbotron" `Block` which was used in the `Article` above,
looks like this:
``` php
<div class="container">
    <div class="jumbotron">

        <h1 class="display-4"><?= $this->value("headline") ?></h1>
        <p class="lead"><?= $this->value("lead") ?></p>
        <hr class="my-4">
        <?= $this->content() ?>
        <p class="lead">
            <a class="btn btn-primary btn-lg" href="<?= $this->value("buttonLink") ?>"
               role="button"><?= $this->value("buttonText") ?></a>
        </p>
    </div>
</div>
```

### Template

Folder: `/local/tempalates`

A `Template` describes how to render a `Page`. `Templates` are written in PHP.
The `default.php` Template is used, if no other `Template` is defined for an
`Article`.

## ToDos

- multi language support


text:
# bugger-v8-client (original readme)

Wonder what this thing does.

# More useful readme

This project provides an implementation and API to the unpopular but powerful nodejs debugging interface (that is actually v8-debug-interface). When you start nodejs with --debug flag, it starts TCP server that listens to the simple JSON rpc protocol, described [here](./PROTOCOL.md).

**TODO:** write API docs here.


text:
# rack-subdomain

[![Build Status](https://secure.travis-ci.org/mattt/rack-subdomain.png?branch=master)](http://travis-ci.org/mattt/rack-subdomain)
[![Code Climate](https://codeclimate.com/github/mattt/rack-subdomain.png)](https://codeclimate.com/github/mattt/rack-subdomain)

Rack middleware to transparently route requests with a subdomain to a specified path with substitutions.

## Usage

### Gemfile

``` ruby
gem 'rack-subdomain'
```

### config.ru

``` ruby
# Map all subdomains
use Rack::Subdomain, "example.com", to: "/users/:subdomain"

# Nested mapping with :except condition
use Rack::Subdomain, "example.com", except: ['', 'www', 'secure'] do
  map 'downloads', to: "/downloads"
  map '*', to: "/users/:subdomain"
end

# :to mapping with :only condition
use Rack::Subdomain, "example.com", only: ['', 'www'], to: '/nested'
```

## Contact

Mattt Thompson

- http://github.com/mattt
- http://twitter.com/mattt
-<EMAIL_ADDRESS>
## License

rack-subdomain is available under the MIT license. See the LICENSE file for more info.

repository: johnnyshields/rack-subdomain

repo_name: johnnyshields/rack-subdomain


text:
# What The Hack - App Modernization Hack

## Abstract and learning objectives

Modernize legacy on-premises applications and infrastructure by leveraging several cloud services, while adding a mix of web services.

Learning Objectives:

- Use Azure App Services
- Implement DevOps with Continuous integration/delivery/deployment with VSTS
- Detect, Diagnose, Monitor Application Performance with Application Insights
- Optimize & Protect Azure Web Application
- Optimize & Secure Azure SQL Database
- Optimize Entire Web Application Performance with Content Distributed Network (CDN)
- Optimize Partial Web Application Performance with Content Distributed Network (CDN)
- Increase Application / Database Performance with Redis Cache
- Use Search to make content full text searchable
- Accelerate development and take advantage of serverless using Azure Functions
- Monetize your data and services, and open new channels to customers using Azure API Management

## Overview

The App Modernization hands-on lab is an exercise that will challenge you to implement an end-to-end migration and modernization scenario using a supplied sample that is based on Microsoft Azure App Services and related services. The scenario will include implementing compute, storage, security, and search, using various components of Microsoft Azure. The hands-on lab can be implemented on your own, but it is highly recommended to pair up with other members at the lab to model a real-world experience and to allow each member to share their expertise for the overall solution.

## Requirements

1. Microsoft Azure subscription (non-Microsoft subscription)
2. **Global Administrator role** for Azure AD within your subscription
3. Local machine with Remote Desktop installed

## Repo contains:
- Challenges
- Proctor Guides
- Sample Web App to Migrate

repository: shawnweisfeld/WhatTheHack

gha_language: HTML

repo_name: shawnweisfeld/WhatTheHack


text:
# Nalika
Free dark design Bootstrap admin dashboard template

# Preview

### Screenshot

![Nalika admin dashboard template preview](https://colorlib.com/wp/wp-content/uploads/sites/2/nalika-simple-free-bootstrap-admin-dashboard.jpg)

### Demo Site: [Here](https://colorlib.com/polygon/nalika/index.html)

### Changelog
#### V 1.0.0
Initial Release
### Authors
[Colorlib](https://colorlib.com)

### More info
- [Bootstrap Admin Templates](https://colorlib.com/wp/free-bootstrap-admin-dashboard-templates/)
- [Angular dashboards](https://colorlib.com/wp/angularjs-admin-templates/)
- [Admin Dashboards](https://colorlib.com/wp/free-html5-admin-dashboard-templates/)
- [HTML Templates](https://colorlib.com/wp/templates/)
- [WordPress Themes](https://colorlib.com/wp/free-wordpress-themes/)

### License

Nalika is licensed under The MIT License (MIT). Which means that you can use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the final products. But you always need to state that Colorlib is the original author of this template.

repository: jayluxferro/Web-Templates

repo_name: jayluxferro/Web-Templates


text:
# Generating Swagger Documents for REST APIs

API documentation is important to guide the users on what they can do using specific APIs. Follow the steps given below to generate Swagger documentation for the REST APIs you created in the Micro Integrator.

!!! Info
    You need to have created a REST API to view the documentation for that API.

## Step 1: Configure the Micro Integrator

1.  Add the following configuration in `MI_HOME/conf/deployment.toml` file to generate the Swagger JSON or YAML files.
    ```toml
    [[server.get_request_processor]]
    item = "swagger.json"
    class = "org.wso2.micro.integrator.transport.handlers.requestprocessors.swagger.format.SwaggerJsonProcessor"

    [[server.get_request_processor]]
    item = "swagger.yaml"
    class = "org.wso2.micro.integrator.transport.handlers.requestprocessors.swagger.format.SwaggerYamlProcessor"
    ```
2.  Open the terminal, navigate to the `<MI_HOME>/bin` directory and start the Micro Integrator.

## Step 2: Generate the Swagger docs

### JSON

Enter the following on the browser and the JSON content will appear on the browser screen: http://<EI_HOST>:8280/<API_NAME>?swagger.json

- By default, <MI_HOST> is `localhost`. However, if you are using a public IP, the respective IP address or domain needs to be specified.
- Enter the APIs name for <API_NAME>.

!!! Note
    The API name is case sensitive. Therefore, make sure to the enter the API name correctly. Else, the JSON file will not download.

Example: http://localhost:8290/HealthcareAPI?swagger.json

### YAML

Enter the following on the browser and the YAML file will download to your machine: http://<MI_HOST>:8290/<API_NAME>?swagger.yaml

- By default, <MI_HOST> is localhost. However, if you are using a public IP, the respective IP address or domain needs to be specified.
- Enter the APIs name for <API_NAME>.

!!! Note
    The API name is case sensitive. Therefore, make sure to the enter the API name correctly. Else, the YAML file will not download.

Example: http://localhost:8290/HealthcareAPI?swagger.yaml

## Step 3: Copy JSON/YAML to Swagger editor

Copy the content of the JSON or YAML file to the Swagger Editor or any other tool and check out the documentation of the API.


text:
# Contributing

:wave: Hello there!
Welcome to **jsonsummarizer**! This document is about the guidelines for this repository. These are not necessarily rules. If you think this document needs some changes, feel free to propose a pull request to this document!

#### Table of Contents

| Table | of | Contents | |
| ----- | ----- | ----- | ----- |
| 1. [Code of Conduct](#code-of-conduct) |
| 2. [Simple Details On What Should You Know](#simple-details-on-what-should-you-know) |
| 3. [Ways To Contribute](#ways-to-contribute) |
| | 1. [Issues](#issues) |
| | | 3.1.1. [Reporting Bugs](#reporting-bugs) |
| | | 3.1.2. [Requesting Features](#requesting-features) |
| | 3.2. [Pull Requests](#pull-requests) |
| | | 1. [Your First Code Contribution](#your-first-code-contribution)
| | | | 1. [Local code development](#local-code-development)
| | | 3.2.2. [Creating Pull Requests](#creating-pull-requests)
| 4. [Additional Notes](#additional-notes) |
| | 4.1. [Issue Labels](#issue-labels)
| | 4.2. [Pull Request Labels](#pull-request-labels)

# Code of Conduct

This repository and everyone participating in it is governed by the Code of Conduct. When you participate, people will expect you to show behavior according to this code. If you find unacceptable behavior, report these kind of behavior to [the<EMAIL_ADDRESS>or the repository's maintainers or collaborators.

# Simple Details On What Should You Know

**jsonsummarizer** is a repository/project that's simple enough, it serves simple functions. The project might expand to other great functionalities, and it should be simple to contribute to the project. E.g. if there is any issue in the Issue Tracker requesting a feature, you can attempt to provide requested feature by creating a pull request.

It's also a new project, so it might not contain enough functions to your needs.

# Ways To Contribute

## Issues

### Reporting Bugs

When you encounter a bug, you should report it as an issue in this repository! This section should help you on creating an issue for a bug!

Just make sure the issue you are creating is non-existent. You should check [this list](https://github.com/KaanGaming/jsonsummarizer/issues) before creating a new issue, because you might find a similar issue to the one you might be creating. Make sure your issue is descriptive enough. You can use [this bug template](https://github.com/KaanGaming/jsonsummarizer/issues/new?assignees=&labels=&template=bug_report.md&title=%5BBUG%5D) if you think you can't write one from scratch.

> **Note**: This repository provides small amount of functions, but don't let this note hesitate you from anything!

> **Also**, if you find a closed issue that seems like the issue creator is experiencing the same thing as what you are experiencing, make sure to open a new issue then link the closed issue.

**On creating a (good) bug report, you should...**

* **Provide a good and descriptive title** for your issue to clarify the problem you're experiencing.
* **Give the exact steps on reproducing the problem**. Give the JSON code that has caused this issue. *If the JSON itself has a syntax error, it's not a bug.* Make sure to explain how you did it, too.
* **Provide an explanation on what strange things you observed after the reproduction steps, if there are any.**

Also, if there is any other additional detail that isn't provided here, make sure to include these in your issue too. If the reproduction and other details can't help, the additional details can be the last resort.

### Requesting Features

Is there any missing functions that would have helped you if they existed? Requesting features are welcome here! First, check if someone [already requested your feature](https://github.com/KaanGaming/jsonsummarizer/labels/feature%20request), or if someone has [already proposed a PR to your request](https://github.com/KaanGaming/jsonsummarizer/labels/feature).

**On creating a (good) feature request...**

* **Provide a good and descriptive title** for your issue to clarify the problem you're experiencing.
* **Provide steps of the requested feature** in as many details as possible.
* **Provide media to demonstrate the feature**. This can be anything related to your concept/feature.
* **Explain why this feature would be useful** to other users of jsonsummarizer.
* **Provide extra details if there is any.**

## Pull Requests

Do you want to expand the functionality in this project? Or do you want to fix some stuff? Either way, great! PRs are always welcome in this repository! This section aims to help you on some topics.

### Your First Code Contribution

Not sure how you can start contributing to jsonsummarizer? You can take a look at these issues:

* **[Good First Issues](https://github.com/KaanGaming/jsonsummarizer/labels/good%20first%20issue)**: These issues are for beginners who want to contribute to Express.js applications! These issues should be easy to fix. Recommended issues.
* [Help wanted issues](https://github.com/KaanGaming/jsonsummarizer/labels/help%20wanted): These issues should be a lot more involved than **good first issue**s.

#### Local code development

The repository can be cloned and be coded in your OS without visiting GitHub. Here are the steps you should follow:

1. (Optional but recommended) Fork the repository. If you fork the repository, you can edit the code locally then upload it to your fork hosted on GitHub! You can still code offline without any forks using `git clone`.
2. **Install the dependencies** by using `npm install`. It should download all dependencies. (`node_modules` isn't included when cloning the repository.)
3. **Run the server** using either `nodemon` or `node .`. The difference between `nodemon` and `node .` is the `nodemon` command restarts the code when it detects any changes in JavaScript or JSON files, and not the HTML files. HTML files and other static files found in `www/` change automatically regardless of what command you are using.
4. **Commit changes once you are done** coding in your local directory and commit changes by first adding all (or only specific files) by using either `git add *` (adds all changed files to commit) or `git add [INSERT FILENAME]` to add only one single file in one command. Then use `git commit`, which launchs the Vim editor. If you don't have Vim installed, it will simply display an error relating to Vim not being installed. You can install Vim by doing `pkg install vim`. If you don't want to install Vim, you can use `git commit -m "insert message"` to commit without entering Vim editor. To use Vim editor, push the `INSERT` key to start editing the file. Then `ESC` to use commands in Vim and then type `:w` to save, `:wq` to save and quit, or `:q` to simply quit. You can leave the commit message empty in Vim editor to cancel the commit.
5. **Push the changes to your fork** using `git push`. If you have cloned using SSH, enter your passphrase, if you cloned using HTTPS, enter your username and password.

Also, when there are any changes in your fork from GitHub, simply use `git pull` to get all changes from the fork. If you are committing to the original repository itself, it's more likely to see those changes. Use `git pull` to pull changes from original repository.

### Creating Pull Requests

You finished your coding session and you are about to push some changes to the original repository. That's great! Here are some things you should watch out for.

**You should either...**

* Fix problems that are described in issues
* Add features that are either described in issues or features that you added and the features you thought would be useful

**Additionally, pull requests...**

* Should include what is the PR adding OR fixing
* Should link related issues if there are any
* Should provide media about what the PR is adding if there are any available
* Should maintain jsonsummarizer's quality

Reviewers may also suggest changes or ask you to complete anything else before your pull request can be accepted.

# Additional Notes

## Issue Labels

| Name | Description | Explanation |
| ----- | ----- | ----- |
| **bug** | Faulty behavior | --- |
| **feature request** | Suggestion of a feature | --- |
| **good first issue** | Good first issue for first time contributors | --- |
| **help wanted** | Extra attention required | --- |
| **invalid** | Bad issue or bad pull request | Most likely issue ending up being irrelevant |
| **question** | Incomplete information found in issue and needs more information | --- |
| **wontfix** | Issue mentioning about intended feature or something else | --- |

## Pull Request Labels

| Name | Description | Explanation |
| ----- | ----- | ----- |
| **feature** | Adds a feature | --- |
| **documentation** | Fixes a documentation or adds a new documentation | Most likely fixes about CONTRIBUTING.md or other documentation files |

repository: KaanGaming/jsonsummarizer

repo_name: KaanGaming/jsonsummarizer


text:
### Hi there 👋

 ![](https://cdn.jsdelivr.net/gh/zcxzzz/blog_pics/zzzimg/cat1.jpg)
 ----------------------------------------------------------
 🔭 I’m currently working on laptop

 🌱 I’m currently learning how to be true

 💬 Ask me about everything you want

 📫 How to reach me: [email](1368356684@qq.com)

 😄 I want to try everything once

 ⚡ Fun fact: nothing

[![996.icu](https://img.shields.io/badge/link-996.icu-red.svg)](https://996.icu)

[![LICENSE](https://img.shields.io/badge/license-Anti%20996-blue.svg)](https://github.com/996icu/996.ICU/blob/master/LICENSE)
[![Page Views Count](https://badges.toozhao.com/badges/01EH2GMKAVSQT1TTCGVCF4963B/green.svg)](https://badges.toozhao.com/badges/01EH2GMKAVSQT1TTCGVCF4963B/green.svg "Get your own page views count badge on badges.toozhao.com")

license: ICU

repository: zcxzzz/zcxzzz

repo_name: zcxzzz/zcxzzz


text:
# BullsEyeGame
## RW iOS Bootcamp Assigment 2.1

This version of the famous **BullsEyeGame** focus on avoiding the infamous *massive viewcontroller* by moving the game logic out of the view controller into a UI-independent model type called **BullsEyeGame**.

Although, Apple recommends to [use struts by default](https://developer.apple.com/documentation/swift/choosing_between_structures_and_classes), I decided to make BullsEyeGame a class since I care about is identity and I dont need copies of this object but prefered to pass it by reference, so all intances of it point to the same address in memory. Also, because I needed mutability.

Built it specifically for assigment 02 of the RW iOS Bootcamp at https://www.raywenderlich.com/10529048-ios-bootcamp.

![Image of BullsEye Main Screen](Screenshots/bullseye-screen1.png)


text:
# Changelog for v1-23-eks-8

This changelog highlights the changes for [v1-23-eks-8](https://github.com/aws/eks-distro/tree/v1-23-eks-8).

## Changes

### Patches
* Added patches to 1.23 and updated patch version ([1442](https://github.com/aws/eks-distro/pull/1442))

### Projects
* Added patches to 1.23 and updated patch version ([1442](https://github.com/aws/eks-distro/pull/1442))
* Bump node driver versions for all supported versions ([1425](https://github.com/aws/eks-distro/pull/1425))
* Bump livenessprobe project versions for all versions ([1424](https://github.com/aws/eks-distro/pull/1424))
* Bump aws-iam-auth project versions for all versions ([1423](https://github.com/aws/eks-distro/pull/1423))

### Base Image
Updated base image [1401](https://github.com/aws/eks-distro/pull/1401)


text:
---
id: api-binding-abstract
title: Abstract Binding
---

Typescript signature of Abstract Binding

```typescript
class AbstractBinding {
  static list(): Promise<PortInfo[]>

  constructor(opt: OpenOptions)

  /**
   * Opens a connection to the serial port referenced by the path. Promise resolves after the port
   * is opened, configured and ready for use.
   * @param {string} path the path or com port to open
   * @param {openOptions} options openOptions for the serialport
   * @returns {Promise} Resolves after the port is opened and configured.
   */
  open(path: string, options: OpenOptions): Promise<void>

  /**
   * Closes an open port
   */
  close(): Promise<void>

  /**
   * Request a number of bytes from the SerialPort. This function is similar to Node's
   * [`fs.read`](http://nodejs.org/api/fs.html#fs_fs_read_fd_buffer_offset_length_position_callback)
   * except it will always return at least one byte.

   * The in progress reads must error when the port is closed with an error object that has the
   * property `canceled` equal to `true`. Any other error will cause a disconnection.

   * @param {buffer} buffer Accepts a [`Buffer`](http://nodejs.org/api/buffer.html) object.
   * @param {integer} offset The offset in the buffer to start writing at.
   * @param {integer} length Specifies the maximum number of bytes to read.
   * @returns {Promise} Resolves with the number of bytes read after a read operation.
   */
  read(buffer: Buffer, offset: number, length: number): Promise<{ bytesRead: number, buffer: Buffer }>

  /**
   * Write bytes to the SerialPort. Only called when there is no pending write operation.

   * The in-progress writes must error when the port is closed, with an error object that has the
   * property `canceled` equal to `true`. Any other error will cause a disconnection.

   * @param {buffer} buffer - Accepts a [`Buffer`](http://nodejs.org/api/buffer.html) object.
   * @returns {Promise} Resolves after the data is passed to the operating system for writing.
   */
  write(buffer: Buffer): Promise<void>

  /**
   * Changes connection settings on an open port. Only `baudRate` is supported.
   * @returns {Promise} Resolves once the port's baud rate changes.
   */
  update(options: { baudRate: number }): Promise<void>

  /**
   * Set control flags on an open port.
   * @param {object=} options All options are operating system default when the port is opened.
   * Every flag is set on each call to the provided or default values. All options are always provided.
   * @param {Boolean} [options.brk=false] flag for brk
   * @param {Boolean} [options.cts=false] flag for cts
   * @param {Boolean} [options.dsr=false] flag for dsr
   * @param {Boolean} [options.dtr=true] flag for dtr
   * @param {Boolean} [options.rts=true] flag for rts
   * @returns {Promise} Resolves once the port's flags are set.
   */
  set(options): Promise<void>

  /**
   * Get the control flags (CTS, DSR, DCD) on the open port.
   * @returns {Promise} Resolves with the retrieved flags.
   */
  get(): Promise<Flags>

  /**
   * Get the OS reported baud rate for the open port. Used mostly for debugging custom baud rates.
   */
  getBaudRate(): Promise<number>

  /**
   * Flush (discard) data received but not read, and written but not transmitted.
   * @returns {Promise} Resolves once the flush operation finishes.
   */
  flush(): Promise<void>

  /**
   * Drain waits until all output data is transmitted to the serial port. An in-progress write
   * should be completed before this returns.
   * @returns {Promise} Resolves once the drain operation finishes.
   */
  drain(): Promise<void>
}
```

repository: serialport/website

gha_language: CSS

repo_name: serialport/website


text:
# OPSkins API for Node.js

This module provides a simple interface to the HTTP-based API for [OPSkins](https://opskins.com).

In order to use most methods, you will need an API key. You can get one from your [account page](https://opskins.com/account).

Like the Steam Web API, the OPSkins API is divided into "interfaces", each of which contains methods which apply to that
interface. This module hides this implementation detail from you, but for simplicity's sake, this documentation is
divided by interface.

# Setting Up

First, you will need to install this module. To do so, simply type on the command line:

    $ npm install @opskins/api

If you are developing an application which will depend on this module, you might want to save it in your `package.json`
file as a dependency:

    $ npm install --save @opskins/api

This package's root export is the `OPSkinsAPI` object, which you need to instantiate with your API key.

```js
var OPSkinsAPI = require('@opskins/api');
var opskins = new OPSkinsAPI('yourapikey');
```

Instantiation with an API key is optional, but if you don't provide one then you will only be able to use unauthenticated
API methods. Such methods are marked in this documentation.

# Error Handling

There are two types of errors which might be returned by the OPSkins API. **HTTP errors** indicate a serious problem.
For example, the HTTP status code `401` indicates that your API key is invalid, and `404` indicates that the requested
API method does not exist.

The other type of error is an **OPSkins error code**. These error codes [are documented here](https://opskins.com/kb/error-codes).
There is also an enum (implemented as an object) available as an `ErrorCode` property of the root export. [This can be
viewed here.](https://github.com/OPSkins/node-opskins/blob/master/resources/ErrorCode.json) To use the `ErrorCode`
enum, you will want to do something like this:

```js
var OPSkinsAPI = require('@opskins/api');
var ErrorCode = OPSkinsAPI.ErrorCode;

var code = getAnErrorCodeSomehow();
if (code == ErrorCode.ACCESS_DENIED) {
	// access denied
}
```

When you get an `Error` object from a request, it will contain an `httpCode` property, containing the HTTP status code
that the server returned to your request. If this is not `200`, then there will be no other properties defined (save
`message`). If it is `200`, then there will also be a `code` property containing the OPSkins ErrorCode that was returned.
The `Error` object's `message` will usually be a descriptive error message as well.

# Sale Status

An item in the OPSkins system is referred to as a *sale*. Each sale has a *status*, which indicates what state it is in.
Here are the available sale statuses, at time of writing:

- `AwaitingPickup` (1) - This sale has been created but the item has not been traded to an OPSkins storage account yet. There may or may not be an active trade offer for this sale.
- `OnSale` (2) - This item has been traded to the storage account, and it is currently up for sale.
- `AwaitingDelivery` (3) - This item has been purchased, but it has not yet been delivered to its buyer. The seller has not yet been paid for this sale. It is possible that the buyer may refund this sale, which will put the sale back into state `OnSale` (2).
- `Sold` (4) - This item has been sold and delivered. The seller has now been paid for this sale. *
- `AwaitingReturn` (5) - The seller has taken this item off of sale and requested that it be returned to their Steam inventory, but the return is not yet complete. There may or may not be an active trade offer for this sale to return it to its seller.
- `Returned` (6) - The seller has taken this item off of sale and it has been returned to their Steam inventory. *

\* = It is not possible (under normal circumstances) for an item to change from this state to another one.

These sale statuses are available as an enum accessible via the `SaleStatus` property of the `OPSkinsAPI` object.
[View this here.](https://github.com/OPSkins/node-opskins/blob/master/resources/SaleStatus.json) Example:

```js
var OPSkinsAPI = require('@opskins/api');
var SaleStatus = OPSkinsAPI.SaleStatus;

var status = getSaleStatusSomehow();

if (status == SaleStatus.OnSale) {
	// this item is currently on sale
}
```

# Prices

All prices accepted as input and provided as output are in USD cents. This means that a price of $5.42 is represented
as the integer 542.

# HTTPS Agent

As of v1.3.0, by default the module will create a single `keepAlive` HTTPS agent and use it for all requests. This means
reduced latency for requests after the first one within a relatively small time period.

If you need to, you can specify your own Agent by overriding the `getAgent` method. For example:

```js
var OPSkins = require('@opskins/api');
var op = new OPSkins();

op.getAgent = function() {
	return new SomeCustomAgent();
};

op.getSteamID(function(err, steamID) {
	if (err) {
	    console.log(err);
    } else {
		console.log("My SteamID is " + steamID);
    }
});
```

All requests are HTTPS, so your agent should be based on `require('https').Agent`.

# Methods

## IInventory

### getInventory(callback)
- `callback` - A function to be called when the request completes.
    - `err` - An `Error` object on failure, or `null` on success
    - `data` - An object containing these properties:
        - `items` - An array containing one object for each item in your OPSkins inventory. Each object has these properties:
            - `id` - The OPSkins ID of the item. If you choose to relist this item, this will be its sale ID.
            - `name` - The Steam name of the item
            - `inspect` - If this item is inspectable, this is its inspect link. May be a steam:// link for CS:GO/TF2, or possibly an HTTP(S) link (e.g. Steam profile backgrounds)
            - `type` - The Steam "type" of this item (displayed next to its game icon in the Steam inventory)
            - `appid` - The Steam AppID of the game which owns this item
            - `contextid` - The Steam context ID which contains this item
            - `assetid` - The Steam asset ID of this item (unique within a given app + context combo)
            - `classid` - The Steam class ID of this item
            - `instanceid` - The Steam instance ID of this item
            - `bot_id` - The internal ID of the bot which is holding this item
            - `bot_id64` - The 64-bit SteamID of the bot which is holding this item (as a string)
            - `added_time` - The Unix timestamp for when this item was added to your OPSkins inventory
            - `offer_id` - If there is an outstanding withdrawal trade offer for this item, this is its ID. If not, this is null. If you have requested a trade offer that couldn't be sent immediately but is queued to be sent in the future, this is 0.
            - `offer_declined` - If there was previously a withdrawal trade offer for this item but it was declined, this is true.
            - `offer_untradable` - If we previously attempted to send a withdrawal trade offer for this item but we were unable to due to a bad trade URL or another trading restriction (e.g. Steam Guard), this is true.
            - `requires_support` - If this item has a problem and requires support intervention before it can be withdrawn or relisted, this is true.
            - `can_repair` - If this item requires support but you can attempt to self-repair it, this is true. If true, you can use ISupport/RepairItem to try to repair it.

**v1.2.0 or later is required to use this method**

Retrieves the contents of your [OPSkins inventory](https://opskins.com/?loc=inventory).

### withdrawInventoryItems(items, callback)
- `items` - Either a single OPSkins item ID, or an array of OPSkins item IDs.
- `callback` - A function to be called when the request completes.
    - `err` - An `Error` object on failure, or `null` on success. On failure, it may have `data.offers` defined, which is identical to the `offers` argument.
    - `offers` - When all trade offers succeed, this is an array of objects. When one or more offers fail, this is available as `data.offers` on `err`. Each object has this structure:
        - `bot_id` - The internal ID of the bot which sent (or tried to send) the trade offer
        - `tradeoffer_id` - If we were able to successfully send a trade offer, this is its ID, as a string. If error, this is null.
        - `tradeoffer_error` - If we were not able to send a trade offer, this is a string containing an error message. If no error, this is null.
        - `items` - An array of OPSkins item IDs in this trade offer

**v1.2.0 or later is required to use this method**

Requests OPSkins bots to send you trade offers to withdraw one or more items from your OPSkins inventory to your Steam
inventory.

## IPricing

### getPriceList(appid, callback)
- `appid` - The [Steam Application ID](https://developer.valvesoftware.com/wiki/Steam_Application_IDs) of the game for which you want prices. Use `753` for Steam Community items.
- `callback` - A function to be called when the request completes.
    - `err` - An `Error` object on failure, or `null` on success
    - `prices` - An object of the structure shown below.

**This method does not require an API key.**

Downloads a list of prices for the past 60 days for an entire app. Prices are provided as the average sale price for
an item in a particular day. The returned data is updated once every 24 hours. The `prices` object structure resembles
the following:

```json
{
    "AK-47 | Black Laminate (Factory New)": {
        "2016-08-10": {"price": 10500},
        "2016-08-14": {"price": 10810},
        "2016-08-15": {"price": 11000},
        "2016-08-16": {"price": 10667},
        ... and so on
    },
    "AK-47 | Black Laminate (Field-Tested)": {
        "2016-08-10": {"price": 494},
        "2016-08-11": {"price": 489},
        "2016-08-12": {"price": 506},
        ... and so on
    },
    ... and so on
}
```

### getLowestPrices(appid, callback)
- `appid` - The [Steam Application ID](https://developer.valvesoftware.com/wiki/Steam_Application_IDs) of the game for which you want prices. Use `753` for Steam Community items.
- `callback` - A function to be called when the request completes.
    - `err` - An `Error` object on failure, or `null` on success
    - `prices` - An object of the structure shown below.

**This method does not require an API key.**

Downloads the current lowest list price and quantity on sale for each item in an app. Note that these two figures are
in no way related to one another. `quantity` is how many of that item are currently on sale, and `price` is the lowest
price at which the item is available. The returned data is updated at most once every 30 minutes. The `prices` object
structure resembles the following:

```json
{
    "AK-47 | Black Laminate (Battle-Scarred)": {
        "price": 590,
        "quantity": 13
    },
    "AK-47 | Black Laminate (Factory New)": {
        "price": 9899,
        "quantity": 12
    },
    "AK-47 | Black Laminate (Field-Tested)": {
        "price": 584,
        "quantity": 51
    },
    "AK-47 | Black Laminate (Minimal Wear)": {
        "price": 622,
        "quantity": 83
    },
    "AK-47 | Black Laminate (Well-Worn)": {
        "price": 598,
        "quantity": 9
    },
    ... and so on
}
```

### getSuggestedPrices(appid, items, callback)
- `appid` - The [Steam Application ID](https://developer.valvesoftware.com/wiki/Steam_Application_IDs) of the game for which you want prices. Use `753` for Steam Community items.
- `items` - An array of market_hash_names for the items for which you want prices. You cannot more than the [listing limit](#getlistinglimitcallback) at once.
- `callback` - A function to be called when the request completes.
    - `err` - An `Error` object on failure, or `null` on success
    - `prices` - An object whose keys are market_hash_name strings, and values are objects containing properties `opskins_price` (OPSkins 7-day suggested price), `market_price` (Steam Analyst/Community Market suggested price), and `opskins_lowest_price` (the current lowest list price on OPSkins). Any or all of these may be `null`.

Gets suggested prices for one or more items. Note that if you're interested in many OPSkins lowest price values,
then you may use [`getLowestPrices`](#getlowestpricesappid-callback).

## ISales

### getSales([req, ]callback)
- `req` - **Required.** An object containing request filters. Available filters:
    - `type` - **Required.** Provide a [`SaleStatus`](#sale-status) value here to only return sales in that status. Default (omitted) is to get all statuses.
    - `page` - The number of the page you would like. Currently, there are 10,000 sales returned per page. Default is page 1.
- `callback` - A function to be called when the request completes
	- `err` - An `Error` object on failure, or `null` on success
	- `totalPages` - A number containing the total number of pages that exist in this listing
	- `sales` - An array of objects, where each object represents one sale on your account. Each object has these properties:
		- `id` - The item's OPSkins sale ID
		- `price` - The item's list price, in USD cents
		- `commission` - If the item has sold, this is how much OPSkins took in commission
		- `tax` - If the item has sold, this is how much sales tax was taken from your cut
		- `classid` - The item's Steam class ID
		- `instanceid` - The item's Steam instance ID
		- `appid` - The Steam AppID of the game to which this item belongs
		- `contextid` - The Steam context ID to which this item belongs
		- `assetid` - The Steam asset ID of this item, if it is awaiting pickup or is in our system
		- `name` - The item's name
		- `bot` - The internal OPSkins ID of the bot which is holding this item
		- `bot_id64` - The 64-bit SteamID of the bot which is holding this item
		- `offerid` - If there is an active trade offer for this item, this is its ID. May also be a negative value representing a [trade offer status code](https://opskins.com/kb/error-codes)
		- `state` - The item's current [state](#sale-status)
		- `escrow_end_date` - If the item is currently in a trade hold or a temporary trade lock (e.g. H1Z1), this is a Unix timestamp representing when the hold period will expire
		- `list_time` - A Unix timestamp representing when the item was listed.
			- If the item is awaiting pickup, this is the time when you sent the request to our servers to list the item
			- If the item is on sale, this is the time when either our bot confirmed the Steam trade, or the time when you re-listed it from your OPSkins inventory, if applicable
		- `bump_time` - A Unix timestamp representing when the item was last bumped. Will be at least the same as `list_time` if never bumped.
		- `last_updated` - A Unix timestamp representing when the item last had its state or price changed. May be 0 for older items.
		- `security_token` - The security token sent in the trade offer from our bot to pick up this item.
		- `wear` - If this item has a wear value and it's known, this is it.
		- `txid` - If the item has been sold, this is the transaction ID of the wallet transaction in which you were paid.
		- `trade_locked` - A boolean representing whether or not the item is in a temporary (H1Z1) trade lock.
			- If `escrow_end_date` is set and is in the future and this is `false`, then the item is in a Steam trade hold
			- If `escrow_end_date` is set and is in the future and this is `true`, then the item is in a Daybreak trade lock
		- `repair_attempted` - If the item requires support intervention and you have already attempted to repair it and the attempt failed, then this is `true`. If this is `true` then you will need to contact support to have this item fixed.
		- `addons` - An array of strings for each addon which is applied to this item.

Gets a listing of items you listed on your account.

### getActiveTradeOffers(callback)
- `callback` - A function to be called when the request completes
    - `err` - An `Error` object on failure, or `null` on success
    - `offers` - An object whose keys are trade offer IDs. Each key contains an object with this structure:
        - `saleids` - An array of sale IDs for the items contained in this offer
        - `bot_id` - The internal OPSkins ID of the bot which sent this trade
        - `bot_id64` - The 64-bit SteamID of the bot which sent this trade, as a string
        - `type` - A string which is `pickup` if this offer is picking up new listings, `return` if this offer is returning listings to you, or `withdrawal` if this offer is delivering items from your OPSkins inventory

**v1.1.0 or later is required to use this method**

Gets a list of outstanding trade offers which have been sent to you. Note that there may be a delay between when you
accept offers (particularly offers which are delivering items to you) and when they disappear from this list.

### editPrice(saleID, price, callback)
- `saleID` - The numeric ID of the sale you wish to edit.
- `price` - The desired new price for this sale, in USD cents.
- `callback` - A function to be called when the request completes
    - `err` - An `Error` object on failure, or `null` on success
    - `relisted` - `true` if this item was in your OPSkins inventory and has now been listed for sale, or `false` if this item was already listed for sale

Edits the price of one of your sales. If the item is in your OPSkins inventory, then calling this will list it for sale
at the provided price.

### editPrices(sales, callback)
- `sales` - An object whose keys are sale IDs and values are new prices, in USD cents. 500 items max.
- `callback` - A function to be called when the request completes
    - `err` - An `Error` object on failure, or `null` on success

**v1.2.0 or later is required to use this method**

Edit the prices for multiple items in one go. This method queues price updates server-side, and the callback will be
fired before any prices have actually been updated. The server will process your request and you will not be notified
when it completes in any way, unless you request your sales list and check the prices yourself.

This will fail if you attempt to queue a price update for an item which already has a queued price update. Price update
errors will not be reported and will be silently dropped in the background. For example, requests to edit the prices of
items you do not own or which do not exist will be accepted, but will not actually be processed.

### getListingLimit(callback)
- `callback` - A function to be called when the request completes
    - `err` - An `Error` object on failure, or `null` on success
    - `liimt` - The current limit of how many items you can list at one time via [`listItems`](#listitemsitems-callback)

Gets the current limit of how many items you can list at one time via [`listItems`](#listitemsitems-callback).

### listItems(items, callback)
- `items` - An array of objects, one object for each item you wish to list. Each object should contain these properties:
    - `appid` - The [Steam Application ID](https://developer.valvesoftware.com/wiki/Steam_Application_IDs) of the game which owns this item
    - `contextid` - The Steam context ID which owns this item. For all current Valve games, this is 2. For H1Z1, this is 1. For Steam Community, this is 6.
    - `assetid` - The Steam asset ID (or just the item's ID) of this item.
    - `price` - The price at which you wish to sell this item, in USD cents.
    - `addons` - Optional. An array of strings for addons you wish to apply to this item. Available addons:
        - `featured` - Feature this item. Costs $3.00 if you don't have any featured credits remaining. Uses a credit if you do.
        - `screenshots` - Inspectable CS:GO items only. Takes screenshots of this item and displays them (Instant Field Inspection). Costs 2% of list price, minimum $0.50. If you also feature this item, then the total cost of both addons is capped at $4.50.
- `callback` - A function to be called when the request completes
    - `err` - An `Error` object on failure, or `null` on success
    - `result` - An object containing these properties:
        - `tradeoffer_id` - If a trade offer was successfully sent, this is its ID as a string. If an offer could not be sent, this is `null`.
        - `tradeoffer_error` - If a trade offer could not be sent, this is an error message explaining why, as a string. If an offer was sent, this is `null`.
        - `bot_id` - The internal OPSkins ID of the bot which sent this trade. This is the number in the bot's Steam name.
        - `bot_id64` - The 64-bit SteamID of the bot which sent this trade, as a string.
        - `security_token` - The 6-character security token which will be included in the trade offer message.
        - `sales` - An array of objects describing the sales that were created. Each object has these properties:
            - `saleid` - The ID of the sale which was created for this item
            - `appid` - The Steam AppID for this item
            - `contextid` - The Steam context ID in which this item resides in your inventory
            - `assetid` - The Steam asset ID for this item in your inventory
            - `market_name` - The name of this item
            - `price` - The list price of this item
            - `addons` - An array (possibly empty) containing strings for each addon this item has

Lists one or more and sends a trade offer. This will fail if any item has price restrictions which are not met, if any
item cannot be sold on OPSkins, if any item does not exist, or if there is already an active trade offer out to pick up
any of these items. There is a limit on how many items you can list in one request; this can be accessed via
[`getListingLimit`](#getlistinglimitcallback).

If there are already sales created for any of these items but they do not currently have active trade offers, then those
sales will be deleted and new ones will be created. This means that if this request fails to send a trade offer, you may
safely re-request it for the same items.

### bumpItems(saleids, callback)
- `saleids` - An array of sale IDs
- `callback` - A function to be called when the request completes
    - `err` - An `Error` object on failure, or `null` on success
    - `balance` - Your account's new balance, in USD cents
    - `results` - An object whose keys are sale IDs, and values are objects with this structure:
        - `status` - An `ErrorCode` indicating the result of bumping this item (1 = OK, indicates success)
        - `message` - An error message ("OK" on success)

**v1.4.0 or later is required to use this method**

Bumps one or more items. Bumps cost $0.50, and this will be charged to your account balance (unless you have free bump
credits on your account, in which case those will be consumed first).

### returnItems(saleids, callback)
- `saleids` - An array of sale IDs
- `callback` - A function to be called when the request completes
    - `err` - An `Error` object on failure, or `null` on success
    - `offers` - An array of objects, where each object in this array represents one trade offer that we sent (or tried to send)
        - `bot_id` - The internal ID of the bot that sent (or tried to send) this offer
        - `items` - An array of sale IDs that are in this offer
        - `tradeoffer_id` - The ID of the offer we sent as a string, on success; `null` on failure
        - `tradeoffer_error` - An error message explaining why the offer couldn't be sent, on failure; `null` on success

**v1.3.0 or later is required to use this method**

Requests the return of one or more items you currently have listed for sale on your account. These items must currently
be on sale (state 2) or awaiting return (state 5), and must not already have a trade offer out.

### search(params, callback)
- `params` - An object containing search parameters. Please [see here](https://opskins.com/kb/api-isales#method-search-v1) for documentation regarding this.
- `callback` - A function to be called when the request completes
    - `err` - An `Error` object on failure, or `null` on success

**v1.2.0 or later is required to use this method**

Search active OPSkins listings for particular items. This endpoint is relatively heavily rate-limited. Current limits
are documented on the [OPSkins knowledgebase](https://opskins.com/kb/api-isales#method-search-v1).

### buyItems(saleids, total, callback)
- `saleids` - An array of OPSkins sale IDs for the items you want to buy
- `total` - The total cost of the items you wish to buy, in USD cents. If this is not correct, the request will fail.
- `callback` - A function to be called when the request completes
    - `err` - An `Error` object on failure, or `null` on success
    - `items` - An array of objects, each of which corresponds to an item you purchased. Each object has these properties:
        - `saleid` - The OPSkins sale ID of the item. This will be one of the IDs you passed in.
        - `new_itemid` - The new OPSkins ID of this item in your OPSkins inventory. This is the ID you need to pass to `withdrawInventoryItems` to withdraw the item to your Steam inventory.
        - `name` - The name of the item
        - `bot_id` - The internal OPSkins ID of the bot which is holding this item
    - `balance` - Your new OPSkins account balance after this purchase, in USD cents

**v1.2.0 or later is required to use this method**

Purchase one or more items and deliver them to your OPSkins inventory. Once purchased, the item(s) can be delivered to
your Steam inventory using `withdrawInventoryItems`. To prevent bot sniping, this endpoint will only purchase listings
which have been publicly visible for at least ten minutes, and are not currently limited to Buyers Club members.

## ISupport

### repairItem(saleID, callback)
- `saleID` - The ID of the sale which you want to repair
- `callback` - A function to be called when the request completes
    - `err` - An `Error` object on failure, or `null` on success
    - `repaired` - `true` if this item was successfully repaired, or `false` if it could not be repaired automatically
    - `type` - A string explaining this item's relationship to you (`sale` if you're selling it, or `item` if it's in your OPSkins inventory)
    - `bot` - The internal ID of the storage account which is holding this item
    - `repairedSaleIds` - An array of sale IDs which were successfully repaired as a result of this request (see below)

Attempts to automatically repair an item which is in a bad state. This will also attempt to repair all other such items
on the same storage account. Sale IDs of all items which were successfully repaired are returned, even those which do
not belong to you. If this fails (`repaired` is `false`), then you will need to contact support in order to have this
item repaired.

## ITest

### getSteamID(callback)
- `callback` - A function to be called when the request completes
    - `err` - An `Error` object on failure, or `null` on success
    - `steamID` - Your 64-bit SteamID, as a string
    - `time` - A `Date` object containing the current server time

Gets the SteamID of the account which owns this API key.

## IUser

### getBalance(callback)
- `callback` - A function to be called when the request completes
    - `err` - An `Error` object on failure, or `null` on success
    - `balance` - Your account's current balance, in USD cents

Gets your OPSkins account's current balance.

### updateTradeURL(url, callback)
- `url` - Your new Trade URL
- `callback` - A function to be called when the request completes
    - `err` - An `Error` object on failure, or `null` on success

**v1.4.1 or later is required to use this method**

Update the Steam Trade URL which is linked with your account. It must belong to the same Steam account as is linked
to your OPSkins account.

## IStatus

### getBotList(callback)
- `callback` - A function to be called when the request completes
    - `err` - An `Error` object on failure, or `null` on success
    - `bots` - An object with numeric keys corresponding to a specific bots internal ID, and Steam 64 ID.

**v1.3.0 or later is required to use this method**

Retrieves a listing of all active OPSkins bots, namely their internal IDs (the number in their Steam name), their SteamIDs, and their online status.

You may wish to note that some internal IDs have either been skipped or retired, so this list is not exactly sequential.

# Events

### queryLimit
- `queriesRemaining` - How many queries you have left today.

Emitted when a request completes and includes an `X-Queries-Remaining` header, indicating how many queries you have
left available for your API key. Query limits reset daily at approximately midnight Eastern Time.

### debug
- `message` - A string containing the debug message.