semvec/pypi-packages huggingface dataset:
uctt 0.5.6
Universal cluster testing toolkit
License: MIT
Keywords: test,unittest

# UCTT

The Universal Cluster Testing Toolbox

## Design

UCTT leverages configerus configuration to configure a number of plugins that
are used to manage a cluster.
The toolbox helps you get a cluster started and accessible, and then lets you
tear it all down.

## UCTT plugins

UCTT is heavily plugins based.  Plugins are registered in UCTT by registering
them using UCTT decoration on plugin factory functions.  If you import a file
that has the decoration, then the plugin is registered and can be used.

We even leverage configerus bootstrapping to import files that include the
factory decoration.

## Tools

## Configerus

We rely heavily on dymanic and abstract configuration using configerus. Most of
the components come with out of the box defaults that work well as long as you
have good config in place.

Determing how to use the toolbox often comes down to discovering the convention
for the tools, and the convetions for the plugins that you want to use.

### Provisioners

The toolbox provides a number of dummy and contrib provisioner implementations
for starting, stopping and connecting to a cluster.

### Clients

Client plugins provide mechanisms for interacting with a cluster.  Clusters are
pretty diverse in behaviour as they are designed to allow interaction with very
specific APIS.

Clients are usually produced directly by a provisioner, as it is aware of what
clients it can be produces.

Clients can be used directly, or as a part of a workload.

Often the goal for a client is to allow common SDK/API access for common systems
such as a docker daemon, a kubernetes cluster or helm.  To do this most clients
try to directly extend common python distributions/packages.

### Workloads

Workload plugins let you apply a workload to a cluster using clients, which are
usually pulled directly from a provisioner.

## Integration

The toolbox is designed to be used in parts, with either contrib or custom code
as needed.

Parts can be used with any testing framework or cli tool.  Parts are designed to
be somewhat thread safe, and only conflict in parrallel where unavoidable.

## Usage

As we heavily rely on configerus to configure elements, you first need to create
usable configerus.config.Config objects.

Typical worklow is to pass a Config object directly to UCTT to ask for a
provisioner. The provisioner is then used to manage the cluster, and provide
clients.  Workloads allow us to standardize loads to apply using clients from
a provisoner.

Workflow:

1. build a configerus Config object on your own.
    Make sure that you have have config sources which will meet the needs of the
    provisioner and workloads that you want.
2. pass the Config object to uctt to ask for a Provisioner based on the config
3. use the Provisioner to start a cluster for testing

4. test your cluster:
    - ask the provisioner plugin for clients to access the cluster
    - use workloads to apply load to a cluster

5. use the provisioner plugin to destroy any resources that you created.
cluster-coords 0.0.7
Build cluster from multiple identical longitude and latitude coordinates
License: MIT
Requires Python: >=3.6

# Cluster Coordinates

Given a longitude, and latitude, cluster_coords will create a new latitude and longitude randomly placing it anywhere between 5 and 25 meters from the original longitude and latitude. This is helpful when adding points to a map, you don't want to add a point directly on top of another point, so this module helps you create a cluster.

```python
from cluster_coords import RandomCoord

longitude=-82.562800
latitude=27.488960

coords = RandomCoord(longitude,latitude).randomize_coords()
new_lat = coords.lat
new_lng = coords.lng
```

# Installation
```pip install cluster_coords```

```python
[sonnyparlin@localhost cluster_coords]$ python
Python 3.9.1 (default, Jan 20 2021, 00:00:00) 
[GCC 10.2.1 20201125 (Red Hat 10.2.1-9)] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> from cluster_coords import RandomCoord
>>> coords=RandomCoord(-82.562800,27.488960).randomize_coords()
>>> coords.lng
-82.56268860928326
>>> coords.lat
27.489076780986935
```

Code borrowed from Stack Exchange answer: [here](https://gis.stackexchange.com/questions/2951/algorithm-for-offsetting-a-latitude-longitude-by-some-amount-of-meters), answer by [haakon-d](https://gis.stackexchange.com/users/260/haakon-d).

This project is open source and is located [here](https://github.com/sonnyparlin/cluster_coords).
vnoise 0.1.0
Vectorized, pure-Python Perlin noise library
License: MIT
Requires Python: >=3.6

# *vnoise*

*vnoise* is a pure-Python, Numpy-based, vectorized port of the [*noise*](https://github.com/caseman/noise) library. It
currently implements the Perlin noise functions in 1D, 2D and 3D version (*noise* also implements simplex noise).

## Why?

*vnoise* was started because the original *noise* library is no longer supported and binaries for recent versions of
Python are unavailable, making it hard to install for non-technical users. *vnoise* does not suffer from the same issue
since it is written in pure Python.

## Is *vnoise* slow?

For scalar input (e.g. when computing noise values one at a time), yes (~300-2000x slower depending on the conditions).

*vnoise* deals with this by offering a vectorized API to compute large numbers of noise values in a single call. Since is
uses Numpy internally, its performance can match or exceed the original library (0.3-4x faster depending on the conditions).

## Installing

```
$ pip install vnoise
```

## Using *vnoise*

Basic example:

```python
>>> import vnoise
>>> noise = vnoise.Noise()
>>> noise.noise1(0.5)
0.0
>>> noise.noise1(0.1)
0.09144000000000001
>>> noise.noise2(0.1, 0.3)
0.09046282464000001
>>> noise.noise3(0.1, 0.3, 0.7)
0.27788822071249925
```

The `noiseX()` functions also accept sequences as arguments:

```python
>>> import numpy as np
>>> noise.noise2([0.1, 0.2, 0.3], np.linspace(0.5, 0.8, 10), grid_mode=True)
array([[0.0893    , 0.08919374, 0.08912713, 0.08910291, 0.08912241,
        0.08918551, 0.08929079, 0.08943552, 0.08961588, 0.08982716],
       [0.1276    , 0.126881  , 0.12643032, 0.12626645, 0.12639833,
        0.12682535, 0.12753768, 0.12851697, 0.12973738, 0.13116695],
       [0.09615   , 0.09412557, 0.09285663, 0.09239525, 0.09276657,
        0.09396889, 0.09597453, 0.09873182, 0.10216802, 0.10619312]])
```

With `grid_mode=True` (default value), a noise value is computed for every combination of the input value. In this case, the length of 
the first input is 3, and the length of the second input is 10. The result is an array with shape `(3, 10)`.

If `grid_mode=False`, all the input must have the same length, and the result has the same shape: 

```python
>>> noise.noise2(np.linspace(0.1, 0.3, 30), np.linspace(10, 10.5, 30), grid_mode=False)
array([0.099144  , 0.12303124, 0.14685425, 0.17057388, 0.194133  ,
       0.21745892, 0.24046583, 0.26305716, 0.28512793, 0.30656706,
       0.32725957, 0.34708877, 0.36593838, 0.38369451, 0.40024759,
       0.41549419, 0.42933872, 0.44169499, 0.45248762, 0.46165335,
       0.46914216, 0.4749182 , 0.47896062, 0.48126415, 0.48183955,
       0.4807138 , 0.47793023, 0.47354831, 0.46764335, 0.460306  ])
```

A seed value can be specified when creating the `Noise` class or afterward using the `seed()` function:

```python
>>> noise = vnoise.Noise(4)
>>> noise.seed(5)
```

## License

This code is available under the MIT license, see [LICENSE](LICENSE).


## Acknowledgments

This code is based on Casey Duncan's [noise](https://github.com/caseman/noise) library. The port was done with the help of [@tatarize](https://github.com/tatarize)
multi-locus-analysis 0.1.0
Utilities for analyzing particle trajectories
License: MIT
Keywords: microscopy diffusion scientific

Multi Locus Analysis
====================

.. image:: https://readthedocs.org/projects/multi-locus-analysis/badge/?version=latest
    :target: https://multi-locus-analysis.readthedocs.io/en/latest/?badge=latest
    :alt: Documentation Status


.. image:: https://travis-ci.org/brunobeltran/multi_locus_analysis.svg?branch=master
    :target: https://travis-ci.org/brunobeltran/multi_locus_analysis

A collection of utilities for analyzing multiple loci (diffusing).

A simple interface designed around Pandas DataFrames allows calculations to be
performed easily for each experiment or across experiments.

Numerous analytical results on the diffusion of polymers are included for
comparison.

Usage
-----

This package can be pip installed

.. code:: bash

    pip install multi_locus_analysis

For detailed usage instructions, please see the
`docs <https://multi-locus-analysis.readthedocs.io>`.