semvec/pypi-packages huggingface dataset:
SeagullScaring 1.1.0
A Python module to add the functionality of Seagull Scaring to any program.
Requires Python: >=3.12
Keywords: audio, playsound, scaring, seagull

# SeagullScaring
A Python module to add the functionality of Seagull Scaring to any program.

### Usage
Copy `seagull_scaring.py` into your project directory.

Import the file and create a Scarer object. Refer to `example.py` for example usage.
dnsmoke 1.0.0
A tool to generate random DNS noise.

# DnSmoke

A tool to generate random DNS noise.

## Installation
`pip install dnsmoke`

## Usage
You can add the command to your **system startup**  to ensure it runs in the background automatically or run when required.

- **Basic run:** `dnsmoke` or  `python3 dnsmoke.py`
- **Custom speed (default 6 queries/min):** `dnsmoke -q 15`
- **Avoid specific network (Home IP):** `dnsmoke -n 192.168.1.12`
- **Use custom domain list:** `dnsmoke -f domains.txt`

## Arguments
- `-q` : Queries per minute (Default: 6)
- `-n` : IP to avoid (exits if matched)
- `-f` : Load custom domains from file
lzy-codec 0.1.1
一種變長文本編解碼方案，支持對Unicode進行編解碼。編解碼效率、存儲空間全面優於UTF-8，未來會替代UTF-8成為新的世界通用編解碼標準。
Requires Python: >=3.6

# LZY Codec

一種變長文本編解碼方案，支持對Unicode進行編解碼。編解碼效率、存儲空間全面優於UTF-8，未來會替代UTF-8成為新的世界通用編解碼標準。

[lzy-codec-py](https://github.com/lizongying/lzy-codec-py)

[pypi](https://pypi.org/project/lzy-codec)

## Other languages

[lzy-codec-go](https://github.com/lizongying/lzy-codec-go)

## install

```
pip install lzy_codec
```

## example

```
from lzy_codec import lzy
r = lzy.encode_from_string('hello，世界')
print(r)

r = lzy.decode_to_string(r)
print(r)
```
mldsa-mu 1.0.0
Python library for generating external μ (mu) values as specified by ML-DSA
Requires Python: >=3.10

# mldsa-mu

A small Python library for generating **external μ (mu)** values as specified by **ML-DSA (FIPS 204)**.

This library is intended for use in systems that need to compute μ outside of a full ML-DSA signing implementation (for example: KMS-style services, HSM adapters, or test tooling).

---

## What is μ?

In ML-DSA, the value **μ** is defined as:

```
μ = SHAKE256(tr || M', 64)
```

where:

- `tr = SHAKE256(public_key, 64)`
- `M' = 0x00 || len(context) || context || message`

This library implements exactly that construction.

---

## Features

- Deterministic μ generation per FIPS 204
- Supports optional domain-separation context
- Utilities for extracting raw public keys from (base64) PKIX / SPKI encodings

---

## Installation

```bash
pip install mldsa-mu
```

---

## Usage

### Example: generate μ from a raw public key
```python
from mldsa_mu import generate

public_key = b"\x01" * 64
message = b"hello world"

mu = generate(public_key, message)
print(mu)
```

### Example: generate μ with a domain-separation context
```python
from mldsa_mu import generate

public_key = b"\x02" * 64
message = b"important message"
context = b"my-protocol-v1"

mu = generate(public_key, message, context=context)
print(mu)
```

### Example: extract raw public key from DER-encoded PKIX (SPKI) and generate μ
```python
from mldsa_mu import generate, public_key_from_pkix

with open("public_key.spki.der", "rb") as f:
    spki_der = f.read()

public_key = public_key_from_pkix(spki_der)

mu = generate(public_key, b"hello world")
print(mu)
```

### Example: extract raw public key from base64-encoded PKIX (SPKI)
```python
from mldsa_mu import generate, public_key_from_pkix_b64

spki_b64 = (
    "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8A..."
)

public_key = public_key_from_pkix_b64(spki_b64)

mu = generate(public_key, b"hello world")
print(mu)
```

---

## Development

Create (and remove if needed) the Hatch dev environment.
```bash
hatch env remove dev
hatch env create dev
```

Run tests: `hatch run dev:fmt`

Run code linting: `hatch run dev:pytest`

Run code type checking: `hatch run dev:typing`

## License

`mldsa-mu` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.

---

*Python written by humans. English written by AI.*
proxPDM-ospfeigrp 0.0.1
A small client for proxmox datacenter manager API
Requires Python: >=3.13

﻿# proxPDM API client

proxPDM is a library for python similar to proxmoxer for proxmox ve only proxPDM is for the datacenter manager api


# Install

    pip install proxPDM

## Example Usage

      from proxPDM import PDMClient
      api = PDMClient( host="192.168.1.100",
      token_id="root@pdm!mytoken",
      token_secret="abc-123-uuid",
      verify_ssl=False) 
	   
	   # GET /version 
	   print(api.version.get())

		# POST /resource/{id}/guest/{vmid}/status/stop 
		# Example: stop VM 101 on remote 'production-cluster' 
		api.resource("production-cluster").guest("101").status.post(action="stop")
commithink 0.1.3
AI-powered Conventional Commit generator using Ollama
Requires Python: >=3.10
Keywords: git, commit, conventional-commits, cli, ollama, ai

# commithink

![Local AI](<https://img.shields.io/badge/AI-local%20(ollama)-success?style=flat-square&color=informational>) ![License](https://img.shields.io/pypi/l/commithink?style=flat-square&color=informational)

**commithink** is an AI-powered CLI tool that generates **clean, Conventional Commit messages** by analyzing your staged Git changes.

It uses a **local LLM via Ollama**, works fully offline, and guides you through an **interactive workflow** so you always stay in control.

> AI suggests. You decide.

## Features

- AI-generated commit messages (local, via Ollama)
- Follows **Conventional Commits**
- Interactive mode (accept, regenerate, edit, change type)
- Uses staged changes (`git diff --cached`)
- No cloud APIs, no API keys
- Project-level configuration
- Fully offline

## Requirements

- Python **>= 3.10**
- Git
- Ollama installed and running locally (ollama.com)

After installation, make sure Ollama is running and that you have at least one model available.

## Installation

### Recommended (pipx)

`pipx` installs CLI tools globally in isolated environments.

```bash
pipx install commithink
```

### Alternative (pip)

```bash
python -m pip install commithink
```

## Basic usage

Stage your changes as usual:

```bash
git add .
```

Then run:

```bash
commithink
```

`commithink` will analyze the staged diff and guide you through an interactive flow to produce the final commit message.

## Interactive controls

| Key | Action                    |
| --- | ------------------------- |
| `a` | Accept and commit         |
| `r` | Regenerate the message    |
| `e` | Edit the message manually |
| `t` | Change commit type        |
| `q` | Abort                     |

## Passing a hint

You can optionally provide a short description of your changes:

```bash
commithink "fix validation on user registration"
```

This helps the model generate a more accurate message.

## Dry run

To generate a commit message **without committing**:

```bash
commithink --dry-run
```

## Configuration

`commithink` supports **project-level configuration** via a `.commithink.toml` file in the repository root.

### Set configuration values

```bash
commithink --config model=qwen2.5-coder:3b
commithink --config language=english
```

This creates or updates the following file:

```toml
model = "qwen2.5-coder:3b"
language = "english"
```

### Configuration precedence

1. CLI options (`--model`, `--lang`)
2. `.commithink.toml`
3. Built-in defaults

## Example output

```text
fix: handle user registration errors correctly
```

## Philosophy

`commithink` is designed to:

- reduce cognitive load
- improve commit quality
- keep the developer in control

AI assists — **the final decision is always yours.**