semvec/pypi-packages huggingface dataset:
bluesky-hwproxy 2022.8.0
Proxy for reading bluesky hardware over ZMQ interface.
Requires Python: >=3.7

# Bluesky Hardware Proxy

This is a proxy server to provide access to certain bluesky device methods over a zmq interface.
The interface is based directly on the zmq interface of bluesky-queueserver, so an identical client (with a different address) can be used.
For convenience, a version of `zmq_single_request` with the default address of `tcp://localhost:60620` is provided as `bluesky_hwproxy.comms.zmq_single_request`.

## Starting a server

`start-hwproxy-server` is an entry point provided to start up an instance of hwproxy.
It accepts the same parameters for specifying the environment that contains device objects as `start-re-manager` from bluesky-queueserver.

for example:

```bash
$ start-hwproxy-server --startup-script ./startup.py
$ start-hwproxy-server --startup-module ophyd.sim
$ start-hwproxy-server --startup-dir ./startup/
```

Note that at present, `--startup-profile` is not connected, though will be in the near future.

## Connecting via python

```python
from bluesky_hwproxy.comms import zmq_single_request

devices = zmq_single_request("list")[0]["result"]

describe = zmq_single_request("describe", {"device":devices[-1]})[0]["result"]
```

## Connecting via cli

We provide a `hwproxy` command line program to allow interfacing with the hwproxy server

Commands to interact with the server itself:
```bash
$ hwproxy list # List available hardware as string keys, one per line
motor1
motor2
det

$ hwproxy reload # reload available devices
```

The following print JSON response to the terminal:

```bash
$ hwproxy read <device>
$ hwproxy describe <device>
$ hwproxy config read <device>
$ hwproxy config describe <device>
$ hwproxy hints <device>
```

Output is colorized when run from an interactive shell, plain text when e.g. piped.

Finally, we allow checking if a set position is valid:
```bash
$ hwproxy check <device> <value>
true
```

The result is simply `true` or `false` printed to the terminal.

`<value>` can be any json encoded string (most of the time it is a simple float, however pseudopositioners and specialized hardware may use lists, etfc.
mpv-remote-app 0.0.5
Server for the Android application
Requires Python: >=3

# mpv-remote-app
Server for an Android application to control the [mpv media player](https://mpv.io/)
running on a separate computer.

Source: [mcastorina/mpv-remote-app](https://github.com/mcastorina/mpv-remote-app)

## Features

* play / pause / stop
* fast forward / rewind
* volume slider
* fullscreen
* subtitles toggle
* audio / subtitle selection
* file browsing
* automatically find server
* NEW! play yt video streams from URL or search keywords

## Donate

I develop this software in my spare time. If you find it useful, consider
buying me a coffee! Thank you!

[![ko-fi](https://www.ko-fi.com/img/donate_sm.png)](https://ko-fi.com/O5O0LAWC)
opentelemetry-instrumentation-digma-fastapi 0.7.0
Digma instrumentation for FastAPI
Requires Python: >=3.6

# opentelemetry-instrumentation-digma-fastapi
[![Tests](https://github.com/digma-ai/opentelemetry-instrumentation-digma-fastapi/actions/workflows/unit-tests.yml/badge.svg)](https://github.com/digma-ai/opentelemetry-instrumentation-digma-fastapi/actions/workflows/unit-tests.yml)
[![PyPI version](https://badge.fury.io/py/opentelemetry-instrumentation-digma-fastapi.svg)](https://badge.fury.io/py/opentelemetry-instrumentation-digma-fastapi)

This package extends the default FastAPI instrumentation for OTEL to provide additional attributes which can be used to facilitate Continuous Feedback back to the code. 

## Installing the package
```bash
pip install opentelemetry-instrumentation-digma-fastapi
```
Or add it to your requirements/poetry file.

## Instrumenting your FastAPI project

### Enable OpenTelemetry in your project
First, configure OpenTelemetry in your project. See the [Digma instrumentation](https://github.com/digma-ai/opentelemetry-instrumentation-digma) repo for quick instructions on getting that done, whether you're already using OTEL or not.

Make sure you've instrumented your FastAPI application using the standard Pypi package.
1. Install the package:
``` pip install opentelemetry-instrumentation-fastapi ```
2. Instrument the FastAPI app by adding the following to your app setup: 
```python 
FastAPIInstrumentor.instrument_app(app) 
```

More info can be found in the [official package documentation](https://opentelemetry-python-contrib.readthedocs.io/en/latest/instrumentation/fastapi/fastapi.html). 

### Enable the Digma OpenTelemetry instrumentation

Before or after the call to ```FastAPIInstrumentor.instrument``` to enable OTEL, also add the following:

```python 
DigmaFastAPIInstrumentor().instrument_app(app)
```

### Check out some sample projects

You can review a simple example in the [FastAPI Sample Repo](https://github.com/digma-ai/otel-sample-fastapi)
Or a more complex real world example in the [Gringotts Vault API application](https://github.com/doppleware/gringotts-vault-api) (which includes both FastAPI, Postgres, RabbitMQ and other technologies)