semvec/pypi-packages huggingface dataset:
cubespec-puna 0.1.0
Control the PUNA Hexapod for positioning cubespec optics
Requires Python: >=3.12

# Cubespec PUNA

This project provides all the functionality to control the Symétrie PUNA Hexapod
in order to position the secondary mirror for the CubeSpec CubeSat.

# Initialise the Project

Create a folder and install the package:

```
$ mkdir -p ~/cubespec_puna
$ cd ~/cubespec_puna
$ uv install cubespec_puna
# cgse init
```
py-robot-template 0.1.1
Tempalte project for handling RobotFramework tests projects using python.
Requires Python: >=3.11

### py-robot-template

[![Codecov](https://codecov.io/gh/MarcinMaciaszek/py-robot-template/branch/main/graph/badge.svg)](https://codecov.io/gh/MarcinMaciaszek/py-robot-template) [![CI](https://github.com/MarcinMaciaszek/py-robot-template/actions/workflows/ci.yml/badge.svg)](https://github.com/MarcinMaciaszek/py-robot-template/actions/workflows/ci.yml)

py-robot-template is a template project demonstrating how to create a Python package for use with RobotFramework.

## Features
- Example of building a custom RobotFramework library in Python
- Simple test versioning approach
- Instructions for building and using as a command-line tool
- Uses [uv](https://github.com/astral-sh/uv) for environment management

## Getting Started
1. Clone the repository:
   ```bash
   git clone https://github.com/your-username/py-robot-template.git
   ```
2. Create a virtual environment using uv (Python 3.11+ required):
   ```bash
   uv venv
   ```
3. (Optional) Install development dependencies:
   ```bash
   uv pip install -e ".[dev]"
   ```

## Running Tests with uv
To run unit tests with coverage and generate a coverage report:
```bash
uv run coverage run --source=src/py_robot_template -m unittest discover tests/unit
uv run coverage xml
```
To view the coverage report in the terminal:
```bash
uv run coverage report
```

To run RobotFramework tests:
```bash
uv run robot tests/robot
```

## Project Structure
- `src/py_robot_template` - Python library code
- `tests/robot` - RobotFramework test suites
- `tests/unit` - Unit tests for Python code

## Contributing

Contributions are welcome! Before starting development:

1. Install `uv`:
   ```bash
   pip install uv
   ```
2. Create a virtual environment using uv:
   ```bash
   uv venv
   ```
3. Activate the virtual environment:
   - On Unix/macOS:
     ```bash
     source .venv/bin/activate
     ```
   - On Windows:
     ```bash
     .venv\Scripts\activate
     ```
5. Install pre-commit hooks:
   ```bash
   pre-commit install
   ```
6. (Optional) Run all hooks manually on all files:
   ```bash
   pre-commit run --all-files
   ```

Pre-commit will automatically check your code before every commit.

To contribute:
1. Fork this repository.
2. Create a new branch for your feature or fix:
   ```bash
   git checkout -b feature/your-feature-name
   ```
3. Make your changes and add tests if needed.
4. Commit your changes:
   ```bash
   git commit -am "Add your feature description"
   ```
5. Push to your fork:
   ```bash
   git push origin feature/your-feature-name
   ```
6. Open a pull request describing your changes.

Please ensure your code follows the existing style and passes all tests before submitting a pull request.

### Code Style & Checks

- To run ruff linter:
  ```bash
  ruff check .
  ```
- To format code with ruff:
  ```bash
  ruff format .
  ```
- To run mypy type checks:
  ```bash
  mypy .
  ```

## License
This project is licensed under the MIT License.

This project supports Python 3.11 and newer. All checks are run for Python 3.11, 3.12, and 3.13 in CI.
azure-tts-client 0.1.2
Azure Text-to-Speech Terminal Client
Requires Python: >=3.14
Keywords: azure, cli, speech-synthesis, terminal, text-to-speech, tts

# Azure TTS Client

A terminal-based Text-to-Speech client for Azure Cognitive Services, built with [Textual](https://textual.textualize.io/).

## Features

- Multiple voice options (English, French, German, Spanish, Chinese)
- Beautiful terminal UI with live playback
- Save audio to WAV files
- Secure API key storage
- Fast and lightweight

## Usage

### Running the app

Run directly without installation:

```bash
uvx azure-tts-client
```

### First-time setup

On first launch, you'll be prompted to enter your Azure Speech API key. The key will be saved securely to `~/.azure_tts_env`.

To get an Azure Speech API key:
1. Go to [Azure Portal](https://portal.azure.com)
2. Create a Speech Service resource
3. Copy the API key from the resource

### Using the app

1. **Type your text** in the text area
2. **Select a voice** from the dropdown menu
3. **Click Play** to hear the speech
4. **Click Save** to export audio to `output.wav`
5. **Click Clear Text** to reset the input

## Development

### Local development

Clone the repository:

```bash
git clone <repository-url>
cd azure-client-tts
```

Run with uv:

```bash
uv run -m azure_tts_client
```

## Requirements

- Python 3.10+
- Azure Speech API key

## Publishing to PyPI

### Prerequisites

1. Set up PyPI credentials:
   - Create an account on [PyPI](https://pypi.org)
   - Generate an API token at https://pypi.org/manage/account/token/
   - Store the token for publishing

### Publishing Steps

1. Update the version in [pyproject.toml](pyproject.toml)

2. Build the package:
```bash
uv build
```

3. Publish to PyPI:
```bash
uv publish
```

You'll be prompted for your PyPI token during publish.

Alternatively, set the token as an environment variable:
```bash
export UV_PUBLISH_TOKEN=pypi-your-api-token-here
uv publish
```

To publish to TestPyPI first:
```bash
uv publish --publish-url https://test.pypi.org/legacy/
```

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.
commonroad-labeling 2025.1.2
Automatic labeling of CommonRoad scenarios.
Requires Python: >=3.10

# CommonRoad Automatic Scenario Labeling

[![PyPI pyversions](https://img.shields.io/pypi/pyversions/commonroad-labeling.svg)](https://pypi.python.org/pypi/commonroad-labeling/)
[![PyPI version fury.io](https://badge.fury.io/py/commonroad-labeling.svg)](https://pypi.python.org/pypi/commonroad-labeling/)
[![PyPI download week](https://img.shields.io/pypi/dw/commonroad-labeling.svg?label=PyPI%20downloads)](https://pypi.python.org/pypi/commonroad-labeling/)
[![PyPI download month](https://img.shields.io/pypi/dm/commonroad-labeling.svg?label=PyPI%20downloads)](https://pypi.python.org/pypi/commonroad-labeling/)
[![PyPI license](https://img.shields.io/pypi/l/commonroad-labeling.svg)](https://pypi.python.org/pypi/commonroad-labeling/)

Automatically assign correct labels to CommonRoad scenarios and check whether existing tags are correct.

The full documentation of the API and introductory examples can be found at [cps.pages.gitlab.lrz.de/commonroad/automatic-scenario-labeling](https://cps.pages.gitlab.lrz.de/commonroad/automatic-scenario-labeling).

## Quick Start

### Installation

```sh
$ pip install commonroad-labeling
```

### Usage Example

```python
from pathlib import Path

from commonroad_labeling.common.general import get_detected_tags_by_file

# specify a directory and detect tags
tags_by_file = get_detected_tags_by_file(Path.cwd().joinpath("path", "to", "directory"))
```

## Sketched Functionality
1. Load scenario using commonroad-io.
2. Read all currently assigned scenario tags.
3. Determine which tags are correct.
   1. Using formalized rules.
   2. Using traffic rule monitor.
   3. Using criticality metrics.
4. Check whether the tags are consistent with the previously assigned tags. → Warning if necessary
5. Overwrite scenario with corrected tags.
lib2fas 0.1.10
Unofficial implementation of 2fas for Python (as a library)
Requires Python: >=3.11

# lib2fas Python

Unofficial implementation of 2fas for Python (as a library).
This library serves as the backend for
the [robinvandernoord/2fas-python](https://github.com/robinvandernoord/2fas-python) CLI, a command-line tool that
provides an easy interface to interact with the 2fas TOTP.

## Installation

To install this project, use pip:

```bash
pip install lib2fas
# or to also install the cli tool:
pip install 2fas
```

## Usage

After installing the package, you can import it in your Python scripts as follows:

```python
import lib2fas

services = lib2fas.load_services("/path/to/file.2fas", passphrase="optional")  # -> TwoFactorStorage

services.generate()  # generate all TOTP keys

gmail = services["gmail"]  # exact match (case-insensitive), returns a list of 'TwoFactorAuthDetails' instances.

github = services.find("githbu")  # fuzzy match should find GitHub, returns a new TwoFactorStorage.

for label, services in github.items():
    # one label can have multiple services!
    for service in services:  # 'service' is a TwoFactorAuthDetails instance
        # Print label, service name, and TOTP code
        print("Label:", label)
        print("Service Name:", service.name)
        print("TOTP Code:", service.generate())  # or .generate_int() to get the code as a number.
```

The `passphrase` option of `load_services` is optional.
If you don't provide a password, but your file is encrypted, you will be prompted for the passphrase.
If possible, this will be safely stored in the keychain manager of your OS* until the next reboot.

* Note: only the "Secret Storage" keychain backend on Ubuntu Linux has been tested.

## License

This project is licensed under the MIT License.