semvec/pypi-packages huggingface dataset:
skasip-docker-swarm 1.0.14
SIP Docker Swarm client library.

# SKA SDP SIP Docker Swarm Client API

## Introduction

This package contains a client library for interfacing with the Docker engine
for creating, deleting and inspecting Docker Swarm services as well as 
managing Docker Swarm nodes.

This library is intended to be used by other SKA SDP SIP Execution Control
services, in particular the Processing Block Controller.

## Quick-start

Install with:

```bash
pip3 install -U skasip-docker-swarm
```

Example usage:

```python
from sip_docker_swarm import DockerSwarmClient
DOCKER_SWARM = DockerSwarmClient()
DOCKER_SWARM.get_service_list()
```

## Testing

Linting and unit test are run automatically by SIP CI/CD system but can also be 
run manually from the docker_api code directory with:

```bash
pytest --pylint --docstyle --codestyle -s -v --pylint-rcfile=../../../.pylintrc .
```

or run the following command from the top level directory

```bash
./tools/run_tests.sh sip/execution_control/docker_api/sip_docker_swarm    
```


## TODO

* Need to add exception into the functions
* Add Log to the script
* depends_on is not enabled -> Need to look into this
* Need to setup the environment variables
* Unit test for update_node function
* Figure out how to validate compose files
* While it is useful to test that service exists, it mighe be even better to test
that the service is running as well
bullseye_method 1.0.2
Implemented tensorflow version of the Bullseye method for prior approximation.

# Bullseye!

"Bullseye!" is a new algorithm for computing the Gaussian Variational Approximation of a target distribution. Its strong point lies in the fact that it can easily be parallelized and distributed.

## Getting Started

These instructions will get you a copy of the project up and running on your local machine for development and testing purposes. See deployment for notes on how to deploy the project on a live system.

### Installing

Bullseye! is now available as a [PyPI package](https://pypi.python.org/pypi/bullseye_method/):

```
pip install bullseye_method
```

or clone the repository :

```
git clone https://github.com/Whenti/bullseye
```

or [download and extract the zip](https://github.com/Whenti/bullseye/archive/master.zip) into your project folder.

## Running the tests

To see if everything is working properly, you can already run the algorithm on a multilogit model with artificially generated data.

```py
from Bullseye.Tests import simple_test
simple_test()
```

## Example

```py
import Bullseye
from Bullseye import generate_multilogit

theta_0, x_array, y_array = generate_multilogit(d = 10, n = 10**3, k = 5)

bull = Bullseye.Graph()
bull.feed_with(x_array,y_array)
bull.set_predefined_model("multilogit")
bull.set_predefined_prior("normal_iid")
bull.init_with(mu_0 = 0, cov_0 = 1)
bull.set_options(local_std_trick = True, s=5)
bull.build()

bull.run()
```

## Authors

* **Quentin Lévêque** [Whenti](https://github.com/Whenti)

See also the list of [contributors](https://github.com/Whenti/bullseye/contributors) who participated in this project. Hopefully, there will be more.

## License

This project licensed under the GPL3 License - see the [LICENSE.txt](LICENSE.txt) file for details.
pyoneer-vsx 0.0.3
A python library to control Pioneer VSX AVRs over telnet

# pyoneer_vsx
This is a Python package for interfacing with Pioneer receivers, primarily the VSX series, via telnet commands as outlined in [this specification](https://www.pioneerelectronics.com/StaticFiles/PUSA/Files/Home%20Custom%20Install/VSX-1120-K-RS232.PDF). 

This package was primarily created for use with [Home Assistant](https://www.home-assistant.io) to support receivers that do not work with the current implementation, as well as to extract all of the Pioneer-specific code out of Home Assistant, and to swtich to using a persistent connection via `asyncio`.

This package is based on [`python-anthemav`](https://github.com/nugget/python-anthemav) which provides similar functionality for Anthem receivers.

### Supported functionality

Currently this supports:
 - Power: on/off
 - Volume: 0-100%
 - Mute: on/off
 - Input selection

 The spec outlines more functionality, including listening modes, tone control, multi-zone power/input selection, etc, however for my purposes all I needed were the basics above.

### Update events

Because we keep a persistent connection to the receiver, we receive events every time a change is made to the receiver, either via a command we sent, or by a person physically interacting with the controls on the device itself.

For this reason we only, and always, update our internal state when we get these events, not when we initially send a command to the receiver.

## Setup

### Package installation

You can either install the package using `pip`:
```
pip3 install pyoneer-vsx
```

or clone the repo and install/run it from the source.

### Receiver

Connect your receiver to your network and ensure it has a static IP address either via the `System Setup > Network Setup` menu on the receiver itself, or by assigning it a fixed address on your router.

Also make sure you enable the `Network Standby` feature (also found in the `Network Setup` menu) so we can still connect to the receiver even when it is powered off.

## Testing

I have exclusively tested this with a VSX-822 and a VSX-1121, but any other Pioneer VSX series receiver (and possibly others) should work.

If download the code you can run the following command, substituting in the IP and port as needed:
```
python3 test_harness.py --host IP_ADDRESS --port PORT
```

This will attempt to connect to the receiver, turn it on, select a few different inputs, then turn it off, all with very verbose logging. At the end, your receiver should be off and when you turn it back on it should be set to the Blu-ray/BD input.

## Caveats

Due to the persistent connection described above, using this package will prevent any other applications/services, such as iOS or Android control apps, from connecting to the receiver.