semvec/pypi-packages huggingface dataset:
pypollution 1.1
A python library for making graph in real time (Hardware based Library).
License: MIT

#pypollution
-----------
pollution is a python library for ploating real time COM port data. This library is project dependent library made for pollution detection and analysis. for more details http://https://github.com/Pamelabanerjee11/pollutionMonitor

*This library is based on specified Hardware*

Ex:
---

import pypollution as plot
import serial.tools.list_ports as ports
import os

print("Available ports : \nPort\t Hardwere")
for i in range(len(ports.comports())):
	print(ports.comports()[i])

inputPort = input("\nEnter Ardiuno Port Number : ")
try:
    p = plot.pyAnalysis(inputPort, os.path.dirname(__file__))
    p.genrateLineAnalysis()
except:
    print("An error is occurred while plotting the graph. Probable reason may be :")
    print("1. You are running app in read only memory.")
    print("2. Check your hardware port(COM port).")
    print("3. Wrong port assignment.")
mitest 0.2.1
mongo inspired policy test
License: MIT

mitest - Mongo Inspired policy test
===================================

.. image:: https://travis-ci.org/WYFDEV/mitest.svg?branch=master
    :target: https://travis-ci.org/WYFDEV/mitest
    :alt: Travis status for master branch

.. image:: https://codecov.io/gh/WYFDEV/mitest/branch/master/graph/badge.svg
   :target: https://codecov.io/gh/WYFDEV/mitest
   :alt: codecov.io status for master branch

Introduction
------------

Test if data match policy, inspired by
`MongoDB query format <https://docs.mongodb.com/manual/tutorial/query-documents/>`_

A **policy** express the expected *relationship* between *variable* and *data*
uesing json (or python dict direct).

Key beginning with "$" to indicate relationship like `$and`, `$lt`, `$gte`.


Example
-------

policy, variable "a" less then 10::

    {"a": {"$lt": 10}}

test, if given data match policy::

    >>> policy = TestPolicy({'a': {'$lt': 10}})
    >>>
    >>> result = policy.test({'a': 9})
    >>> bool(result)
    True
    >>> result.how
    [('a', {'$lt': 10}, 9)]
    >>>
    >>> result = policy.test({'a': 11})
    >>> bool(result)
    False
    >>> result.how
    [('a', {'$lt': 10}, 11)]

Arrtibute `how` express how data match or not match policy.
For example, `("a", {"$lt": 10}, 9)` mean that for variable `a`, policy is `lessthen 10`,
and (or but, if not match) given data is `9`.


Policy format
-------------

MongoDB query format is a little complicated, but
"Simple is better than complex".

For this MongoDB query::

    {"$or":[
        {"$and":[
            {"a":"23"},
            {"b":6}
        ]},
        {"$and":[
            {"c":{"$gte":2}},
            {"c":{"$lt":4}}
        ]}
    ]}

"$and" is default for each items in list::

    {"$or":[
        [
            {"a":"23"},
            {"b":6}
        ],
        [
            {"c":{"$gte":2}},
            {"c":{"$lt":4}}
        ]
    ]}

Merge items to single dict::

    {"$or":[
        {"a":"23", "b":6},
        {"c":{"$gte":2, "$lt":4}}
    ]}

Much simpler :-)

----------------------------------------

Wish this can help you.
mixingbear 0.0.1
Automatic beat-mixing of music files
License: MIT
Keywords: Automatic beat-mixing of music files. audio analysis

[![GitHub license](https://img.shields.io/github/license/Naereen/StrapDown.js.svg)](https://github.com/Naereen/StrapDown.js/blob/master/LICENSE)
[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](http://makeapullrequest.com)

# MixingBear
Automatic beat-mixing of music files in Python, using [AudioOwl](https://github.com/dodiku/AudioOwl) ��

**Jump to:**
- [Quickstart](https://github.com/dodiku/MixingBear#quickstart)
- [Installation](https://github.com/dodiku/MixingBear#installation)
- [Usage](https://github.com/dodiku/MixingBear#usage)


![MixingBear](https://raw.githubusercontent.com/dodiku/MixingBear/master/Images/MixingBear.png)

# Quickstart
Mix two WAV files -
```python
import mixingbear
mixingbear.mix('track01.wav', 'track02.wav', 'output.wav')
```
# Installation
> Tested on Python 3.6 or later


> ⚠️ AudioOwl needs **ffmpeg** to be installed on your machine.
> The easiest way to install ffmpeg (at least on a Mac) is using homebrew. [See instructions here](https://gist.github.com/clayton/6196167).


The latest stable release is available on PyPI.  
Install it using the following command -

```bash
$ pip install mixingbear
```

# Usage

## ``mixingbear.mix()``
Saves a mixed WAV file locally to ``output_file_path``

Supported keyword arguments for ``audioowl.get_waveform()``:
- ``top_file`` - Path to a WAV file you want to mix onto ``bottom_file``. e.g. ``top_file=wav_file.wav``
- ``bottom_file`` - Path to a WAV file you want to mix ``top_file`` onto. e.g. ``bottom_file=wav_file.wav``
- ``output_file_path`` - Path for the mixed output WAV file you want to mix ``output_file_path`` onto. e.g. ``bottom_file=output.wav``
- ``mix_mode`` *[optional, default == 'random']* - String:
  - ``random`` - MixingBear will find the best mixing points, and will mix the tracks starting on a random one out of them.
  - ``first`` - MixingBear will find the best mixing points, and will mix the tracks on the **first** one.
- ``sr`` *[optional, default == 22050]* - Integer. Sample rate.
- ``offset`` *[optional, default == 880, equal to ~20 milliseconds on a track with 44100 sample rate]* - Integer. Number of samples to use as padding on beats, to choose sync points. e.g. With offset=880, beats will be considered as 'matching' is they are positioned away from each other in 880 samples or less.
- ``trim_silence`` *[optional, default == True]* - Boolean. If True, MixingBear will trim leading silence on ``top_file``.
spe2py 2.0.0
This module imports a Princeton Instruments LightField (SPE 3.0) file into a python environment.
License: MIT
Keywords: spectroscopy optics imaging data analysis

# spe2py

spe2py is a module that imports a Princeton Instruments LightField (SPE 3.x) file into a python environment. 

### Basic Usage
##### Modules
The `spe2py` module is designed for quick data loading, viewing, and exploration. It is most effective for quick access
to .spe files via a graphical file dialog, and incorporates tooling functionality to view images and plots with as
little typing as possible.

The `spe_loader` module is responsible for the pure .spe file loading functionality, and can (and should) be imported
separately when only lightweight, programmatic loading is necessary.

##### Loading and accessing data
Use the `load()` function to load one or more SPE files at a time into a set of tools:
```python
>>> import spe2py as spe
>>> spe_tools = spe.load()
```
A file selection window will open to allow browsing for source files. The result is an individual SpeTool object, or, in the case where multiple files are loaded at once, a list of SpeTool objects.

Alternatively programmatic loading should be done with with the `spe_loader` module:
```python
>>> import spe_loader as sl
>>> spe_files = sl.load_from_files(['path/to/file1', 'path/to/file2'])
```
The result is an individual SpeFile object, or, in the case where multiple files are loaded at once, a list of SpeFile objects.

Raw data from a file is stored in NumPy arrays and can be accessed directly by
```python
>>> frame_data = spe_tool.file.data[frame][regionOfInterest]
>>> frame_data = spe_tools[n].file.data[frame][regionOfInterest]  # where multiple files are loaded
```
or when using the pure loader module:
```python
>>> frame_data = spe_file.data[frame][regionOfInterest]
>>> frame_data = spe_files[n].data[frame][regionOfInterest]  # where multiple files are loaded
```

##### Automatic imaging and plotting (spe2py tools only)
To quickly view an individual frame, region-of-interest, or spectrum, use the `image()` or `specplot()` methods. For example,
```python
>>> spe_tool.image()  # images the first frame and region of interest
>>> spe_tool.image(f, r)  # images frame 'f' and region of interest 'r'
>>> spe_tool.specplot()  # plots the loaded spectrum
```

##### Accessing metadata
Upon loading, the metadata contained in the file's XML footer is automatically parsed and stored as an `untangle` object in the `footer` variable. Elements and attributes can be accessed by calling the different elements and subelements of footer, ending with the attribute as a string:
```python
>>> sensor_height = loaded_file.footer.SpeFormat.Calibrations.SensorInformation['height']
```
One can print the full element tree by calling the `xmltree()` method.

### Dependencies
  - NumPy - data storage and file reading
  - [untangle](https://github.com/stchris/untangle) - XML parsing
  - tkinter - file selection dialog (spe2py tools only)
  - matplotlib - imaging and plotting (spe2py tools only)

### Version
2.0.0 - Separation of Tooling and Loading functionality


License
----

MIT
bossdata 0.3.1
Tools to access SDSS spectroscopic data.
License: MIT
Keywords: bossdata

A python package for working with `spectroscopic data <http://www.sdss.org/dr12/spectro/spectro_basics/>`_ from the `Sloan Digital Sky Survey <http://www.sdss.org>`_.

* Free software: MIT license
* Documentation: https://bossdata.readthedocs.org
* Releases: https://pypi.python.org/pypi/bossdata
* Code: https://github.com/dkirkby/bossdata

What's new in version 0.3.1:

* Add support for running at sites where data is local (e.g., nersc)
Flask-WTF-Decorators 0.1.2
Decorators for flask-wtf
License: MIT

# Flask-WTF-Decorators [![Build Status](https://travis-ci.org/simpleapples/flask-wtf-decorators.svg?branch=master)](https://travis-ci.org/simpleapples/flask-wtf-decorators)

Using decorators to validate form.

# Installation

Using pip

`pip install flask-wtf-decorators`

Using Pipenv

`pipenv install flask-wtf-decorators`

# Usage

Flask-WTF-Decorators is easy to use. You can define a view that requires validation.

```python
from flask-wtf-decorators import FormValidator

form_validator = FormValidator()

@form_validator.validate_form(TestForm)
@app.route('/', methods=['GET', 'POST'])
def index(form):
    pass
```

You can tell Flask-WTF-Decorators what to do when a form is illegal. To do this you should provide a callback for `error_handler`.

```python
@form_validator.error_handler
def error_handler(errors):
    return jsonify({'errors': errors}), 400
```

# Test

`python -m unittest discover -s tests`

# Contributing

Please submit a pull request to contribute.

# License

This project is licensed under the MIT License.
django-wallets 0.1.46
BTC, LTC, DASH, DOGE wallets for each user with withdraw with webhook
License: MIT
Keywords: django-wallets

=============================
Django wallets
=============================

.. image:: https://badge.fury.io/py/django-wallets.svg
    :target: https://badge.fury.io/py/django-wallets

.. image:: https://travis-ci.org/narnikgamarnikus/django-wallets.svg?branch=master
    :target: https://travis-ci.org/narnikgamarnikus/django-wallets

.. image:: https://codecov.io/gh/narnikgamarnikus/django-wallets/branch/master/graph/badge.svg
    :target: https://codecov.io/gh/narnikgamarnikus/django-wallets

BTC, LTC, DASH, DOGE wallets for each user with withdraw with webhook

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

The full documentation is at https://django-wallets.readthedocs.io.

Quickstart
----------

Install Django wallets::

    pip install django-wallets

Add it to your `INSTALLED_APPS`:

.. code-block:: python

    INSTALLED_APPS = (
        ...
        'wallets.apps.WalletsConfig',
        ...
    )

Add Django wallets's URL patterns:

.. code-block:: python

    from wallets import urls as wallets_urls


    urlpatterns = [
        ...
        url(r'^', include(wallets_urls)),
        ...
    ]

Features
--------

* TODO

Running Tests
-------------

Does the code actually work?

::

    source <YOURVIRTUALENV>/bin/activate
    (myenv) $ pip install tox
    (myenv) $ tox

Credits
-------

Tools used in rendering this package:

*  Cookiecutter_
*  `cookiecutter-djangopackage`_

.. _Cookiecutter: https://github.com/audreyr/cookiecutter
.. _`cookiecutter-djangopackage`: https://github.com/pydanny/cookiecutter-djangopackage




History
-------

0.1.0 (2018-03-20)
++++++++++++++++++

* First release on PyPI.