semvec/pypi-packages huggingface dataset:
peng3dnet 0.1.3a0
Networking Library for Peng3d

``peng3dnet`` - Networking Library for ``peng3d``
=================================================

.. image:: https://readthedocs.org/projects/peng3dnet/badge/?version=latest
   :target: http://peng3dnet.readthedocs.io/en/latest/?badge=latest
   :alt: Documentation Status

.. image:: https://circleci.com/gh/not-na/peng3dnet.svg?style=svg
    :target: https://circleci.com/gh/not-na/peng3dnet

.. image:: https://img.shields.io/pypi/dm/peng3dnet.svg
   :target: https://pypi.python.org/pypi/peng3dnet


``peng3dnet`` is a TCP-Based networking Library designed for use with `peng3d <https://github.com/not-na/peng3d>`_\ .

It uses Length-Prefixing to cut the raw TCP Stream into packets, which are usually `MessagePack <http://msgpack.org/>`_\ -encoded Python objects.

``peng3dnet`` has been tested and is developed under Python 3.5, however it should work with newer versions as well.
Python 2.x support is currently not planned, but may be possible by rewriting small parts of the code.

Documentation
-------------

The current documentation is available `here <https://peng3dnet.readthedocs.io>`_ on ReadTheDocs.

The Sphinx-based source for the documentation is available in the ``docs/`` subdirectory.
Documentation for specific methods and classes is usually found in the docstring of the method/class.

Requirements
------------

Currently, ``peng3dnet`` requires only two modules:
- `bidict <https://github.com/jab/bidict>`_\ , as PyPI package ``bidict``
- `msgpack-python <https://github.com/msgpack/msgpack-python>`_ or `u-msgpack-python <https://github.com/vsergeev/u-msgpack-python>`_\ , available under the same name on PyPI

Note that ``msgpack-python`` may be faster, since it has a C-extension.
In cases where C-extensions cannot be used, ``u-msgpack-python`` can be used, since it should work on all platforms and is written in pure Python.

Installation via ``pip``
------------------------

If possible, this method of installation is to be preferred.

Installation via ``pip`` is simple::

    pip install peng3dnet

Note that on some systems it may be necessary to use ``sudo pip install peng3dnet`` if the above command fails.

Installation via ``setup.py``
-----------------------------

If possible, use ``pip`` instead.

Installation via ``setup.py``\ ::

    python setup.py install

Note that using this method requires manually installing the dependencies and downloading of the repository.
It may also be necessary to use ``sudo python setup.py install`` if the above command fails.
hiko 0.0.6
Execute functions in parallel using Dask & other useful stuff

# hiko
[![made-with-python](https://img.shields.io/badge/Made%20with-Python-1f425f.svg)](https://www.python.org/)
[![Maintenance](https://img.shields.io/badge/Maintained%3F-yes-green.svg)](https://github.com/Sarunas-Girdenas/hiko/graphs/commit-activity)
[![codecov](https://codecov.io/gh/Sarunas-Girdenas/hiko/branch/master/graph/badge.svg?token=2O20HPZX0I)](https://codecov.io/gh/Sarunas-Girdenas/hiko)

Seamlessly run simple functions in parallel using [Dask](https://github.com/dask/dask) and other useful tools

# Instalation

To install newest version from PYPI:
```python
pip install hiko
```


# Sample Usecases
## Dask
```python
from hiko.dask import daskify

@daskify()
def squared(x):
  return x ** 2

squared_output = squared([i for i in range(10)])
```

It is also possible to provide cluster address if Dask is running on multiple machines. For example:

```python
@daskify("111.111.111.1:8797")
def squared(x):
  return x ** 2
```
## time
Little utility to provide execution time using decorator

```python
from hiko.time import timeify

@timeify(True)
def squared(x):
  return x ** 2

# if True is provided, then execution time returned alongside the result
result, execution_time = squared(5)
```

# IDEAS
1. Data Query / Data Injection
2. Standard Dask Functions
3. Automated documentation
4. Write more tests

# Modules
hiko
  time
  - data
  - dask
    decorators
    - functions
  - spark
    decorators
    - functions
  - data
  - pipelines
ADCPy 0.1.1
read ADCP data from TRDI and Nortek instruments
Requires Python: >=3.5
Keywords: acoustic doppler profiler ADCP

# ADCPy - code to work with ADCP data from the raw binary using python 3.x

[![Documentation Status](https://readthedocs.org/projects/adcpy/badge/?version=latest)](https://adcpy.readthedocs.io/en/latest/?badge=latest)
[![Build Status](https://travis-ci.org/mmartini-usgs/ADCPy.svg?branch=master)](https://travis-ci.org/mmartini-usgs/ADCPy)
### Purpose
This code prepares large amounts of single ping ADCP data from the raw binary for use with xarray by converting it to netCDF.  

### Motivation
The code was written for the TRDI ADCP when I discovered theat TRDI's Velocity software could not easily export single ping data.  While there are other packages out there, as the time of writing this code, I had yet to find one that saved the data in netCDF format (so it can be accessed with xarray and dask), could be run on linux, windows and mac, and did not load it into memory (the files I have are > 2GB)

The code is written as a module of functions, rather than classes, ensemble information is stored as nested dicts, in order to be more readable and to make the structure of the raw data (particularly the TRDI instruments) understandable.

### Status
As the code stands now, a 3.5 GB, single ping Workhorse ADCP .pd0 file with 3 Million ensembles will take 4-5 hours to convert.  I live with this, because I can just let the conversion happen overnight on such large data sets, and once my data is in netCDF, everything else is convenient and fast.  I suspect that more speed might be acheived by making use of xarray and dask to write the netCDF output, and I may do this if time allows, and I invite an enterprising soul to beat me to it.  I use this code myself on a routine basis in my work, and continue to make it better as I learn more about python.

At USGS Coastal and Marine Geology we use the PMEL EPIC convention for netCDF as we started doing this back in the early 1990's.  Downstream we do convert to more current CF conventions, however our diagnostic and other legacy code for processing instrument data from binary and other raw formats depends on the EPIC convention for time, so you will see a time (Time (UTC) in True Julian Days: 2440000 = 0000 h on May 23, 1968) and time2 (msec since 0:00 GMT) variable created as default.  This may confuse your code.  If you want the more python friendly CF time (seconds since 1970-01-01T00:00:00 UTC) set timetype to CF.

Use at  your own risk - this is a work in progress and a python learning project.

Enjoy,

Marinna