semvec/pypi-packages huggingface dataset:
shipaw 0.3.27
Shipping client
Requires Python: >=3.13

# Setup

## Index env file

set environment variable 'ENV_INDEX' to an index of environment files:

- SHIPAW_ENV = Shipaw settings env file
- APC_ENV = APC settings env file
- PARCELFORCE_ENV = Parcelforce settings env file

## Shipaw env file
### switches 
- SHIPPER_LIVE - set to 'true' for live mode, 'false' for test mode
- LOG_LEVEL - set to 'DEBUG', 'INFO', 'WARNING', 'ERROR' or 'CRITICAL'

### paths
- LABEL_DIR - absolute path to label download root directory
- LOG_DIR - absolute path to log file directory
- UI_DIR - absolute path to UI root directory (templates and static)

### derived paths to overwrite if necessary
- [STATIC_DIR] = UI_DIR / 'static'
- [TEMPLATE_DIR] = UI_DIR / 'templates'

### sender details
- ADDRESS_LINE1
- [ADDRESS_LINE2]
- [ADDRESS_LINE3]
- TOWN
- POSTCODE
- [COUNTRY] = 'GB'
- BUSINESS_NAME
- CONTACT_NAME
- EMAIL
- [PHONE] = MOBILE_PHONE
- MOBILE_PHONE

## APC env file

- APC_EMAIL
- APC_PASSWORD
- BASE_URL

## Parcelforce env file
- PF_AC_NUM_1
- PF_CONTRACT_NUM_1
- DEPARTMENT_ID=1
- PF_EXPR_USR=EL
- PF_EXPR_PWD

- [PF_ENDPOINT]=https://expresslink-test.parcelforce.net/ws/
- [PF_BINDING]={http://www.parcelforce.net/ws/ship/v14}ShipServiceSoapBinding
- [TRACKING_URL_STEM]='https://www.royalmail.com/track-your-item#/tracking-results/'
myo-model 0.0.0
myo_model is a library of carefully constructed musculoskeletal models.
Requires Python: >=3.10

# MyoModel

**MyoModel** is a library of carefully constructed Musculoskeletal Models.
![banner](https://github.com/user-attachments/assets/87897766-cf55-4932-936f-dc53711976ef)


## Overview
Musculoskeletal models are one the fundamental building blocks in diverse fields - biomechanics, graphics, animation, rehabilitation, etc. Given their significance, there is a rich history of musculoskeletal modeling efforts by multiple groups over decades. In addition to varying conventions, such efforts face two key challenges -
  1. sparsity of experimental data - leading to localized incomplete models
  2. computational challenges - in capturing the full human anatomy

The goal of MyoModel is to develop a comprehensive library that unifies the fragmented developments from disjoint fields while meeting the computational challenges involved in capturing full details of human anatomy.

## Usage
There are multiple ways to explore and leverage MyoModel
  - MyoModel: For any needs involving *only* access to the models, [myo_model](https://github.com/myolab/myo_model) (this repo) is all you need
  - MyoTools: For programmatic access to the models and basic developmental needs, please refer to [myo_tools](https://github.com/myolab/myo_tools) repo
  - MyoSuite: For building data-driven behavioral controllers for the models, please refer to [myosuite](https://github.com/MyoHub/myosuite) repo

## License
A permissive license for non-commercial scientific research is available [here](LICENSE).

## Citation
```bibtex
@techreport{myoskeleton,
  author      = {Vittorio Caggiano AND Vittorio La Barbera AND Andrea Prestia AND Ouassim Aouattah AND Pierre Schumacher AND Varun Joshi AND Vikash Kumar},
  title       = {MyoSkeleton: A Universal Human Skeletal Model},
  institution = {MyoLab Inc.},
  year        = {2024},
  type        = {White Paper},
  note        = {Available at: \url{https://github.com/myolab/myo_model}},
}
```

## Example usage
```python
import mujoco
import mujoco.viewer
from myo_model.utils import model_utils

model_path = model_utils.get_model_xml_path()
mj_model = mujoco.MjModel.from_xml_path(model_path)

# Make the data object
mj_data = mujoco.MjData(mj_model)

# Run the viewer
with mujoco.viewer.launch_passive(
    mj_model, mj_data) as viewer:
    while viewer.is_running():
        viewer.sync()
```
breakout-garden-exporter 2.2.0
Exposes Prometheus metrics based on data collected from Pimoroni Breakout Garden sensors
Requires Python: >=3.10

# breakout-garden-exporter

[![Pipeline](https://github.com/andrewjw/breakout-garden-exporter/actions/workflows/build.yml/badge.svg)](https://github.com/andrewjw/breakout-garden-exporter/actions/workflows/build.yml)
[![PyPI](https://img.shields.io/pypi/v/breakout-garden-exporter)](https://pypi.org/project/breakout-garden-exporter/)
[![PyPI - Downloads](https://img.shields.io/pypi/dm/glowprom)](https://pypi.org/project/breakout-garden-exporter/)
[![Coverage Status](https://coveralls.io/repos/github/andrewjw/breakout-garden-exporter/badge.svg?branch=main)](https://coveralls.io/github/andrewjw/breakout-garden-exporter?branch=master)

Exposes Prometheus metrics from sensors that are part of [Pimoroni's Breakout Garden family](https://shop.pimoroni.com/collections/breakout-garden).

```
usage: breakout-garden-exporter [-h] [-q] [--bind [BIND]]

Exposes Prometheus metrics from sensors that are part of Pimoroni's Breakout Garden family

optional arguments:
  -h, --help     show this help message and exit
  -q, --quiet    don't log HTTP requests
  --bind [BIND]  the ip address and port to bind to. Default: *:9101
```

Currently supported devices are:

* ICP10125 temperature and pressure sensor (e.g. [this](https://shop.pimoroni.com/products/icp10125-air-pressure-breakout))
* SGP30 CO2 and VOC air quality sensors (e.g. [this](https://shop.pimoroni.com/products/sgp30-air-quality-sensor-breakout))
* BME280 temperature, pressure and humidity sensor (e.g. [this](https://shop.pimoroni.com/products/bme280-breakout))
* PM25 air quality sensors (e.g. [this](https://shop.pimoroni.com/products/adafruit-pmsa003i-air-quality-breakout-stemma-qt-qwiic) connect via an [appropriate breakout board](https://shop.pimoroni.com/products/breakout-garden-to-qwiic-adaptor?))

If you have any other breakout devices, please get in touch so we can add support for them!
adaMVP-new 2.0.3
Adaptive AI-Augmented Drug Discovery and Development Molecular Vulnerability Picker
Requires Python: >=3.8

# A3D3a's MVP (adaMVP_new) python package
A novel graph-based, cooperativity-led Markov chain model, A3D3a’s MVP (Adaptive AI-Augmented Drug Discovery and Development Molecular Vulnerability Picker), to identify and prioritize key druggable molecular vulnerabilities in cancer.
dctap2shacl 0.1.1
BIBFRAME Interoperability Group code for transforming DCTap tsv files into SHACL
Requires Python: >=3.12

# BIG dctap2shacl Custom Parser
Code repository for the BIBFRAME InterOp Group's custom DCTap-to-SHACL parser.

## Command Line Usage
After installing, convert one or more BIBFRAME DCTap files to a SHACL validation
graph from the command:

- If installed with [uv][uv], `uv run dctap2shacl --dctap admin_metadata.tsv`
- If installed with pip, `dctap2shacl --dctap admin_metadata.tsv`

This will create and save a turtle file, `bf-validation.ttl` in the same directory.

### Options
- `-h`, `--help` Displays help
- `-i`, `--dctap` One or more DCTap files, seperated by commas
- `-o`, `--shacl` Optional, file name for the validation graph
- `-fmt`, `--format` Optional, RDF serialization format, can be one of the following:
  - `turtle`: Turtle (default)
  - `xml` or `pretty-xml`: XML
  - `json-ld`: JSON Linked Data format
  - `nt`: N-triples


[uv]: https://docs.astral.sh/uv/
runqy-task 0.1.0
Python SDK for runqy-worker tasks
Requires Python: >=3.8
Keywords: task-queue, distributed, worker, redis, async

# runqy-task

Python SDK for creating tasks that run on [runqy-worker](../runqy-worker).

## Installation

```bash
pip install git+https://github.com/Publikey/runqy-python.git
```

## Usage

### Simple Task

```python
from runqy_task import task, run

@task
def process(payload: dict) -> dict:
    return {"message": "Hello!", "received": payload}

if __name__ == "__main__":
    run()
```

### With Model Loading

For ML inference tasks, use `@load` to load models once at startup:

```python
from runqy_task import task, load, run

@load
def setup():
    """Runs once before ready signal. Return value is passed to @task as ctx."""
    model = load_heavy_model()  # Load weights, etc.
    return {"model": model}

@task
def process(payload: dict, ctx: dict) -> dict:
    """Process tasks using the loaded model."""
    prediction = ctx["model"].predict(payload["input"])
    return {"prediction": prediction}

if __name__ == "__main__":
    run()
```

### One-Shot Tasks

For lightweight tasks that don't need to stay loaded in memory, use `run_once()`:

```python
from runqy_task import task, run_once

@task
def process(payload: dict) -> dict:
    return {"result": payload["x"] * 2}

if __name__ == "__main__":
    run_once()  # Process one task and exit
```

| Function | Behavior | Use case |
|----------|----------|----------|
| `run()` | Loops forever, handles many tasks | ML inference (expensive load) |
| `run_once()` | Handles ONE task, exits | Lightweight tasks |

## Protocol

The SDK handles the runqy-worker stdin/stdout JSON protocol:

1. **Load phase**: Calls `@load` function (if registered)
2. **Ready signal**: Sends `{"status": "ready"}` after load completes
3. **Task input**: Reads JSON from stdin: `{"task_id": "...", "payload": {...}}`
4. **Response**: Writes JSON to stdout: `{"task_id": "...", "result": {...}, "error": null, "retry": false}`

## Development

```bash
# Install in editable mode
pip install -e .

# Test
echo '{"task_id":"t1","payload":{"foo":"bar"}}' | python your_model.py
```