semvec/pypi-packages huggingface dataset:
pyxair 0.0.2
A library for interacting with Behringer XAir devices.
Requires Python: >=3.7

# pyxair

Python library for interacting with Behringer XAir devices.

## Usage

### Detect XAir Devices

```python
xinfo = await pyxair.auto_detect()
```

### Create an XAir Client

`XAir` is a client that subscribes to events from an XAir device and caches the messages.

```python
xair = pyxair.XAir(xinfo)
asyncio.create_task(xair.start())
```

### Get & Put

Here's an example using the `get` coroutine to retrieve the status. This is achieved by sending an OSC message to the `/status` address:

```python
await xair.get("/status")
```

Response:

```python
OscMessage(address='/status', arguments=['active', '192.168.86.128', 'XR18-5E-91-5A'])
```

This is am example using the `get` coroutine to retrieve the main L/R mix:

```python
await xair.get("/lr/mix/on")
```

Response:

```python
OscMessage(address='/lr/mix/on', arguments=[0])
```

We can use the `put` coroutine to apply changes to the XAir device. In this example, we unmute the main L/R channel:

```python
await xair.put("/lr/mix/on", [1])
```

If we now send a `get` request to the main L/R mix, we see that it is unmuted:

```python
await xair.get("/lr/mix/on")
```

Response:

```python
OscMessage(address='/lr/mix/on', arguments=[1])
```

### Monitoring Updates

In this example, the XAir `_cache` attribute currently looks like this:

```python
{
    '/status': OscMessage(address='/status', arguments=['active', '192.168.86.128', 'XR18-5E-91-5A']),
    '/lr/mix/on': OscMessage(address='/lr/mix/on', arguments=[0])
}
```

If you unmute the main L/R channel using X-AIR-Edit, or some other client, and then observe the `_cache` attribute again, it will look like this:

```python
{
    '/status': OscMessage(address='/status', arguments=['active', '192.168.86.128', 'XR18-5E-91-5A']),
    '/lr/mix/on': OscMessage(address='/lr/mix/on', arguments=[1])
}
```

Using `get` on an OSC address not in the cache will fetch the value from the XAir device and update the cache:

```python
await xair.get('/lr/mix/fader')
```

Now, the `_cache` will look like this:

```python
{
    '/status': OscMessage(address='/status', arguments=['active', '192.168.86.128', 'XR18-5E-91-5A']),
    '/lr/mix/on': OscMessage(address='/lr/mix/on', arguments=[1]),
    '/lr/mix/fader': OscMessage(address='/lr/mix/fader', arguments=[0.5747800469398499])
}
```

### Subscribing to Updates

Use the `subscribe` method to get published messages:

```python
with xair.subscribe() as queue:
    while True:
        message = await queue.get()
        print(f"Got a new OSC message: {message}")
```

### Subscribing to Meters

Enable a meter on an `XAir` instance, and then meter updates will be published to the same subscription queue as described in the previous section:

```python
xair.enable_meter(2)
```
xox 0.1.1
Lightweight virtualenv orchestration

xox: lightweight virtualenv orchestration
=========================================

This project helps provision virtualenvs and dependencies for your Python code.
It works like tox_ or nox_, but your requirements are declared in your script.

Credit to the nox_ project for much of the implementation.


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

Use pip::

    pip install --user xox


Usage
-----

Before you import any other third-party modules, call ``xox.activate()``::

    import xox

    xox.activate("lxml", "requests>=1.0")

    import lxml
    import requests

This will create a virtualenv, install packages, and call ``os.exec()`` to
replace the current process. The virtualenv will be re-used in subsequent runs.

You could also pass ``python='pythonX.Y'`` to specify a Python version, or
``silent=False`` to show output from ``pip``.

... And that's it! No custom executables or config files needed, just an extra
header in your script.


Notes
-----

Any code before your ``activate()`` call will be run twice: once without and
once within the virtualenv. Any code after your ``activate()`` call will run
only within the virtualenv.

Each virtualenv is stored in a subdirectory of system's temporary directory
named ``'xox-virtualenvs'``. No cleanup mechanism is provided - sorry!


.. _tox: https://tox.readthedocs.io
.. _nox: https://nox.thea.codes
gitlab-superb-helper 1.0.0
Projeto para ser utilizado como Helper para o GitLab
Requires Python: >=3.5

# GitLab Helper

This is an open source tool to help manage GitLab.

## Pre-requisites

Install the dependencies
+ pip3 install -r requirements.txt

## Scripts

**1. CloneUpdateGroup.py** - Clones all the projects of a group in their respective path structure

    python3 CloneUpdateGroup.py --url="" --token="" --userGroupId="" basePath=""

**2. ConcederAcessoListaGrupoUsuariosListaProjetos.py** - Grants access to a list of user groups in a list of projects:

    python3 ConcederAcessoListaGrupoUsuariosListaProjetos.py --url="" --token="" --userGroupIdList="" --projectIdList="" --nivelAcesso="" --verbose=""

**3. ConcederAcessoFull.py** - Grants access to all GitLab projects (repositories):

    python3 ConcederAcessoFull.py --url="" --token="" --userGroupId="" nivelAcesso="" --verbose=""

**4. ConcederAcessoGrupoUsuariosGrupoProjetos.py** - Grants access to a group of users in all repositories from a group project:

    python3 ConcederAcessoGrupoUsuariosGrupoProjetos.py --url="" --token="" --projectGroupId="" --userGroupId="" --nivelAcesso="" --verbose=""

**5. ConcederAcessoGrupoUsuariosSubgrupoProjetos.py** - Grants access to a group of users in all projects (and subprojects) with a specific name group:

    python3 ConcederAcessoGrupoUsuariosSubgrupoProjetos.py --url="" --token="" --subGrupo="" --userGroupId="" --nivelAcesso="" --verbose=""
ppprint 0.1.0
An easy to use Python Pretty Print
Requires Python: >=3.6
Keywords: print pretty console progress bar

# Python Pretty Print

A simple and lightweight Python library to use as a replacement of the default `print()` function.

Full documentation available on [Github](https://github.com/sylvelk/ppprint/tree/master/ppprint). Feel free to submit any [feature request](https://github.com/sylvelk/ppprint/issues/new?template=feature_request.md) or [bug report](https://github.com/sylvelk/ppprint/issues/new?template=bug_report.md) !

## Getting started

### Download and install

```bash
pip install ppprint
```

### Standard use

```python
from ppprint import ppprint
```

### JavaScript-like use

```python
from ppprint import console

console.log("Hello World !")
console.warn("Careful ...")
console.error("Ooops something went wrong !")
console.info("Climate change is real.")
console.debug("this code works")
```
pcdm 0.1.0
Property Casualty Data Model Standard
Requires Python: >=3.8

# PCDM
[![PyPI version](https://badge.fury.io/py/pcdm.svg)](https://badge.fury.io/py/pcdm)

Property Casualty Data Model

SQLAlchemy implementation of [OMG Property Casualty Data Model](https://www.omg.org/spec/PC/About-PC/)

![](docs/pcdmcdm.png)

## Distribution

According to the [Object Management Group](https://www.omg.org/gettingstarted/overview.htm#Free):

>Anyone can download specifications from the OMG website for free, write software implementations that conform to the specifications, and use them, give them away, or sell them. Neither OMG membership nor license is required for this.


## Installation and Deployment

This repository requires sqlalchemy, so install it if you don't have it:

```
pip3 install sqlalchemy
```

or
```
pip3 install -r requirements.txt
```

The file deploy_sqlite contains a script that can be used to deploy a SQLite database:

```
git clone https://github.com/genedan/PCDM
cd PCDM
python3 deploy_sqlite.py
```

## PyPI

This packages is also avaiable on PyPI:

```
pip3 install pcdm
```
olivar 0.0.1
Olivar pipeline
Requires Python: >=3.7

# Olivar
Olivar is an open source pipeline for comprehensive design of primer and probe sets for pathogen 
sequences. Our pipeline relies on the state-of-the-art primer generating software, and incorporates 
low frequency variant information to ensure robust sensitivity and specificity for rapidly evolving 
pathogens. Additionally, our software provides visualization and validation capabilities to aid fast 
evaluation of the output probe and primer sets.

### Install
To use Olivar, simply clone the repository and ensure that the requrements below are installed and in the system path.

### Requirements
* Biopython
* Pandas
* Jinja2
* Parsnp
* Primer3
* Blast
* MAFFT
* PyVCF
* pysam

#### Additional requirements for simulation
1.  Samtools
2.  Minimap2
3.  Bowtie2
4.  Lofreq

### Usage
To run Olivar and generate probes and primers for a set of sequences and a reference, 

```
olivar /path/to/reference.fasta /path/to/input_genomes/ --email <your_email>
```

If you have a set of read datasets you'd like to use to simulate more input data: 
```
olivar /path/to/reference.fasta /path/to/input_genomes/ \
    --simulate /path/to/read_directories
    --csv      /path/to/read_metadata.csv
    --email <your_email>
```
NCBI may throttle your blast queries if you only provide your email. If you have an API, you can provide that instead to have a higher allowance. Alternatively, you can supply a local blast database location via `--blastdb <database_location>`.

You can skip the generation of primers by adding the `--probes-only` flag. Please see the `--help`
documentation for more arguments.


### Output
The final output reports are present in `output/final_report`. In `output`, intermediate directories 
for the other modules' output is present as well.