semvec/pypi-packages huggingface dataset:
rambo-py 1.0.5
collection of handy methods for terminal applications

# Rambo
#### A few helpful tools for creating terminal applications

Rambo is a collection of methods to help with mapping terminal program arguments to python actions / functions

Getting started
`pip install rambo-py`

creating a project
`rambo init project`

This will create a directory called `actions` as well as a file called `rambo.yml` which functions both at the terminal
config file, and mapper configuration

Example `rambo.yml`

```
commands:
  action:
    help: "available options for the rambo action argument"
    choices:
      - init
      - delete
  object:
    help: "available options for the rambo object argument"
    choices:
      - project
      - file
```

Rambo commands follow the pattern of `action -> object` where the action argument will be performed on the 
provided object. in the above example the following combinations are valid
```
init project
init file
delete project
delete file
```

these argument combinations can be mapped to `actions` which are python functions. Rambo will map these valid combinations
to functions of the same name.


## Rambo Decorators

Rambo provides handy decorator methods to access the passed in cmd arguments, rambo.yml config file
and function key value


Provides the ```rambo.yml``` config file as a dictionary to the decorated function.
```
@provide_config(path = this is optional)
def my_cool_func(confg):
	# do things with config here
```

Provides the namespace object to the decorated function with the commands available in ````rambo.yml````
```
@provide_cmd_args
def another_cool_func(cmd_args):
	# do some things with the arguments in the argparser
```
zeropy 0.4.0
zerolevel blockchain's api bind.

# zeropy

[![PyPI version](https://badge.fury.io/py/zeropy.svg)](https://badge.fury.io/py/zeroPy)
[![Python 3.6](https://img.shields.io/badge/python-3.6-blue.svg)](https://www.python.org/downloads/release/python-360/)
[![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)

Blockchain's api bind, python3.5+


# Requirements 
 - racrypt
 - crcPy(now part, but it will be changed)

# Tests

Default tests: 
```sh
 sh tests.sh
```
Testing Api: 
```sh 
cd tests
vim node.ini
change ip, port
python3 -m unittest test_client.py
```


# Start
```python
import zeropy

client = zeropy.apiClient()
client.connect('127.0.0.1', 5000)

tmp_key = b'any 64 symbols'
#Blockchain should know with whom he works
client.send_info(tmp_key)

counters = client.get_counters()
print('blocks\n', counters.blocks, 'transactions\n', counters.transactions,
'binary data \n',counters)

```
zerocrypt 0.2
Node' crypto library bind to python

# racrypt
small package, which allow to crypto lib on C in Python

[![PyPI version](https://badge.fury.io/py/racrypt.svg)](https://badge.fury.io/py/racrypt)
[![Python 3.6](https://img.shields.io/badge/python-3.6-blue.svg)](https://www.python.org/downloads/release/python-360/)
[![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)

# Requirements
  - python3 
  - pip

# Tests

```sh
    cd racrypt
    python3 tests/test_crypto.py
```
openapi-resolver 0.0.7rc2
Resolve and bundle openapi v3 specs.
Keywords: openapi,rest,swagger

# OpenAPI Resolver

[![CircleCI](https://circleci.com/gh/ioggstream/openapi-resolver.svg?style=svg)](https://circleci.com/gh/ioggstream/openapi-resolver)
[![CodeCov](https://codecov.io/gh/ioggstream/openapi-resolver/branch/master/graph/badge.svg)](https://codecov.io/gh/ioggstream/openapi-resolver)

This module recursively parses openapi specs resolving references.

## Test

Tests run locally via 

        tox

Or via [circleci-local](https://circleci.com/docs/2.0/local-cli/)

        circleci build 


## Usage

The module has an embedded script that can be run via

        $ python -m openapi_resolver --help

        usage: __main__.py [-h] src_file [dst_file]

        Recursively resolves and bundles OpenAPI v3 files.

        positional arguments:
          src_file    An OpenAPI v3 yaml file.
          dst_file    Destination file, default is stdout.

        optional arguments:
          -h, --help  show this help message and exit

To create an openapi bundle from a spec file just run

        $ python -m openapi_resolver sample.yaml

You can use this module to normalize two specs before diffing, eg:

        $ python -m openapi_resolver one.yaml normal-one.yaml
        $ python -m openapi_resolver two.yaml normal-two.yaml
        $ diff normal-one.yaml normal-two.yaml

## Use with docker

Build the image with:

```
$ docker build --tag openapi-resolver . 
```

then run docker mapping the openapi.yaml directory
to the `/code` volume.

```
docker run -it --rm -v $(dirname path-to-openapi.yaml):/code \
    openapi-resolver /code/openapi.yaml /code/bundle.yaml
```
zdb-analysis 0.1.7
Pandas + Z inv analysis

# Z invisible DB analysis

Setup with

```
source setup.sh
```

To run the analysis use `zdb_analyse.py`:

```
usage: zdb_analyse.py [-h] [-m MODE] [-j NCORES] [--sge-opts SGE_OPTS]
                      [-n NFILES] [-o OUTPUT]
                      config

positional arguments:
  config                Path to yaml file

optional arguments:
  -h, --help            show this help message and exit
  -m MODE, --mode MODE  Parallelisation: 'multiprocessing', 'sge', 'htcondor'
  -j NCORES, --ncores NCORES
                        Number of cores for 'multiprocessing' jobs
  --sge-opts SGE_OPTS   Options to pass onto qsub
  -n NFILES, --nfiles NFILES
                        Number of files to process. -1 = all
  -o OUTPUT, --output OUTPUT
                        Output file

```
py-set 0.1.3
C extension module actualizing red-black search tree for Python3

# Pyset
[![Build Status](https://travis-ci.com/DobroSun/py_set.svg?branch=master)](https://travis-ci.com/DobroSun/py_set)

PySet is wrapper of C++ standart red-black tree realization(std::set)

Install
-----
```
pip3 install py_set
```

Usage
-----
```
>>>from py_set import pyset
>>>rbt = pyset()
>>>
>>>rbt.size()
0
>>>rbt.is_empty()
1
>>>rbt.add("Hello world")
>>>rbt.add(20.15)
>>>rbt.add(6)
>>>
>>>rbt.to_list()
[20.15, 'Hello world', 6]
>>>rbt.remove(6)
>>>rbt.size()
2
>>>del rbt
>>>
>>>rbt = pyset(5, 10, 1)
>>>rbt.to_list()
[5, 6, 7, 8, 9]
>>>
>>>rbt.from_list([1, 2, 3, 4], (10, 11, 12))
>>>rbt.to_list()
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
>>>rbt.find(4)
1
>>>rbt.find("Hello")
0
>>>rbt.clear()
>>>rbt.to_list()
[]
>>>rbt.remove("Nothing")
>>>rbt.pop("Error")
IndexError: Pyset is empty

>>>del rbt
```

Comparing with python structures:
-----
```
*** Adding elements ***
List time on adding 10^6 items: 142.03ms
Set time on adding 10^6 items: 168.01ms
Pyset time on adding 10^6 items: 457.31ms

*** Searching for elements ***
Set time on searching in 10^6 items: 178.88ms
Pyset time on searching in 10^6 items: 773.05ms

*** Deleting elements ***
Set time on deleting 10^6 items: 154.70ms
Pyset time on deleting 10^6 items: 348.18ms
```