semvec/pypi-packages huggingface dataset:
nestingnote 0.0.11
Terminal note-taking application
Requires Python: >3.6

### Installation
- Windows
  1. [Download](https://github.com/woodsonmiles/nestingnote/raw/master/dist/nestingnote.exe)
- Linux (varies per distro)
  1. Install Python3<br>
    `sudo apt install python3`
  1. Install pip for Python3
  1. install nestingnote<br>
    `python3 -m pip install nestingnote`
  1. create alias (for convenience)<br>
    ```
    echo "alias nestingnote='python3 -m nestingnote'" >> ~/.bash_aliases
    source ~/.bash_aliasees
    ```    
### Execution
```python3 -m nestingnote \path\to\my\notes```
### Controls
Most controls are intuitive, e.g., all printable keys insert that character, arrow keys, home, end, page up, and page down all move the cursor appropriately. However, there are a few special controls introduced by nestingnote:
- **Tab**: at the beginning of a line will indent the line, starting an inner nested list. Within the line, tab will split the line into fields similar to columns in a matrix.
- **Ctrl+k**: toggles whether the current item in the nested list is collapsed, meaning that all items nested beneath it are hidden.
- **Ctrl+w**: save the edits
internetofutils 0.1.0
A utility package with various things in it.
Requires Python: >=3.6

# Internet of Utilities

Internet of Utilities (which will be shortented to IoU from now on) is a tool for a variety of utilities, including
Roundbottom (or `Rndb`), a WIP flask extension and IDL, a very simple tool similar to `wget`.

## Using Roundbottom
To make a simple roundbottom program, run the following code:
```
rndb = Rndb()
Rndb().run_app(torun=Rndb.helloworld)

# or, for all the arguments

rndb = Rndb()

rndb.run_app(host="localhost", port=8000, route="/")

```

compared to the longer
```
from flask import Flask

app = Flask(__name__)



@app.route('/')

def hello_world():

    return 'Hello, World!'
	
```

The `Rndb.helloworld` is an example program ran if no function to run was given, and is defined as:
```
def helloworld():

    return 'Hello, World!'
	
```

If you want to use a custom function that *you* defined, use the following:
```

def test123():

    return 'Hello, other world!'
	

rndb = Rndb()

rndb.run_app(host="localhost", port=8000, torun=test123, route="/")

```

Let's step through the program.

```
rndb = Rndb()
rndb.run_app(host="localhost", port=8000, torun=Rndb.helloworld, route="/")

```


`rndb = Rndb()` instantiates Roundbottom, for the use of `run_app`

`rndb.run_app` runs an application with the following arguments:

`host="localhost"` is used to define the host. For a local webserver, use `localhost`. For a repl-like website, (e.g. [repl.it](https://repl.it/))
use something like `0.0.0.0`

`port=8000` defines the port. You can have 8080, 8000, 6000, etc.

`torun=Rndb.helloworld` defines which function to run. In this case, it runs the example program `Rndb.helloworld`, which just
does `return "Hello, World"`.

`route="/"` simply puts @app.route(route) before the function you provided with `torun`.

## Using IDL

IDL is a simple function with one argument using one library; `urllib`.
The function is like `idl(url)`.
Replace `url` with a URL, and you will get the text content for the URL's page.
distributed-counter 0.0.3
distributed increment/decrement counter leveraging dynamodb

[![Build Status](https://travis-ci.org/wontonst/distributed-counter-py.svg?branch=initial)](https://travis-ci.org/wontonst/distributed-counter-py)
[![Documentation Status](https://readthedocs.org/projects/distributed-counter-py/badge/?version=latest)](http://distributed-counter-py.readthedocs.io/en/latest/?badge=latest)

# Overview

`distributed_counter` is a python package for maintaining counters across clusters of computers.
It leverages [AWS DynamoDB](https://aws.amazon.com/dynamodb) for storage and atomicity of the counter.

# Installation

`distributed_counter` is compatible with `python2` and `python3`.
Simply use `pip` to install.

```
pip install distributed_counter
```

You'll also want to set up your [aws configurations](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html).

# Usage

The interface for `distributed_counter` is very simple.
Everything is done through the `DistributedCounter` class.
To instantiate:

```
from distributed_counter import DistributedCounter

counter = DistributedCounter('my_dynamo_table_name')
```

You can pass anything in `kwargs` to DistributedCounter and they will be propagated to the boto3 Session, e.g.

```
counter = DistributedCounter('mytable', region_name='us-west-1', aws_access_key_id='somekey',
                             aws_secret_access_key='somesecret')
```

There are also special parameters `config` and `endpoint_url` which get passed to the
DynamoDB ServiceResource. 

## Table Creation

The dynamodb table has one HASH key called `key`. You can create the table yourself, or you can use `create_table`.

```
counter.create_table()
```

`distributed_counter` is smart enough to wait for the table to finish creation on your next call to the table.

## Getting/Setting

Next, you can set a key using `put` and get it with `get`:

```
counter.put('mykey', 0)
counter.get('mykey')
0
```

## Increment/Decrementing

Finally, you can `increment`/`decrement`.

```
counter.increment('mykey', 10)
10
counter.increment('mykey', 5)
15
counter.decrement('mykey', 14)
1
```

Note that the returned value is the new value.

You can use `increment`/`decrement` with a default.
This is the same as doing a `put` then an `increment`/`decrement`.

```
counter.increment('nonexistantkey', 0, 0)
0
counter.increment('someotherkey', 0, 10)
10
counter.increment('yetanotherkey', 1, 10)
11
```

## Example Use

Let's say we want to run a function every 100 calls to an API.
In your API, you can put:

```
if not counter.increment('mykey', 1) % 100:
    run_function()
    counter.decrement('mykey', 100)
```

This guarantees that no matter how many servers you have, every 100 calls to your API will run your function.

The modulo is used instead of `==` because there is a corner case where hypothetically you could increment to 200 before
the decrement finishes.
compETAG 0.0.3
The tool provides methods to calculate ETags for Objects on AWS S3, and also md5s, on local objects. It also allows to check the integrity of files, both locally and on AWS S3.
Requires Python: >=3.6

# Compute ETags and MD5s
The tool provides methods to calculate ETags for Objects on AWS S3, and also md5s, on local objects. It also allows comparing ETags or md5s to check the integrity of files, both locally and on AWS S3, given a list of files and their calculated ETags.
## Installation
```pip install compETAG```
## Usage
The following example will compute ETags for local files with the same chunk size used by AWS on S3:

```compute_etags -i <file1> <file2> .... -m etag -s 8MB -o out.txt```

Chunk size can be set to any desired value:

```compute_etags -i <file1> <file2> .... -m etag -s 1GB```

With mode fixed at `md5`, the resulting calculation will be md5 hashes:

```compute_etags -i <file1> <file2> .... -m md5```

To retrieve ETags from objects on AWS S3, setting mode to `s3uri` will redirect the tool to AWS S3, provided a bucket/s, key/s, and pattern/s (optional):

```compute_etags -m s3uri -b <bucket1> <bucket2> .. -k <key1> <key2> .. -p <pattern1> <pattern2> .. ```

To check the integrity of local files or AWS S3 objects, the following will calculate or retrieve ETags or md5s on the list of files provided in a text file, and compare the results to the provided hashings. Each row in the input text file represents a pair of ETag/md5 hash and a file name. 

* Checking ETags of local files:

    ```compute_etags -c <input.txt> -m etags```

* Checking md5s of local files:

    ```compute_etags -c <input.txt> -m md5```

* Checking ETags of AWS S3 objects:

    ```compute_etags -c <input.txt> -m s3uri -b <bucket1> <bucket2> .. -k <key1> <key2> .. ```