semvec/pypi-packages huggingface dataset:
ramlpy 0.0.25
RAML parsing library
License: MIT

RAML parsing library for python
===============================

.. image:: https://coveralls.io/repos/github/alvassin/ramlpy/badge.svg?branch=master
    :target: https://coveralls.io/github/alvassin/ramlpy
    :alt: Coveralls

.. image:: https://travis-ci.org/alvassin/ramlpy.svg
    :target: https://travis-ci.org/alvassin/ramlpy
    :alt: Travis CI

.. image:: https://img.shields.io/pypi/v/ramlpy.svg
    :target: https://pypi.python.org/pypi/ramlpy/
    :alt: Latest Version

.. image:: https://img.shields.io/pypi/wheel/ramlpy.svg
    :target: https://pypi.python.org/pypi/ramlpy/

.. image:: https://img.shields.io/pypi/pyversions/ramlpy.svg
    :target: https://pypi.python.org/pypi/ramlpy/

.. image:: https://img.shields.io/pypi/l/ramlpy.svg
    :target: https://pypi.python.org/pypi/ramlpy/

*Library in very active development stage, is not recommended for use in production.*

**Supports only RAML 1.0 and Python 3.**

The main goal of this library:
 - Fast incoming HTTP requests validation (Resource URI, HTTP method, body)
 - Outgoing HTTP responses validation (when running test with CI)
 - Usable tool to use RAML Data types for validating any data structures (e.g. Rabbitmq queues, any other stuff your API is working with)

I also working on aiohttp middleware for super-easy integration, i plan to share it a little bit later.

Versioning
==========

This software follows `Semantic Versioning`_


.. _Semantic Versioning: http://semver.org/
LeshanRestAPI 0.1.2
Wrapper for Leshan IOT RESTful API
License: MIT

# LeshanRestAPI
RESTful Library Wrapper for Leshan IOT.

## Installation
Install using pip  
`pip install LeshanRestAPI`

## Getting Started
Find the url of the Leshan client you want to interface with. Some examples are found on on the [leshan website](https://leshan.eclipse.org/#/clients)  
First import the library and instantiate a new class of Client(), passing in the url. If this is the first time you have connected to this client, the html will be extracted and cached in the cached_clients folder in the installation directory of this library. Future connections will use this json cache to avoid the time consuming process of extracting the html from the client webpage. If the webpage has changed from your cache, supply the parameter refresh=True to your instantiation of Client().  

LeshanRestAPI uses json representation of the client objects and searches this dictionary for a match on the resource supplied by the user. The user can supply additional parameters instance or object_ if the client webpage has more than one resource with the same name.  

## Examples
```
from LeshanRestAPI import Client
runner = Client('https://leshan.eclipse.org/#/clients/358185090000024')
print(runner.read("Lifetime"))
runner.observe("Lifetime")
runner.execute("Update")
runner.discover("Lifetime")
```

## Methods
Available methods are 
```
read  
write  
observe  
discover  
excecute  
AssertRead  
```
These methods take the following inputs in order:  
`resource,object_=None,instance_=None,timeout=TIMEOUT`  
Write takes an additional parameter: text  
`text,resource,object_None,instance=None,timeout=TIMEOUT`

## Additional Details
The user does not need to enter all details of the object for it to be found. In most cases, the resource name is sufficient. Only when there is more than one resource does the user need to provide additional information such as instance or object_.  Note in examples two and three that the instance can be overloaded in the object_ variable.
The following example illustrates this on this [client](https://leshan.eclipse.org/#/clients/358185090000024)
```
read("Lifetime")
read("Lifetime",0)    #search resource Lifetime on instance 0 with object not specified
read("Lifetime","0")  #search resource Lifetime on instance 0 with object not specified
read("Lifetime",None,0)   #search resource Lifetime on instance 0 with object not specified
read("Lifetime","LwM2M Server")   #search resource LifeTime on Object LwM2M Server with instance not specified
read("Lifetime","LwM2M Server",0)     #search resource LifeTime on Object LwM2M Server on instance 0 
```

Since "Lifetime" resource exists only once on this client. The user can use any of the above to read from it.

## Troubleshooting
If you cannot operate on a resource. Try operating on the resource directly through its webportal. Often times, methods are not allowed for a resource or the resource is not available.

More details of the leshan RESTful API is given [here](http://robertsrhapsody.blogspot.com/2018/01/eclipse-leshan-rest-apis.html)
pysndfx 0.3.6
Apply audio effects such as reverb and EQ directly to audio files or NumPy ndarrays.
License: MIT
Keywords: audio music sound

# pysndfx
[![Build Status](https://travis-ci.org/carlthome/python-audio-effects.svg?branch=master)](https://travis-ci.org/carlthome/python-audio-effects) [![PyPI](https://img.shields.io/pypi/v/pysndfx.svg)](https://pypi.python.org/pypi/pysndfx) [![PyPI](https://img.shields.io/pypi/pyversions/pysndfx.svg)](http://py3readiness.org/) [![license](https://img.shields.io/github/license/mashape/apistatus.svg)](LICENSE)

**Apply audio effects such as reverb and EQ directly to audio files or NumPy ndarrays.**

This is a lightweight Python wrapper for SoX, the Swiss Army knife of sound processing programs. Supported effects range from EQ and compression to phasers, reverb and pitch shifters.

## Install
Install with pip as:
```sh
pip install pysndfx
```
The system must also have [SoX](http://sox.sourceforge.net/) installed (for Debian-based operating systems: `apt install sox`, or with Anaconda as `conda install -c conda-forge sox`)

## Usage
First create an audio effects chain.
```python
# Import the package and create an audio effects chain function.
from pysndfx import AudioEffectsChain

fx = (
    AudioEffectsChain()
    .highshelf()
    .reverb()
    .phaser()
    .delay()
    .lowshelf()
)
```
Then we can call the effects chain object with paths to audio files, or directly with NumPy ndarrays.
```python
infile = 'my_audio_file.wav'
outfile = 'my_processed_audio_file.ogg'

# Apply phaser and reverb directly to an audio file.
fx(infile, outfile)

# Or, apply the effects directly to a ndarray.
from librosa import load
y, sr = load(infile, sr=None)
y = fx(y)

# Apply the effects and return the results as a ndarray.
y = fx(infile)

# Apply the effects to a ndarray but store the resulting audio to disk.
fx(x, outfile)
```
There's also experimental streaming support. Try applying reverb to a microphone input and listening to the results live like this:
```sh
python -c "from pysndfx import AudioEffectsChain; AudioEffectsChain().reverb()(None, None)"
```