semvec/pypi-packages huggingface dataset:
py-umi 0.2.4
Python package to access Universa UMI API from python.
Keywords: Universa,UMI

# py-umi

[![Build status](https://travis-ci.org/vkovrigin/py-umi.svg?master)](https://travis-ci.org/vkovrigin/py-umi)
[![PyPI Downloads](https://img.shields.io/pypi/dm/py-umi.svg)](https://pypi.org/project/py-umi/)
[![Latest PyPI version](https://img.shields.io/pypi/v/py-umi.svg)](https://pypi.org/project/py-umi/)
[![License](https://img.shields.io/pypi/l/py-umi.svg)](https://pypi.org/project/py-umi/)

This is an under-construction official Python package from
[Universa](https://universablockchain.com)
to facilitate access to the Java library using Universa's UMI protocol.

## Installation

```bash
pip install py-umi
```

## Usage

### Prerequisites

You need to have [UMI](https://kb.universablockchain.com/umi_protocol/98) installed somewhere on your system.
To run, UMI requires JVM v1.8.* (or newer) to be installed, too.

UMI can be used in one of three modes:

* `pipe` – the UMI instance is dynamically executed in a subprocess, and a pipe is used for communication.
* `tcp` – connect to an already running UMI instance via TCP socket.
* `unix` – connect to an already running UMI instance via Unix socket.

 By default it expects an `umi` binary to be installed an reachable via the shell `$PATH`, and will invoke it automatically in `pipe` mode.
 Use `umi.transport.setupUMI` method if you need to switch the connection method to some other.

### Example

```python
#!/usr/bin/env python3
from umi.transport import transport
from umi.types import PrivateKey, Contract, RevokePermission

if __name__ == '__main__':
    # The next line is not necessary if umi is reachable via the $PATH
    # transport.setupUMI('pipe', '/usr/local/bin/umi')

    # To connect to an already running UMI instance you may use one of this modes:
    # transport.setupUMI('tcp', host='127.0.0.1', port=12345)  # IPv6 is also ok
    # transport.setupUMI('unix', path='/path-to-the-socket')

    print(transport.version)

    private_key = PrivateKey(size=2048)
    contract = Contract()
    short_address = private_key.public_key.short_address
    owner_role = contract.set_owner_addresses(short_address)
    revoke_permission = RevokePermission(owner_role)
    contract.add_permission(revoke_permission)
```

## Docs and resources

For more information see:
- [Universa Knowledge Base](https://kb.universablockchain.com/)
- [Universa Java API](https://kb.universablockchain.com/general_java_api/5)
- [Universa UMI server](https://kb.universablockchain.com/umi_protocol/98)

## License

This package is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
claraw10 0.0.1
A plotting and clustering package
Requires Python: >=3.6

## This package allows you to:
1. Create a scatterplot 
2. Plot the distribution of your data
3. Group or cluster samples in your data

### 1. Creating a scatterplot:

To create a scatterplot, you have to run the **scattergraph** function from the **plotting.py** file, which takes the following arguments:
1.  x: this is the column that you want to plot on your x-axis. This should be a numpy array.
2.  y: this is the column that you want to plot on your y-axis. This should be a numpy array.
3.  xtitle: this will be the title of your x-axis. This should be a string.
4.  ytitle: this will be the title of your y-axis. This should be a string.
5.  graphtitle: this will be the title of your graph. This should be a string.
6.  outlier_treatment: this tells the graph how to visually differentiate outliers on your plot. You can choose one of the below options. This should be a string.
-  "color": plots the outliers in a different color
-  "shape": plots the outliers with a different marker
-  "size": plots the outliers with a different size
-  _Note: this argument will default to size if any other string is passed_
7. outlier_sensitivity: this is a multiplier in a customized IQR calculation, which ultiamately generates a sub-array of outliers. This should be a float (recommended between 0 and 2). If outlier_sensitivity is zero, then your outliers are in the 1st and 4th quartile of your data. The higher the outlier_sensitivity, the fewer the outliers.

### 2. Plotting your distributions:
To plot your distribution, you have to run the **plotdistribution** function from the **plotting.py** file, which takes the following arguments:
1. y: this is the column that has your target data. This should be a numpy array.
2. numberofbins: choose the number of bins for the histogram. The larger the data set, the more likely youï¿½ll want a large number of bins. This should be an int.
3. plottitle: this will be the title of your graph. This should be a string.

### 3. Grouping/creating clusters:
To create clusters, you have to run the **create_clusters** function from the **clustering.py** file, which takes the following arguments:
1. x: the columns that you want to use as a basis for clustering. This should be a numpy array.
2. y: this is the column that has your target data. This should be a numpy array.
3. numberofclusters: the number of clusters to form as well as the number of centroids to generate. This should be an int.
svgpipe 0.2.0
Transactions on existing SVG documents: inject/extract/modify
Requires Python: >=3.7
Keywords: svg,vector graphics,scalable vector graphics,xml,visualisation



`svg|pipe` Transactions for existing SVG documents
==================================================

**Note:** *The project is in an early stage of development. 0.x.x versions do not garantee a stable API.*

`inject` data and SVG content into an existing document, keeping its structure intact.

`extract` data and SVG content from an existing document (planned).

`transfer` data, attributes, etc. between existing SVG elements (planned).


Motivation
----------

Graphics applications are often picky (extremely picky) about the formatting of graphics documents. In order to have SVG files interpreted by your/everybodies favourite vector graphics application, the file structure not only needs to follow the SVG specs, but should follow a precise structure of layers, ids, and other unwritten conventions.

The project wants to facilitate transactions on existing documents for graphics-based workflows:

 + automated SVG generation (e.g. for data visualisation)
 + smooth integration with interactive vector graphics/CAD applications
 + automated data-import into complex pre-formatted graphics documents for visualisation


Philosophy
----------

`svg|pipe` not only uses SVG documents for import/export of graphical content into/from some existing stock of data. SVG documents are XML documents and can serve as data structures themselves.


Requirements and Installation
-----------------------------

Currently under development using:

* Python 3.7
* Pytest 5.2.2.


Install and test
----------------

```
pip install svgpipe
```

(on Windows with older pythons you may need `python -m pip install svgpipe`)


### run tests

When in the package directory, just type:
```
pytest
```

When the package was installed via `pip`:

```
pytest --pyargs svgpipe
```


### visual inspection of test results

To get a file output of the SVG content involved in the testing:
+ Set environment variable `SVGPIPE_TEST_SVG_OUT` to point to the desired output directory.
+ Make sure the directory/folder exists.

After the test run, for each svg injection test there will be three SVG files:
+ `XXXX_test.svg` (before the injection)
+ `XXXX_result.svg` (what was actually the case after the injection)
+ `XXXX_expect.svg` (what should be the case after the injection)
gyre 2019.11.24
A tool that makes building tons of Python manylinux wheels quick and easy.
Requires Python: >=3.6

# Gyre

A tool that makes building tons of Python manylinux wheels quick and easy.

> jī(-ə)r (noun) 
> - a ring or circle.
> - a circular course or motion.
> - a ringlike system of rotating ocean currents

## Installation

`python -m pip install gyre`

## Usage

The Gyre CLI (`gyre`) takes an input directory or PyPI project to
get a source to compile (defaults to the current directory)
and an output directory (defaults to `dist/`) to store the wheels.

Try using `gyre --help` for all options.

### Building Wheels for a Local Project

```console
$ gyre -i ~/kiwisolver
...

$ ls -Al dist/
```

### Building Wheels for a Package on PyPI

Let's say you released a version of your package on PyPI
and now that a new Python version is out you don't want to
check out the tag and rebuild a new wheel. Don't need to
do that anymore!

```console
$ gyre -i kiwisolver==1.1.0
```

Note this only works if you have an `sdist` for that package version
uploaded to PyPI.

### Specifying `manylinux` Version(s)

By default Gyre creates only `manylinux1` builds.
Possible values are `1`, `2010`, and `2014` comma-separated.

```console
$ gyre -i ~/kiwisolver --manylinux=1,2010
```

### Specifying Python version(s)

By default Gyre creates wheels for all Python versions 2.7 to the latest released version.

```console
$ gyre -i ~/kiwisolver --python-versions=3.6,3.7,3.8
```

### Installing External Dependencies

Manylinux environments use CentOS as an operating system so `yum` is the package
manager you must use to install external dependencies.

```console
$ gyre -i scipy==1.3.3 --yum=openblas-devel,lapack-devel
```

### Using Environment Variables

You can specify any number of environment variables via multiple uses of `-e`.

```console
gyre -e NPY_BLAS_ORDER=openblas -i ~/numpy
```

### Using a Custom Build/Wheel Command

You can specify a custom wheel command if the standard `pip wheel [X]` doesn't work.

The two environment variables that are useful for building your own commands are `$PYTHON` and `$PIP`
which point to the specific version of Python and Pip that you should use for that Python version.

You must also make sure that the wheels end up in `$WHEEL_DIR`.

```console
gyre --wheel-command "$PYTHON setup.py bdist_wheel; cp dist/*.whl $WHEEL_DIR"
```

## Using Gyre in Travis for Continuous Deployment

```yaml
services:
  - docker

deploy:
  provider: script
  script:
    # Install dependencies
    - python -m pip install gyre twine

    # Build the sdist
    - python setup.py sdist

    # Build the wheels with Gyre
    - gyre --manylinux=2014

    # Upload all distributions
    - twine upload dist/* --username=${PYPI_USERNAME} --password=${PYPI_PASSWORD}
  on:
    branch: release
```

## License

Apache-2.0
apextras 0.9.1
Some helpers for python's argparse
Requires Python: >=3.6

# python-argparse-extras

Some helpers for python's argparse.

Currently, this package provides 3 HelpFormatter classes that you can extend and / or use with
python's `argparse` module:

## Contents

### `formatter.WideHelpFormatter`

HelpFormatter which tries to use a given amount of the terminal width.

The maximum line length is determines by the class attribute `percentage_of_line_length`.
This defaults to the full width (1.0). Override this class and set your own percentage.

This uses ``shutil.get_terminal_size()`` to determine the line length.

### `formatter.ThreeQuarterWidthHelpFormatter`

A `WideHelpFormatter` subclass with its `percentage_of_line_length` set to three quarters of the terminal line length.

### `formatter.ThreeQuarterWidthDefaultsHelpFormatter`

A `ThreeQuarterWidthHelpFormatter` subclass which also derives from `argparse.ArgumentDefaultsHelpFormatter`. This means that in addition to using 3/4 of the terminal line length, it also prints the argument defaults in the help text.

## Installation & Usage

Install the package with your favourite python package manager:

    pip install apextras

or directly into your [pipenv](https://pipenv.readthedocs.io/):

    pipenv install apextras

After that, you can use these classes in the same way as any other `argparse.HelpFormatter` subclass while creating your argument parser:

    from apextras.formatter import WideHelpFormatter
    parser = argparse.ArgumentParser(formatter_class=WideHelpFormatter)
    parser.add_argument(...)
    ...