semvec/pypi-packages huggingface dataset:
spritely 0.0.1
Generate an svg sprite file from other svg files
Requires Python: >=3.11

# spritely
Create an svg sprite file from other svg files

# Usage
```bash
spritely --config {path to config file} > /tmp/my-new-sprite-file.svg
```

# Installation
```bash
python -m pipx install --Upgrade spritely
```

# Config format
See tests/resources for example.
radis-app 0.1.20
A simple CLI app that prints personal info
Requires Python: >=3.8

# MyApp

A simple command-line Python application that prints a description of a person.

## 🧑 What It Does

When you run the command:

```bash
myapp


Use cd: + file path to go to a specific file directory

Use pip install -e . from myApp directory to be able to run this program 
with just the terminal command: myApp
peateazea 0.1.1
A Python package for controlling PTZ cameras through various protocols
Requires Python: >=3.9

# Peateazea

A Python package for controlling PTZ (Pan-Tilt-Zoom) cameras through various protocols. Currently supports Avkans cameras, VISCA, and VISCA over UDP.

## Features

- Multi-protocol support:
  - Avkans cameras
  - VISCA (TCP)
  - VISCA over UDP
- Basic PTZ controls (pan, tilt, zoom)
- Preset position recall
- Home position support
- Simple, unified API across different protocols

## Installation

Install using pip:

```bash
pip install peateazea
```

Or install from source:

```bash
git clone https://github.com/benbaptist/peateazea.git
cd peateazea
pip install -e .
```

## Requirements

- Python 3.9 or higher
- `requests`
- `visca-over-ip`

## Usage

### Basic Example

```python
from peateazea import Avkans, Visca, ViscaUDP

# For Avkans cameras
camera = Avkans("192.168.1.100", 80, username="admin", password="password")

# For VISCA over TCP
camera = Visca("192.168.1.100", 1259)

# For VISCA over UDP
camera = ViscaUDP("192.168.1.100", 52381)

# Basic controls
camera.pantilt(-12, 0)  # Pan left
camera.pantilt(12, 0)   # Pan right
camera.pantilt(0, -12)  # Tilt up
camera.pantilt(0, 12)   # Tilt down

camera.zoom(7)    # Zoom in
camera.zoom(-7)   # Zoom out

camera.stop()     # Stop all movement
camera.home()     # Return to home position

# Recall preset position
camera.recall_preset(1)
```

## License

MIT License

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.
turkyazim 1.2.0
Gelişmiş Türkçe Yazım Denetleyici - Zemberek + BERT + TDK

# Türkçe Yazım Kontrol Kütüphanesi

Türkçe metinlerde yazım hatalarını tespit eden ve düzelten basit ama güçlü bir Python kütüphanesi.

## Özellikler

- Türkçeye özel yazım denetimi  
- Otomatik kelime önerileri  
- Büyük harf ve noktalama kuralları kontrolü  
- Kolay entegrasyon  
- CLI desteği  
- Web API olarak kullanılabilir  

## Kurulum

```bash
pip install turkyazim

## kullanım
from turkyazim import TurkceYazim

denetleyici = TurkceYazim()
sonuc = denetleyici.duzelt("Bu metin cok guzel degıl.")
print(sonuc)

CLI ile kullanım
turkyazim "Bu metin cok guzel degıl." --duzelt
parseable-dataclasses 1.0.0
Dataclass extension to use argparse
Requires Python: >=3.12

# Parseable dataclasses

This library provides `parse_args` method to your dataclass.

## Install

`pip install git+https://github.com/m5ep12/parseable_dataclasses.git`

## Examples

### Simple dataclass

```python
@parseable_dataclass
@dataclass
class DC:
    a: int
    b: str
    opt: float = 3.141592
```

or

```python
@parseable_dataclass
class DC:
    a: int
    b: str
    opt: float = 3.141592
```

and parse

```python
assert, hasattr(DC, "parse_args")
dc = DC.parse_args("1 hello".split())
# dc(a=1, b="hello", opt=3.141592)
dc = DC.parse_args("1 hello 2.71828".split())
# dc(a=1, b="hello", opt=2.71828)
```

### Generate help-text

```python
dc = DC.parse_args(["-h"])
usage: DC [-h] [--opt OPT] a b

positional arguments:
  a           int
  b           str

options:
  -h, --help  show this help message and exit
  --opt OPT   float
```

### Make CLI

```python
from pathlib import Path
from pprint import pprint
from parseable_dataclasses import parseable_dataclass

@parseable_dataclass
class SuperTool:
    src: list[Path]
    verbose: bool = False
    timeout: float = 10.0
    retly: int = 3
    prefix: str = "Hello"

    def __call__(self):
        # implementation your tool
        pprint(self)

if __name__ == "__main__":
    tool = SuperTool.parse_args()
    tool()
```

```bash
$ python examples/make_cli.py -h
usage: SuperTool [-h] [--verbose | --no-verbose] [--timeout TIMEOUT] [--retly RETLY] [--prefix PREFIX] src

positional arguments:
  src                   Path

options:
  -h, --help            show this help message and exit
  --verbose, --no-verbose
                        bool (default: False)
  --timeout TIMEOUT     float (default: 10.0)
  --retly RETLY         int (default: 3)
  --prefix PREFIX       str (default: Hello)

$ python examples/make_cli.py --verbose aaa/bbb.py
SuperTool(src=WindowsPath('aaa/bbb.py'),
          verbose=True,
          timeout=10.0,
          retly=3,
          prefix='Hello')

$ 
```

## Limitations

### tuple

Due to my inability, I have not implemented to accept a complex tuple like following.
(I'd like to convert this dataclass, but I can't find a nice implementation...)

```python
@parseable_dataclass
@dataclass
class SomeClass:
    a: tuple[int, str, float]
```