semvec/pypi-packages huggingface dataset:
omg-beyler 1.0.0
Kolay kullanımlı OMG Python kütüphanesi, WAV dosyalarını oynatma ve örnekler içerir.
Requires Python: >=3.7

# OMG

OMG, kolay kullanımlı bir Python kütüphanesidir.  
WAV dosyalarını oynatma, toplama fonksiyonları ve örnekler içerir.

## Kurulum

```bash
pip install omg
tabulardelta 1.1.1
Simplify table comparisons.
Requires Python: >=3.11

# TabularDelta

[![CI](https://img.shields.io/github/actions/workflow/status/quantco/tabulardelta/ci.yml?style=flat-square&branch=main)](https://github.com/quantco/tabulardelta/actions/workflows/ci.yml)
[![Documentation](https://img.shields.io/badge/docs-latest-success?branch=main&style=flat-square)](https://tabulardelta.readthedocs.io/en/latest/)
[![pypi-version](https://img.shields.io/pypi/v/tabulardelta.svg?logo=pypi&logoColor=white&style=flat-square)](https://pypi.org/project/tabulardelta)
[![python-version](https://img.shields.io/pypi/pyversions/tabulardelta?logoColor=white&logo=python&style=flat-square)](https://pypi.org/project/tabulardelta)

TabularDelta helps to automate and simplify the often tedious and manual process of comparing relational data.

The so-called TabularDelta protocol defines a representation of the differences between two tables.
"Comparators" are used to generate such a representation from two table objects. The exchangeability of the comparators allows for varying table input formats like SQL tables or Pandas DataFrames.
"Formatters" allow to present the differences in different output formats depending on the desired usecase.
The flexibility in the output format allows to find small deviations in largely similar tables or provide an overview of more structural changes.

## Usage example

This snippet will report the differences of two CSV files.
You can execute it directly in [test_docs_examples.py](tests/test_docs_examples.py).

```python
import pandas as pd
from tabulardelta import PandasComparator, DetailedTextFormatter

df_old = pd.read_csv("week24.csv", index_col=[0, 1])
df_new = pd.read_csv("week25.csv", index_col=[0, 1])

delta = PandasComparator().compare(df_old, df_new)
print(DetailedTextFormatter().format(delta))
```

To compare two tables, first select a comparator that supports the table format. Now select any formatter that best suits your use case to obtain a visualization of the result.

To find more examples and get started, please visit the [documentation](https://tabulardelta.readthedocs.io/en/latest/).

## Development

This project is managed by [pixi](https://pixi.sh).
You can install the package in development mode using:

```bash
git clone https://github.com/quantco/tabulardelta
cd tabulardelta

pixi run pre-commit-install
pixi run postinstall
```

## Testing

- Make sure docker is installed
- Make sure `ODBC Driver 17 for SQL Server` is installed
  - See [Download ODBC Driver for SQL Server](https://learn.microsoft.com/en-us/sql/connect/odbc/download-odbc-driver-for-sql-server?view=sql-server-ver16)
  - This may require setting the `ODBCSYSINI` environment variable to the path of msodbcsql17
- Run `pixi run test`

Setting up the MsSql docker container may take a while, but it will be cached for future runs as long as you keep it running.
drim2p 1.0.1
A dreamy 2-photon imaging processing pipeline.
Requires Python: >=3.12
Keywords: 2-photon, imaging, neuroscience, processing, two-photon

# drim2p

[![PyPI - Version](https://img.shields.io/pypi/v/drim2p.svg)](https://pypi.org/project/drim2p)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/drim2p.svg)](https://pypi.org/project/drim2p)

A dreamy 2-photon imaging processing pipeline.

-----

## Table of Contents

- [Installation](#installation)
- [License](#license)

## Installation

The recommended way to install `drim2p` is using [`pipx`](https://pipx.pypa.io/latest/installation/):

```console
pipx install drim2p
```

## License

`drim2p` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.
whisperx-nemo-pipeline 1.0.7
Production-ready transcription and diarization pipeline with parallel processing
Requires Python: >=3.8

# WhisperX-NeMo Pipeline

A production-ready transcription and diarization pipeline with parallel processing.

## Features

- **Parallel Processing**: Runs Whisper transcription and NeMo diarization simultaneously
- **Multiple Backends**: Supports both faster-whisper and WhisperX
- **Speaker Diarization**: Uses NeMo MSDD models for accurate speaker identification
- **Audio Source Separation**: Optional vocal extraction using Demucs
- **Punctuation Restoration**: Automatic punctuation using deep learning models
- **Memory Efficient**: Proper GPU memory management and cleanup

## Installation

```bash
pip install whisperx-nemo-pipeline
```

**With constraints (recommended for production):**
```bash
pip install whisperx-nemo-pipeline -c constraints.txt
```

## Quick Start

```python
from whisperx_nemo_pipeline import create_transcription_pipeline

# Create pipeline
pipeline = create_transcription_pipeline(
    audio_path="path/to/your/audio.wav",
    model_name="large-v2",
    device="cuda",  # or "cpu"
    stemming=True,  # Enable source separation
    backend="faster_whisper"  # or "whisperx"
)

# Process audio
transcript_path, srt_path, timing_info = pipeline.process()

print(f"Transcript saved to: {transcript_path}")
print(f"Subtitles saved to: {srt_path}")
print(f"Processing took: {timing_info['total_time']:.2f}s")
```

## Advanced Usage

```python
from whisperx_nemo_pipeline import TranscriptionPipeline, TranscriptionConfig

# Custom configuration
config = TranscriptionConfig(
    audio_path="path/to/audio.wav",
    model_name="large-v2",
    device="cuda",
    batch_size=8,
    language="en",  # or None for auto-detection
    stemming=True,
    suppress_numerals=False,
    backend="faster_whisper"
)

# Create pipeline with custom config
pipeline = TranscriptionPipeline(config)

# Process
transcript_path, srt_path, timing_info = pipeline.process()
```

## Configuration Options

- `audio_path`: Path to input audio file
- `model_name`: Whisper model size ("tiny", "base", "small", "medium", "large-v2")
- `device`: Computing device ("cuda" or "cpu")
- `batch_size`: Batch size for inference (default: 4)
- `language`: Language code or None for auto-detection
- `stemming`: Enable audio source separation (default: True)
- `suppress_numerals`: Suppress numerical tokens (default: False)
- `backend`: "faster_whisper" or "whisperx"

## Requirements

- Python 3.8+
- CUDA-capable GPU (recommended)
- See `requirements.txt` for full dependency list

## License

MIT License
bagsy 0.5.1
A cli tool to help in the creation, conversion and sharing of rosbags
Requires Python: >=3.10

# bagSy

bagSy (pronounced [`[bagzi]`](https://en.wikipedia.org/wiki/International_Phonetic_Alphabet)) is a python cli tool to
help in the creation, conversion and sharing of rosbags.

It was created and is maintained by the SyRRo team at
the [U2IS Laboratory (ENSTA, Paris campus)](http://u2is.ensta-paris.fr/).

## Installation

It is recommended to use [pipx](https://github.com/pypa/pipx). With pipx, to install do `pipx install bagsy`.

Otherwise, you can install it in a python virtual environment.

## Usage

- `bagsy info [PATH ...]` (alias: `bag-info`): Same as rosbag info without requiring installing ros on the system.
- `bagsy convert PATH [-t topic_name ...] [-o output_folder]` (alias: `bag-convert`): Convert rosbag to csv or raw
  files depending on the message type.

## Contributions

Contributions are welcomed, consider submitting issues and/or merge requests.

## License

See [LICENSE](LICENSE)
pyshield-secure 0.2.0
A Python library to securely handle sensitive in-memory variables with authorized access controls.
Requires Python: >=3.7

# PyShield

PyShield is a professional Python library designed to securely handle sensitive in-memory variables such as passwords, tokens, API keys, and payment data. It wraps these values in protected objects that prevent accidental exposure during printing, logging, or debugging, while providing controlled access through authorization mechanisms.

## Features

- **Masking**: Displays a mask (e.g., "*****") instead of the real value in `print()`, `str()`, or `repr()`.
- **Authorized Access**: Enforces checks via passkey, custom callbacks, access limits, expiration, environment verification, and caller inspection.
- **Secure Deletion**: Wipes the value from memory to prevent further access.
- **Access Logging**: Logs all access attempts for auditing.
- **Thread-Safety**: Safe for use in multi-threaded environments.
- **Optional Encryption**: Simple in-memory XOR encryption for added protection.
- **Python 3.7+ Support**: Compatible with modern Python versions.

## Installation

Install via PyPI:pip install pyshield


## Usage

### Basic Usage

```python
from pyshield import ShieldedVar, AccessDeniedError

# Create a shielded variable with passkey authorization
secret = ShieldedVar("top_secret", passkey="my123")

print(secret)  # Outputs: *****
print(repr(secret))  # Outputs: <ShieldedVar: *****>

# Access with correct passkey
value = secret.get(passkey="my123")  # Returns: "top_secret"

# Access with wrong passkey
try:
    secret.get(passkey="wrong")
except AccessDeniedError:
    print("Access denied")

# Using callback authorization
def check_auth():
    # Dynamic logic, e.g., check user permissions
    return True

secret2 = ShieldedVar("another_secret", authorize=check_auth)
value2 = secret2.get()  # Returns value if check_auth() is True

# Return None on failure instead of raising
value_fail = secret.get(passkey="wrong", raise_on_fail=False)  # Returns: None
buvar-aiohttp 0.5.3
aiohttp plugin for buvar
Requires Python: >=3.11

buvar_aiohttp
=============

Solves some boilerplate around starting an `aiohttp`_ server.

.. code-block:: python

    import aiohttp.web
    from buvar import context, di, fork, plugin

    from buvar_aiohttp import AioHttpConfig


    async def hello(request):
        return aiohttp.web.Response(body=b"Hello, world")


    async def prepare_aiohttp(load: plugin.Loader):
        # provide config
        context.add(AioHttpConfig(host="0.0.0.0", port=5678))

        # prepare server site
        await load("buvar_aiohttp")

        # mount routes
        app = await di.nject(aiohttp.web.Application)
        app.router.add_route("GET", "/", hello)


    # start a process for each available CPU and provide a shared socket to all
    # children
    fork.stage(prepare_aiohttp, forks=0, sockets=["tcp://:5678"])


.. _aiohttp: https://docs.aiohttp.org
nt-telegram-bot 0.1.0
A simple pyton telegram libary
Requires Python: >=3.9

# nt-telegram-bot

Oddiy va minimal telegram bot uchun Python + requests asosidagi kutubxona.

```python
from telegram.updater import Updater
from telegram.handlers import MessageHandler
from telegram.types import Update
from config import TOKEN
```

`nt-telegram-bot` sizga hech qanday qo‘shimcha murakkabliksiz, tozalangan interfeys orqali Telegram bot yaratish imkonini beradi.

## ⚙️ O‘rnatish

```bash
pip install nt-telegram-bot
```

## 🚀 Boshlang‘ich foydalanish

Quyidagi kod namunasi orqali botni ishga tushiring:

```python
from telegram.updater import Updater
from telegram.handlers import MessageHandler
from telegram.types import Update
from config import TOKEN


def handle_message(update: Update):
    message = update.message

    if message.text:
        if message.text == '/start':
            message.reply_text(
                TOKEN,
                "assalomu alaykum. ECHO BOT"
            )
        else:
            message.reply_text(TOKEN, message.text)
    elif message.contact:
        pass
    elif message.photo:
        pass
    elif message.sickter:
        pass


updater = Updater(TOKEN)
dispatcher = updater.dispatcher

dispatcher.add_handler(MessageHandler(handle_message))
updater.start_polling()
```

## 📌 Xususiyatlar

* `Updater` yordamida soddalashtirilgan polling
* `MessageHandler` orqali barcha turdagi xabarlarni tutib olish
* `Update` obyektiga qulay kirish

## 📣 Hissa qo‘shish

Pull request’lar mamnuniyat bilan qabul qilinadi.
Agar xatolik topsangiz — Issue qoldiring.

## 📄 Litsenziya

MIT