semvec/pypi-packages huggingface dataset:
brickdetector 0.1.0
A package for detecting the word 'brick' in any form within any provided text
Requires Python: >=3.9

# brickdetector

**brickdetector** is a lightweight Python package that detects the presence of the word "brick" in any form (e.g., "Brick", "bricked", "bricking") within a given text input.

## Features

- Detects all variants of the word "brick" (case-insensitive, including prefixes and suffixes as well as unicode characters resembling characters in the word "brick")
- Easy-to-use
- Lightweight

## Installation

```bash
$ pip install brickdetector
```

## Usage

```py
from brickdetector import brickbasher

# w -- string. word to check
brickbasher(w)
```
casrel-datautils-yu 1.1.9
A Chinese relation extraction data utility toolkit based on CasRel model
Requires Python: >=3.7

CasRel 数据处理工具包

这是一个基于 CasRel 模型的中文关系抽取数据处理工具包，支持 BERT 预训练模型。

## 支持的 BERT 模型

- **bert-base-chinese**: 默认中文 BERT 基础模型，适用于通用中文任务，参数量适中，bert_dim=768。

## 安装

- pip install casrel_datautils

## 使用示例

以下是一个使用 `casrel_datautils` 进行数据加载和单条样本处理的示例代码：

```python
from casrel_datautils.Base_Conf import BaseConfig
from casrel_datautils.data_loader import get_dataloader
from casrel_datautils.process import single_sample_process

# 配置基础参数
baseconf = BaseConfig(
    bert_path=r"C:\Lucky_dt\2_bj\BJ_AI23_KG\12days\KG_code\chapter4_code\CasRel_RE\bert-base-chinese", #模型路径
    train_data=r"本地数据路径train.json",
    test_data=r"本地数据路径test.json",
    rel_data=r"本地关系数据路径relation.json",
    batch_size=2
)

# 获取数据加载器
dataloaders = get_dataloader(baseconf)

# 单条样本处理
sample = {"text": "这是一个测试句子"}
input_tensor, mask_tensor = single_sample_process(baseconf, sample)
print(input_tensor.shape)
print(mask_tensor.shape)
```

### 说明

- **BaseConfig**: 用于设置 BERT 模型路径、数据路径和批次大小等参数。
- **get_dataloader**: 返回训练、验证和测试的数据加载器。
- **single_sample_process**: 处理单条文本样本，返回输入张量和掩码张量。

## 注意事项

- 确保数据文件（如 `train.json`、`test.json`、`relation.json`）路径正确。
- 根据任务需求选择合适的 BERT 模型。
openspace-api 0.1.3
Python library to interface with OpenSpace using sockets
Requires Python: >=3.10

# openspace-api-python
Python library to interface with [OpenSpace](https://github.com/OpenSpace/OpenSpace) using sockets.

## Work in progress
Both the API and library are still very much a work in progress and are subject to change.

## Install
Stable release of the OpenSpace API Python package are registered at [PyPi](https://pypi.org/project/openspace-api/). The latest version can be installed using `pip`:

`pip install openspace-api` 

## Python in the terminal
https://github.com/OpenSpace/openspace-api-python/blob/master/example/example.py provides an example of how to connect from a Python script using sockets. To run it, run `python example.py` from the working directory in the terminal.
sbpkg 1.1.4
Simple, fast and full-featured SBo package manager
Requires Python: >=3.9
Keywords: slackware, linux, package, manager, tool

# sbpkg 1.1.3

### About

Simple, fast and full-featured SBo package manager.

Sbpkg is a command-line tool to synchronize with the SlackBuilds.org
repository. It features resolving dependency support, install and
uninstall scripts, and the ability to sync your local machine with
a remote repository to automatically upgrade packages.

### Features

- Install packages with resolving dependencies.
- Build SlackBuilds scripts without installing.
- Check and upgrade installed SBo packages on your system.
- Check your installed packages and dependencies based on repository.
- Remove installed packages with their dependencies.
- Automatic calculate the installed package size.
- Automatic MD5 checksum for download sources.
- Automatic GPG verification for SBo scripts.
- Display the full path of package dependencies.
- Display packages that depend on other packages.
- Search SlackBuilds in the repository.
- Download slackbuilds scripts with sources without build or install them.
- Display the full information of packages in your terminal.
- Display the contents of the SlackBuild files in your terminal.

### Install

```bash
$ tar xvf sbpkg-1.1.3.tar.gz
$ cd sbpkg-1.1.3
$ ./install.sh
```

## Screenshots

### sbpkg --install \<packages\>

<img src="https://gitlab.com/dslackw/images/-/raw/master/sbpkg/install.png" width="900" title="sbpkg --install <packages>">

### sbpkg --remove \<packages\>

<img src="https://gitlab.com/dslackw/images/-/raw/master/sbpkg/remove.png" width="900" title="sbpkg --remove <packages>">

### sbpkg --upgrade

<img src="https://gitlab.com/dslackw/images/-/raw/master/sbpkg/upgrade.png" width="900" title="sbpkg --upgrade">

### sbpkg --pkg-info \<packages\>

<img src="https://gitlab.com/dslackw/images/-/raw/master/sbpkg/information.png" width="900" title="sbpkg --pkg-information <packages>">
getstream-plugins-silero 0.1.0
Silero plugin for GetStream
Requires Python: >=3.10

# Silero Voice Activity Detection Plugin

A fast and accurate Voice Activity Detection (VAD) plugin for GetStream that uses the Silero VAD model.

## Installation

```bash
pip install getstream-plugins-silero
```

## Usage

```python
from getstream.plugins.silero import SileroVAD
from getstream.video.rtc.track_util import PcmData

# Initialize with default settings
vad = SileroVAD()

# Or customize parameters
vad = SileroVAD(
    sample_rate=16000,
    frame_size=512,
    silence_threshold=0.3,
    speech_pad_ms=300,
    min_speech_ms=250,
    max_speech_ms=60000,
)

# Register event handlers
@vad.on("audio")
async def on_audio(pcm_data, user):
    print(f"Detected speech: {pcm_data.duration:.2f} seconds")
    # Process the detected speech with an STT engine
    # await stt.process_audio(pcm_data)

# Process incoming audio
incoming_audio = PcmData(samples=audio_bytes, sample_rate=16000, format="s16")
await vad.process_audio(incoming_audio)

# Reset state if needed
await vad.reset()
```

## Configuration Options

- `sample_rate`: Audio sample rate in Hz (default: 16000)
- `frame_size`: Size of audio frames to process (default: 512)
- `silence_threshold`: Threshold for detecting silence (0.0 to 1.0) (default: 0.5)
- `speech_pad_ms`: Number of milliseconds to pad before/after speech (default: 300)
- `min_speech_ms`: Minimum milliseconds of speech to emit (default: 250)
- `max_speech_ms`: Maximum milliseconds of speech before forced flush (default: 30000)
getstream-plugins-kokoro 0.1.0
Kokoro TTS plugin for GetStream
Requires Python: >=3.10

# GetStream Kokoro Plugin

This package integrates the open-weight [Kokoro-82M TTS model](https://github.com/hexgrad/kokoro) with the GetStream audio/video SDK.

It provides a drop-in `KokoroTTS` class that implements the common `getstream_common.tts.TTS` interface, allowing you to stream PCM audio generated by Kokoro directly into a WebRTC `AudioStreamTrack`.

```py
from getstream.plugins.kokoro import KokoroTTS
from getstream.video.rtc.audio_track import AudioStreamTrack

track = AudioStreamTrack(framerate=24_000)

tts = KokoroTTS(lang_code="a", voice="af_heart")
tts.set_output_track(track)

await tts.send("Hello from Kokoro!")
```

## Installation

```bash
pip install getstream-plugins-kokoro
```

This will pull in the required `kokoro`, `numpy` and `getstream[webrtc]` dependencies.  You also need `espeak-ng` **at runtime** for pronunciation fallback.  On macOS you can install it with Homebrew:

```bash
brew install espeak-ng
```

## Configuration options

| Parameter | Default | Description |
|-----------|---------|-------------|
| `lang_code` | `"a"` | Language group passed to `KPipeline` (`"a"` = American English, etc.) |
| `voice` | `"af_heart"` | Kokoro voice preset.  See the [model card](https://huggingface.co/NeuML/kokoro-int8-onnx#speaker-reference) for available options. |
| `speed` | `1.0` | Playback speed multiplier. |
| `sample_rate` | `24000` | Output sample-rate (fixed by Kokoro).  **The attached `AudioStreamTrack` must use the same value.** |
getstream-plugins-elevenlabs 0.1.0
ElevenLabs plugin for GetStream
Requires Python: >=3.10

# ElevenLabs Text-to-Speech Plugin

A high-quality Text-to-Speech (TTS) plugin for GetStream that uses the ElevenLabs API.

## Installation

```bash
pip install getstream-plugins-elevenlabs
```

## Usage

```python
from getstream.plugins.elevenlabs import ElevenLabsTTS
from getstream.video.rtc.audio_track import AudioStreamTrack

# Initialize with API key from environment variable
tts = ElevenLabsTTS()

# Or specify API key directly
tts = ElevenLabsTTS(api_key="your_elevenlabs_api_key")

# Create an audio track to output speech
track = AudioStreamTrack(framerate=16000)
tts.set_output_track(track)

# Register event handlers
@tts.on("audio")
def on_audio(audio_data, user):
    print(f"Received audio chunk: {len(audio_data)} bytes")

# Send text to be converted to speech
await tts.send("Hello, this is a test of the ElevenLabs text-to-speech plugin.")
```

## Configuration Options

- `api_key`: ElevenLabs API key (default: reads from ELEVENLABS_API_KEY environment variable)
- `voice_id`: The voice ID to use for synthesis (default: "VR6AewLTigWG4xSOukaG")
- `model_id`: The model ID to use for synthesis (default: "eleven_multilingual_v2")

## Requirements

- Python 3.10+
- elevenlabs>=0.2.0
getstream-plugins-cartesia 0.1.0
Cartesia plugin for GetStream
Requires Python: >=3.10

# Cartesia Text-to-Speech Plugin

High-quality **Text-to-Speech** (TTS) plugin for [GetStream](https://getstream.io/) backed by the
[Cartesia](https://github.com/cartesia-ai/cartesia-python) Sonic model. It lets a Python
process speak PCM audio into a Stream call.

## Installation

Install from PyPI (installs both `getstream` and the Cartesia SDK):

```bash
pip install "getstream-plugins-cartesia[webrtc]"
```

If you already have the Stream SDK in your project just add the Cartesia plugin:

```bash
pip install cartesia getstream-plugins-cartesia
```

## Usage

```python
from getstream.plugins.cartesia import CartesiaTTS
from getstream.video.rtc.audio_track import AudioStreamTrack

async def speak():
    # Option A: read key from env var (CARTESIA_API_KEY)
    tts = CartesiaTTS()

    # Option B: pass explicitly
    # tts = CartesiaTTS(api_key="<your key>")

    # Audio MUST be 16-kHz, 16-bit PCM (matches Cartesia Sonic model)
    track = AudioStreamTrack(framerate=16000)
    tts.set_output_track(track)

    # Listen for every raw PCM chunk that gets produced
    @tts.on("audio")
    def _on_audio(chunk: bytes, user):
        print("🔊 got", len(chunk), "bytes of audio")

    await tts.send("Hello from Cartesia!")

# Run inside an event-loop, e.g. `asyncio.run(speak())`
```

## Configuration Options

- `api_key` (str, optional) – Cartesia API key (falls back to `CARTESIA_API_KEY`).
- `model_id` (str) – Which model to hit (`"sonic-2"` by default).
- `voice_id` (str | None) – Cartesia voice to use (pass `None` for model default).
- `sample_rate` (int) – Target sample-rate in Hz. Must match the
  `AudioStreamTrack.framerate` you attach (defaults to `16000`). If they don't match a
  `TypeError` is raised early so you don't get distorted audio on the call.

Events emitted:

• `audio` – each raw PCM chunk, arguments: `chunk: bytes`, `user: dict | None`

• `error` – any exception raised during synthesis

## Requirements

- Python 3.10+
- `cartesia>=2.0.5` (automatically installed)

## Testing

Run the offline unit-tests:

```bash
pytest -q getstream/plugins/cartesia/tests
```

To additionally exercise the live Cartesia API set `CARTESIA_API_KEY` in your
environment; the integration test will be executed automatically.

---

💡 See `examples/tts_cartesia/` for a fully-working bot that joins a Stream call
and greets participants using this plugin.
pyw-ai-docgen 0.0.0
AI-powered automated docstring generation and Sphinx documentation tool within the PythonWoods framework.
Requires Python: >=3.10
Keywords: ai, automation, docstring, documentation, python, sphinx

# pyw-autodocgen

[![PyPI version](https://img.shields.io/pypi/v/pyw-autodocgen.svg)](https://pypi.org/project/pyw-autodocgen)
[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)

`pyw-autodocgen` è un pacchetto placeholder nel namespace `pyw` (PythonWoods).

Questo modulo è riservato per l'integrazione futura con strumenti di generazione automatica di documentazione.
imad213rsa 213.9
High-security encryption tool using RSA-4096 and AES-256 with anti-debug and self-destruct.
Requires Python: >=3.6

[![GitHub](https://img.shields.io/badge/GitHub-imad213rsa-000?logo=github)](https://github.com/imadoo27/imad213rsa)
[![PyPI](https://img.shields.io/pypi/v/imad213rsa?color=blue&logo=pypi)](https://pypi.org/project/imad213rsa/)

# 🔐 IMAD213 RSA – Military-Grade Python Code Encryption

`imad213rsa` is a high-security encryption tool designed to protect your Python source code using the latest military-grade cryptographic techniques, combining **AES-256-GCM**, **RSA-4096**, and **deep anti-debugging layers**. This tool makes decryption nearly impossible without the original private key, even for advanced analysts.

---

## 🚀 Features

- 🔐 **AES-256 GCM encryption** for secure, authenticated encryption
- 🔐 **RSA 4096-bit key wrapping** for encrypted key exchange
- 🔐 **Anti-debugging & sandbox detection** to prevent reverse engineering
- 🔐 **Self-destruct mechanism** if tampering or analysis is detected
- 🔐 **Private key obfuscation** in multiple reversed chunks
- 🔐 **Secure in-memory execution**, no plain-text file is extracted
- 🔐 **Terminal progress display & CLI banner**
- 🔐 **Developed in Algeria 🇩🇿 with global-grade protection**

---

## 📦 Installation

Install via `pip`:

```bash
pip install imad213rsa
```

---

## 🔧 Usage

```bash
imad213rsa yourfile.py
```

✅ Output will be:
```
yourfile_secure.py
```

This new file is encrypted and protected. It runs only with its embedded logic and cannot be decrypted without the internal RSA key.

---

## 📄 Example

```bash
# Encrypt your Python script
imad213rsa script.py

# Output: script_secure.py (encrypted, protected, and anti-debug)
```

---

## 💡 Why use IMAD213 RSA?

| Feature                 | Description                                      |
|------------------------|--------------------------------------------------|
| AES-256 + RSA-4096     | Modern hybrid encryption (military grade)        |
| Anti-Debug Layer       | Terminates under any debugger or sandbox         |
| Self-Destruct Code     | Deletes itself when analyzed or tampered         |
| Obfuscated Key         | Hard-to-rebuild RSA key in reversed chunks       |
| Python Native          | 100% compatible with Python 3.x                  |
| One-Line CLI Tool      | Encrypt any script with a single command         |

---

## 👤 Author

**Imad Madmad**  
📧 Email: `madmadimado59@gmail.com`  
🔒 Creator of high-security Python tools  

---

## 🌐 License

MIT License – Use responsibly.

---

## 🗨️ Arabic Description 

IMAD213 RSA هي أداة لتشفير سكربتات بايثون باستخدام خوارزميات تشفير عسكرية مثل AES وRSA.  
تمنع التحليل الهندسي والتجسس على الكود، وتدمر نفسها إذا تم اكتشاف أدوات مراقبة.  
أداة احترافية لحماية مشاريعك البرمجية.

---
human-short-code 1.0.2
Replace long, unreadable ids with short human-readable code ids
Requires Python: >=3.6

# Human Short Code

Encode integers into compact, human-readable codes and decode them reliably.  
Useful for generating invitation codes, referral links, tracking IDs, or session tokens.

## Features

- Encode numbers into fixed-length readable codes  
- Decode codes back to original numbers  
- Validate code format  
- Customizable alphabet and length  
- Mid-string hyphen for clarity  

## Installation

```bash
pip install human-short-code
```

Or install from source:

```bash
git clone https://github.com/yourusername/human-short-code.git
cd human-short-code
python -m build
pip install dist/*.whl
```

## Usage

```python
from human_short_code import encode, decode, verify

number = 123456789

# Encode number
code = encode(number)
print(code)  # e.g. 'QIUN-ESAD'

# Decode code
original = decode(code)
print(original)  # 123456789

# Verify code format
print(verify(code))  # True
```

## API

`encode(id_number: int, alphabet: str = ..., length: int = ...) -> str`

Convert an integer into a short, fixed-length alphanumeric code.

- id_number: Integer to encode
- alphabet: Optional custom alphabet (default: "ASDEIUNWRQXBOKH")
- length: Total code length excluding hyphen (default: 8)

Returns a code string with a hyphen inserted at the center.

`decode(code: str, alphabet: str = ..., length: int = ...) -> int`

Decode a code string back into the original integer.

- code: Code string to decode
- alphabet: Optional custom alphabet used in encoding
- length: Expected code length excluding hyphen

Raises ValueError if invalid input.

`verify(code: str, alphabet: str = ..., length: int = ...) -> bool`

Check if a code is valid for the given alphabet and length.

- code: Code string to verify
- alphabet: Optional alphabet to validate against
- length: Maximum code length excluding hyphen

Returns True if valid, False otherwise.

## Customization

```python
custom_alphabet = "ABCDEFGHJKLMNPQRSTUVWXYZ"
custom_length = 6

code = encode(987654, custom_alphabet, custom_length)
print(code)  # e.g. 'BAC-DEF'

number = decode(code, custom_alphabet, custom_length)
print(number)  # 987654
```

## Tests

```bash
pytest
```

## License

MIT