semvec/pypi-packages huggingface dataset:
pylogenetics 0.4.0
Phylogenetic analysis tools

# pylogenetics

A python package containing classes and functions for phylogenetic analyses.


Includes
 - A tree class
 - A matrix class
 - Functions for reading tree files in newick format
 - A function for creating a MRP (supertree) matrix of a set of trees

### Installing

A step by step series of examples that tell you how to get a development env running

Say what the step will be

```
Give the example
```

And repeat

```
until finished
```

End with an example of getting some data out of the system or using it for a little demo

## Usage examples


## Running the tests

Explain how to run the automated tests for this system


## Authors

* **Billie Thompson** - *Initial work* - [PurpleBooth](https://github.com/PurpleBooth)

See also the list of [contributors](https://github.com/your/project/contributors) who participated in this project.

## License

This project is licensed under the MIT License - see the [LICENSE.txt](LICENSE.txt) file for details
boutpy 0.0.1.dev3
Common python2.x toolkits for BOUT++ project
Requires Python: ~=2.7

________ _______ _____  __________
    ___  __ )__  __ \__  / / /___  __/______ ______
    __  __  |_  / / /_  / / / __  /   ___/ /____/ /_
    _  /_/ / / /_/ / / /_/ /  _  /    /_  __//_  __/
    /_____/  \____/  \____/   /_/      /_/    /_/

BOUT++ boutpy's documentation!
=================================

**Wellcome to BOUT++ boutpy documentation**!

**BOUTPY** is a ``Python2.x`` package intended to provide some common
tools required for performing Plasmas Fluid Simulations with
 [BOUT++](http://boutproject.github.io/index.html) framework.
The **BOUTPY** in the latest release
[BOUT++ v4.0.0](https://github.com/boutproject/BOUT-dev/releases/tag/v4.0.0)
is ``Python3.x`` supported.

**Download** This repo is accessible on
[GitLab](https://gitlab.com/conderls/boutpy)

**Bugs Report** The most bugs and issues are managed using the
[issue tracker](https://gitlab.com/conderls/boutpy/issues).
All suggestions, comments and feature requests are gladly wellcome and
appreciated.

Getting Started
----------------

It's highly encouraged to use [Anaconda](https://www.continuum.io/downloads)
as the python environment.
Before starting to use the tools in this package, some envrionment variables
and required packages are suggested to be set up first.

```shell
$ pip install boutpy

# if "IOError: Permission denied" occoured, try:
$ pip install --user boutpy

```

User Manual
------------------
The document for this repo is available at
[ReadTheDocs](http://boutpy.readthedocs.io). The user manual for the latest
BOUT++ are available [here](http://bout-dev.readthedocs.io/en/latest/)
paraproc 0.1.3
Easy parallel processing in Python

.. image:: https://img.shields.io/pypi/v/paraproc.svg
   :target: https://pypi.python.org/pypi/paraproc

.. image:: https://img.shields.io/badge/license-MIT-green.svg
   :target: https://github.com/herrlich10/paraproc/blob/master/LICENSE.txt

Overview
========
Paraproc is a simple library that helps you easily parallelize your computation
(over independent chunks of data) across multiple processes in Python, especially 
when you want to mix callings to external command line programs and hand brew 
Python functions together in your data processing pipeline.

Under the hood, it combines subprocess and multiprocessing, and uses a process pool
to schedule the jobs. It also provides a numpy.ndarray interface to access 
shared-memory across multiple processes.

Paraproc supports both Python 2 and 3, with numpy as the only external dependency. 
It is contained in only one Python file, so it can be easily copied into your project. 
(The copyright and license notice must be retained.)

Code snippets that demonstrate the basic usage of the library can be found later
in this documentation, and in the demo_*.py files.

Bugs can be reported to https://github.com/herrlich10/paraproc. 
The code can also be found there.

Quick starts
============
Execute commands in parallel
----------------------------
You can run both Python codes and command line programs in parallel:

.. code:: python

    import os
    import paraproc
    def my_job():
        print(os.getpid())

    pc = paraproc.PooledCaller()
    for k in range(5):
        pc.check_call(my_job) 
    for k in range(5):
        pc.check_call('echo $$', shell=True) # For linux/mac
    pc.wait()

The ``pc.check_call()`` method will return immediatedly. The actual execution of 
the queued commands are delayed until you call ``pc.wait()``.

Use shared-memory
-----------------
You can load large data in shared-memory, and read or write them 
as a normal numpy array from multiple processes:

.. code:: python

    import numpy as np
    import paraproc
    def slow_operation(k, x):
        x.acquire()
        x[:100000,:] += 1 # Write access
        res = np.mean(x) # Read access
        x.release()
        print('#{0}: mean = {1}'.format(k, res))

    a = paraproc.SharedMemoryArray.from_array(np.random.rand(1000000,500)) # About 4 GB
    pc = paraproc.PooledCaller()
    for k in range(pc.pool_size):
        pc.check_call(slow_operation, k, a)
    pc.wait()

The data in ``a`` is shared in memory across all children processes and 
never copied even with write accesses.
giftbit 0.1
A Python SDK for GiftBit's API

# giftbit-python

A Python SDK for GiftBit's API.

## Installation
```bash
$ pip install giftbit
```

## Getting Started 

### API Credentials
The `GiftbitClient` needs your Giftbit credentials. You can pass them into the constructor
or use the environment variable `GIFTBIT_API_KEY`.
```python
from giftbit import GiftbitClient

client = GiftbitClient(api_key="<your api key here>")

# or using the environment variable
client = GiftbitClient()
```

By default, the `GiftbitClient` uses Giftbit's testbed API. To use the production API server, do the following: 
```python
from giftbit import GiftbitClient, 

client = GiftbitClient(testbed=False)
```

You can check to see if the client is configured correctly by using the ping method
```python
from giftbit import GiftbitClient, 

client = GiftbitClient(testbed=False)

result = client.ping()

print(result)
```

## Brands 

### List Brands 

```python
from giftbit import GiftbitClient, 

client = GiftbitClient()

result = client.list_brands()

for brand in result['brands']:
    print(brand['name'])
```

### Get Individual Brand

```python
from giftbit import GiftbitClient, 

client = GiftbitClient()

result = client.get_brand('amazonus')

print(result['brand'])
```

## Regions 
Not implemented yet

## Campaigns 
Not implemented yet

## Funds 
Not implemented yet

## Gifts 
Not implemented yet

## Links 
Not implemented yet
wtsize 0.1.0
WTSize let's you check the size of a remote file without downloading it.

# WTSize

On the road with a limited data plan or bad network and want to know if it's safe to download a particular remote file? WTSize (what the size) is a small Python 3 CLI app which checks the size of remote files without downloading them (by looking at the Content-Length header).

```
>>> wtsize https://site.tld/some_big_file.zip
822.24 MiB
```

## Usage

```
wtsize URL
wtsize URL [--unit=MiB]
wtsize -h | --help
wtsize --version
```

## Install

```
pip install wtsize
```

## Limitations

- Not all servers return a Content-Length header so you might be unable to get the actual file size without, well, downloading the file. `wtsize` will tell you if that's the case.
- In some cases the Content-Length cannot be known before accessing the body (dynamic content)
- Headers can easily be spoofed. Generally, though, there's a good chance that the Content-Length header in the server response is accurate.
TideServer 0.2a5
Flask REST API to supply tidal gravity corrections
Requires Python: >=3.5.*

TideServer
==========

Installation
------------

1. Create a virtual environment on deployment server:

.. code-block:: bash

    mkdir TideServer && cd TideServer
    python3 -m virtualenv venv


2. Activate the virtual environment and install the flask app

.. code-block:: bash

    source venv/bin/activate
    pip install tideserver