semvec/pypi-packages huggingface dataset:
hello-robot-stretch-urdf 0.1.2
Stretch URDF

# Overview

The Stretch URDF package provides URDF and Mesh files for use by Stretch Body. 
This URDF data is uncalibrated and is managed completely seperately from the Stretch ROS(2) URDF data. 

This package can be installed by:

```
python3 -m pip install  -U hello-robot-stretch-urdf
```

The URDF and mesh data is installed as a Python package. It's location can be found as:

    import importlib.resources as importlib_resources
    pkg = str(importlib_resources.files("stretch_urdf"))

The URDF naming convention is `stretch_description_<model_name>_<tool_name>.urdf`
For example:

    model_name = robot.params['model_name']
    tool_name = robot.params['tool']
    urdf_name = pkg + '/%s/stretch_description_%s_%s.urdf' % (model_name, model_name, tool_name)

For further example usesage, see the included `stretch_urdf_example.py`
mysqllib 1.0.6
Simple mysql database library

# Mysqllib
Simple mysql database

## Connect
```text
connect(
        user: str,
        password: str,
        database: str,
        host: str='127.0.0.1',
        port: int=3306
)
```

## Fetch one
```text
fetchone(query, args=None) -> Optional[dict]
```

## Fetch all
```text
fetchall(query, args=None) -> Optional[list]:
```

## Execute
```text
execute(query, args=None) -> bool:
```

## find
```text
def find(
        table: str,
        conditions: Dict[str, Union[str, List]] = None,
        columns='*',
        joins: Optional[List[Tuple[str, str, str]]] = None,
        order_by=None
) -> dict
```

## findall
```text
def findall(
        table: str,
        conditions: Dict[str, Union[str, List]] = None,
        columns='*',
        joins: Optional[List[Tuple[str, str, str]]] = None,
        group_by=None,
        order_by=None,
        limit=None
) -> list
```

## update
```text
def update(
        table: str,
        data: Dict[str, any],
        conditions: Optional[Dict[str, any]] = None
) -> bool
```

## delete
```text
def delete(
        table: str,
        conditions: Optional[Dict[str, any]] = None
)
```

## insert
```text
def create(
        table: str,
        data: Dict[str, any]
) -> bool
```

# Mirations
## Run
```python
import mysqllib.migration

mysqllib.migration.run_migration('./path/to/migration/directory/')
```
async-progressbar 0.1.2
Add your description here
Requires Python: >=3.9

# async-progressbar

An asynchronous progress bar for Python, supporting both terminal and Jupyter notebook environments.

## Installation

```bash
pip install async-progressbar
```

## Usage

### Basic Example

```python
import asyncio
from async_progressbar import AsyncProgressBar

async def main():
    total = 100
    bar = AsyncProgressBar(total)
    for _ in range(total):
        await asyncio.sleep(0.01)
        await bar.update(1)
    await bar.finish()

asyncio.run(main())
```

### With aiolimiter (rate-limited requests)

```python
import asyncio
import random
import time
from async_progressbar import AsyncProgressBar
import aiolimiter

number_of_requests = 1000
rate_limiter = aiolimiter.AsyncLimiter(500, 1)
progressbar = AsyncProgressBar(number_of_requests)

async def request(i):
    async with rate_limiter:
        await progressbar.update(1)
        await asyncio.sleep(random.random() * 0.01)
        return i

async def main():
    await asyncio.gather(*(request(i) for i in range(number_of_requests)))
    await progressbar.finish()

if __name__ == "__main__":
    t1 = time.time()
    asyncio.run(main())
    print(f"Total time: {time.time() - t1:.2f} seconds")
```

### In Jupyter Notebooks

The progress bar will automatically use an interactive widget if run in a Jupyter notebook.

## API

- `AsyncProgressBar(total, leave=True, prefix="", suffix="", fill="█", minimum_interval=0.1)`
  - `update(progress=1)`: Increment the progress bar.
  - `draw()`: Redraw the progress bar.
  - `finish()`: Mark the progress bar as finished.
  - `reset()`: Reset the progress bar.

## Testing

To run the tests:

```bash
pytest
```
get-args-to-launch-editor 0.1.0a0
A cross-platform Python utility to determine how to launch the user's preferred text editor, using user input, environment variables, and platform-specific fallbacks.
Requires Python: >=2

# `get-args-to-launch-editor`

A cross-platform Python utility to determine how to launch the user's preferred text editor, using user input, environment variables, and platform-specific fallbacks.

## Features

- Resolves a preferred text editor using (in order of precedence):
  1. User-supplied command (`editor` parameter)
  2. `$VISUAL` environment variable
  3. `$EDITOR` environment variable
  4. Platform-specific fallbacks:
     - NT: `notepad`
     - POSIX: `nano`, `vi`
- Verifies that the editor executable exists on the system.
- Canonicalizes the returned command as a list suitable for `os.execvp()` or `subprocess` calls.
- Command-line splitting and executable resolution is platform-aware.

## Installation

```commandline
pip install get-args-to-launch-editor
```

## Usage

```python
from get_args_to_launch_editor import get_args_to_launch_editor

# Example output on Linux:
# ['/usr/bin/nano']
print(get_args_to_launch_editor())

# Example output on Linux:
# ['/usr/bin/vim', '-R']
print(get_args_to_launch_editor('vim -R'))
```

## API

### `get_args_to_launch_editor(editor=None)`

Returns a list of arguments (absolute executable path and any arguments) to launch the user's preferred text editor.

- `editor` (str or None): Optionally specify the editor command to use (overrides env vars and fallbacks).
- Raises `EnvironmentError` if no editor could be found.

## Contributing

Contributions welcome! Please open issues or pull requests on GitHub.

## License

This project is licensed under the [MIT License](LICENSE).