semvec/pypi-packages huggingface dataset:
deliverymatch-python 0.1.0
Python client for DeliveryMatch API
Requires Python: >=3.10

# DeliveryMatch Python Client

Auto-generated Python client for the DeliveryMatch API.

## Installation

```bash
pip install deliverymatch-python
```

## Usage

See [tests/test_api.py](tests/test_api.py) for examples.

## Development

Requires [uv](https://docs.astral.sh/uv/).

```bash
make install
make generate SPEC=/path/to/openapi.yaml
make test
make lint
```
pyconverters-paddleocr 0.5.5
Convert PDF to structured text using PaddleOCR
Requires Python: >=3.8

# pyconverters_paddleocr

[![license](https://img.shields.io/github/license/oterrier/pyconverters_paddleocr)](https://github.com/oterrier/pyconverters_paddleocr/blob/master/LICENSE)
[![tests](https://github.com/oterrier/pyconverters_paddleocr/workflows/tests/badge.svg)](https://github.com/oterrier/pyconverters_paddleocr/actions?query=workflow%3Atests)
[![codecov](https://img.shields.io/codecov/c/github/oterrier/pyconverters_paddleocr)](https://codecov.io/gh/oterrier/pyconverters_paddleocr)
[![docs](https://img.shields.io/readthedocs/pyconverters_paddleocr)](https://pyconverters_paddleocr.readthedocs.io)
[![version](https://img.shields.io/pypi/v/pyconverters_paddleocr)](https://pypi.org/project/pyconverters_paddleocr/)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pyconverters_paddleocr)](https://pypi.org/project/pyconverters_paddleocr/)

Convert PDF to structured text using [PaddleOCR](https://github.com/kermitt2/paddleocr)

## Installation

You can simply `pip install pyconverters_paddleocr`.

## Developing

### Pre-requesites

You will need to install `flit` (for building the package) and `tox` (for orchestrating testing and documentation building):

```
python3 -m pip install flit tox
```

Clone the repository:

```
git clone https://github.com/oterrier/pyconverters_paddleocr
```

### Running the test suite

You can run the full test suite against all supported versions of Python (3.8) with:

```
tox
```

### Building the documentation

You can build the HTML documentation with:

```
tox -e docs
```

The built documentation is available at `docs/_build/index.html.
motor-python 0.0.6
CubeMars motor module for Aries exosuits.
Requires Python: <3.14,>=3.11

# Motor Control Software for Soft Exoskeleton
[![Coverage Status](https://coveralls.io/repos/github/TUM-Aries-Lab/motor-module/badge.svg?branch=main)](https://coveralls.io/github/TUM-Aries-Lab/motor-module?branch=main)
![Docker Image CI](https://github.com/TUM-Aries-Lab/motor-module/actions/workflows/ci.yml/badge.svg)



## Install
To install the library run:

```bash
uv install motor_python
```

OR

```bash
uv install git+https://github.com/TUM-Aries-Lab/motor_python.git@<specific-tag>  
```

## Publishing
It's super easy to publish your own packages on PyPI. To build and publish this package run:
1. Update the version number in pyproject.toml and imu_module/__init__.py
2. Commit your changes and add a git tag "<new.version.number>"
3. Push the tag `git push --tag`

The package can then be found at: https://pypi.org/project/motor_python

## Module Usage
```python
"""Basic docstring for my module."""

from loguru import logger

from motor_python.cube_mars_motor import CubeMarsAK606v3

def main() -> None:
    """Run a simple demonstration."""
    motor = CubeMarsAK606v3()
    motor.get_status()
    motor.set_position(position_degrees=0.0)

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

## Program Usage
```bash
uv run python -m motor_python
```

## Structure
<!-- TREE-START -->
```
├── Test Rig CAD files
│   ├── Foot.3mf
│   ├── Jetson_Mount.3mf
│   ├── Leg_with_2_IMU's.3mf
│   ├── Motor_Case.3mf
│   ├── Rod_Adapter_Jetson.3mf
│   ├── Rod_Adapter_Motor.3mf
│   └── Spool_V2.3mf
├── docs
│   ├── AK60-6 Manual.pdf
│   └── Jetson-Orin-Nano-DevKit.pdf
├── src
│   └── motor_python
│       ├── config
│       ├── __init__.py
│       ├── __main__.py
│       ├── cube_mars_motor.py
│       ├── definitions.py
│       ├── examples.py
│       ├── motor_status_parser.py
│       └── utils.py
├── tests
│   ├── __init__.py
│   ├── conftest.py
│   ├── cube_mars_motor_test.py
│   ├── motor_status_parser_test.py
│   └── utils_test.py
├── .dockerignore
├── .gitignore
├── .pre-commit-config.yaml
├── .python-version
├── CONTRIBUTING.md
├── Dockerfile
├── LICENSE
├── Makefile
├── README.md
├── pyproject.toml
├── repo_tree.py
└── uv.lock
```
<!-- TREE-END -->
selene-core 0.2.4
The core interop library for Selene python interfaces
Requires Python: >=3.10

# Selene-Core

Selene is designed to be extensible through the use of plugins, in the form
of compiled libraries and lightweight python interfaces that provide configuration
for the selene-sim frontend. We achieve this through this selene-core crate and
python module.

Each plugin should comprise a python component and a compiled library component.
The compiled library implements the Selene plugin API, and the python component
provides configuration, link information and the path to the compiled library to
the selene frontend.

The selene-core python module provides interfaces for plugins to adhere to. It also
provides a bundled include directory, containing C headers for the Selene plugin API
for each type of component.

To access the C headers in the build stage of a python package, depend on selene-core
as a build dependency and call `selene_core.get_include_directory()`. The resulting
path can be provided to a build system for C or C++ and the plugin APIs can be included
through:
```c
#include <selene/simulator.h>   # for the simulator API
#include <selene/error_model.h> # for the error model API
#include <selene/runtime.h>     # for the runtime API
```

By implementing the required functions, the plugin can be dynamically loaded by Selene
at runtime.
tgzr.shell 0.102
tgzr command line interface
Requires Python: >=3.9

# tgzr.shell
tgzr workstation runtime

# Create a Shell Application plugin:

There are 3 types or shell app you can provide:
- [NiceGUI](https://nicegui.io/) App:
    - Insall `tgzr.shell[nicegui]`
    - Use `tgzr.shell.app_sdk.nice_app.ShellNiceApp`
- [qtpy](https://pypi.org/project/QtPy/) App:
    - Insall `tgzr.shell[qt]` will install `qtpy` and `PySide6`
    -   Note: If you prefer using PyQt, you can install `tgzr.shell`+`qtpy`+`PyQt6`
    - Use `tgzr.shell.app_sdk.qtpy.ShellQtpyApp`
- Executable file App:
    - Simply install `tgzr.shell`
    - Use `tgzr.shell.app_sdk.exe_app.ShellExeApp`

## Nice app example
To implement a NiceGUI app plugin, you need to:
- install `tgzr.shell[nicegui]`
- create an instance of a `tgzr.shell.app_sdk.ShellApp`
- add an entry point in the group "tgzr.shell.app_plugin" pointing to that app


**Here is a minimalist workging example:**
> 
> **your_package/app.py**:
> ```python
> from . import run_native, run_dev, pages
> from tgzr.shell.app_skd.nice_app import ShellNiceApp
> 
> app = ShellNiceApp(
>     "app_name",
>     run_native_module=run_native,
>     run_dev_module=run_dev,
>     static_file_path=Path(pages.__file__).parent / "static_files",
> )
> ``` 
>
> **your_package/pages.py**:
> ```python
> from nicegui import ui
> 
> 
> @ui.page("/", title="My App")
> async def main():
>     ui.label("Hello world! 😛")
> ```
> 
> **your_package/run_native.py**:
> ```python
> if __name__ == "__main__":
>    from .app import app
>
>    app.run_app(native=True, reload=False)
> ``` 
>
> **your_package/run_dev.py**:
> ```python
> if __name__ in {"__main__", "__mp_main__"}:
>     from .app import app
>    app.run_app(native=False, reload=True)
> ``` 
>
> **pyproject.toml**:
> ```
> [project.entry-points."tgzr.shell.app_plugin"]
> my_shell_app = "your_package:app"
> ```
opendbs 1.0.1
Official Python Client for OpenDBS
Requires Python: >=3.6

# OpenDBS Python Client

Official Python client library for OpenDBS.

## Installation

```bash
pip install opendbs
```

## Usage

### Initialization

```python
from opendbs import OpenDBS

# Initialize
client = OpenDBS("http://localhost:4402")

# Login
client.login("admin", "admin123")
```

### Basic Operations

```python
# Create Database
client.create_database("shop")

# Create Racks
client.create_rack("shop", "products", type="sql", schema={
    "name": {"type": "string"},
    "price": {"type": "number"}
})
client.create_rack("shop", "users", type="nosql")

# Insert Data
client.insert("shop", "users", {"name": "Alice"})
client.sql("shop", "INSERT INTO products (name, price) VALUES ('Laptop', 999)")

# Find Data
users = client.find("shop", "users", {"name": "Alice"})
```

### Advanced Search

```python
# Fuzzy Search
results = client.fuzzy_search("shop", "users", "field", "Alice")

# Vector Search
results = client.vector_search("shop", "products", "embedding", [0.1, 0.2, 0.3])
```
sumolib 1.26.0
Python helper modules to read networks, parse output data and do other useful stuff related to the traffic simulation Eclipse SUMO
Keywords: simulation, sumo, traci, traffic

# sumolib

sumolib is a set of python modules for working with SUMO networks, simulation output and other simulation artifacts.

## Installation

Install sumolib by simply executing:
```pip install sumolib```

A [daily version](https://test.pypi.org/project/sumolib/) is also available in TestPyPI:
```pip install -i https://test.pypi.org/simple/ sumolib```

## Getting Started

To use sumolib in your Python code, import the `sumolib` module. The following code snippet shows a basic example
of how to load a network file and retrieve the coordinate of a node:

```python
import sumolib

# Parse the network
net = sumolib.net.readNet("myNet.net.xml")

# Retrieve the coordinate of a node based on its ID
print(net.getNode("myNodeID").getCoord())
```

## Documentation

The sumolib documentation is available online at
[https://sumo.dlr.de/docs/Tools/Sumolib.html](https://sumo.dlr.de/docs/Tools/Sumolib.html). For a list of available
functions take a look at the [pydoc generated documentation](http://sumo.dlr.de/pydoc/sumolib.html)
or simply browse the [source code here](https://github.com/eclipse-sumo/sumo/tree/main/tools/sumolib).


## Contributing

If you find a bug in sumolib or have a suggestion for a new feature, please report it on the SUMO issue tracker at
[https://github.com/eclipse-sumo/sumo/issues](https://github.com/eclipse-sumo/sumo/issues).
If you would like to contribute code to sumolib, please submit a pull request to the SUMO repository at
[https://github.com/eclipse-sumo/sumo](https://github.com/eclipse-sumo/sumo).

## License

sumolib is released under the Eclipse Public License 2.0 (EPL-2.0).
traci 1.26.0
The pure python version of the TraCI API to communicate with the traffic simulation Eclipse SUMO
Keywords: simulation, sumo, traffic

# TraCI - Traffic Control Interface

TraCI (short for Traffic Control Interface) is an API that provides access to a SUMO traffic simulation,
enabling controlling the behavior of multiple simulation objects during a live simulation.
It allows for external scripts to interact with the simulation and its vehicles, pedestrians, and infrastructure.

## Installation

To use TraCI, you must first have an Eclipse SUMO installation. Install TraCI by simply executing:
```pip install traci```

A [daily version](https://test.pypi.org/project/traci/) is also available in TestPyPI:
```pip install -i https://test.pypi.org/simple/ traci```

## Getting Started

To use TraCI in your Python code, import the `traci` module. The following code snippet shows a basic example
of how to connect to a running SUMO simulation using TraCI:

```python
import traci

# Connect to SUMO simulation
traci.start(["sumo", "-c", "path/to/your/sumocfg/file.sumocfg"])

# Simulation loop
step = 0
while step < 1000:
    traci.simulationStep()
    # Your simulation logic here
    step += 1

# Close TraCI connection
traci.close()
```

Once connected to the SUMO simulation, TraCI provides a range of functions that can be used to query and modify
the state of the simulation. For example, you can use TraCI to control the behavior of individual vehicles,
modify the traffic light phases, or query the current state of the simulation.

## Documentation

The TraCI documentation is available online at
[http://sumo.dlr.de/docs/TraCI.html](http://sumo.dlr.de/docs/TraCI.html). The documentation provides detailed
information on the TraCI API, including a list of available functions and their parameters.

## Examples

There are some [TraCI Tutorials](https://sumo.dlr.de/docs/Tutorials/index.html#traci_tutorials) available.

## Contributing

If you find a bug in TraCI or have a suggestion for a new feature, please report it on the SUMO issue tracker at
[https://github.com/eclipse-sumo/sumo/issues](https://github.com/eclipse-sumo/sumo/issues).
If you would like to contribute code to TraCI, please submit a pull request to the SUMO repository at
[https://github.com/eclipse-sumo/sumo](https://github.com/eclipse-sumo/sumo).

## License

TraCI is released under the Eclipse Public License 2.0 (EPL-2.0).