semvec/pypi-packages huggingface dataset:
jaxcld 0.1.0
CLD: language detection heads for ASR models
License: MIT
Requires Python: >=3.9

## jaxcld

`jaxcld` is a lightweight language-detection module for multilingual ASR models (Whisper / MMS). It provides an `ASRModel` wrapper plus pluggable language detection heads you can attach at inference time.

## Install

```bash
pip install jaxcld
```

If you are developing from source:

```bash
pip install -e .
```

## Using the package (minimal inference example)

```python
import numpy as np

from jaxcld import ASRModel, CVXNNLangDetectHead, NNLangDetectHead, SVMLangDetectHead

# 1) Load the base ASR model
languages = ["en", "hi", "id", "ms", "zh"]
asr = ASRModel.from_pretrained("openai/whisper-small", config={"languages": languages})

# 2) Load a language detection head artifact (choose ONE)
# head = CVXNNLangDetectHead.load("path/to/whisper-small_trained_cvx_mlp.pkl", asr)
# head = NNLangDetectHead.load("path/to/openai_whisper-small_nn_head.pkl", asr)
# head = SVMLangDetectHead.load("path/to/openai_whisper-small_linear_svm.pkl", asr)

# 3) Attach head and run inference
asr.set_lang_detect_head(head)

audio_16k_mono: np.ndarray = ...  # shape (T,), sampling rate 16kHz
pred_langs, pred_texts = asr.predict(audio_16k_mono)
print(pred_langs[0], pred_texts[0])
```

## Notes

- Head artifacts (`*.pkl`) are produced by training scripts in the source repository; this pip README intentionally focuses only on **package usage**.
balance-rxns 0.2.0
A Python package for balancing chemical equations and finding possible reactions
License: MIT
Requires Python: >=3.9
Keywords: balancing, chemical equations, chemistry, pymatgen, reactions

# balance-rxns

A Python package for balancing chemical equations and finding possible reactions.

[中文文档](README_zh.md)

## Installation

```bash
pip install balance-rxns
```

## Features

- Automatically balance chemical equations
- Find all possible reactions from given reactants and products
- Support for complex chemical formulas
- Accurate calculations based on sympy and pymatgen

## Usage

### Basic Usage

```python
from balance_rxns import balance_rxns

# Define reactants and products
reactants = ("Fe", "O2")
products = ("FeO", "Fe2O3", "Fe3O4")

# Find all possible balanced equations
results = balance_rxns(reactants, products)

# Print results
for equation, reactant_coeffs, product_coeffs in results:
    print(equation)
```

Output:
```
2Fe + O2 -> 2FeO
4Fe + 3O2 -> 2Fe2O3
3Fe + 2O2 -> Fe3O4
```

### Advanced Options

```python
# Limit the number of products
results = balance_rxns(
    reactants=["Cu", "Al2O3"],
    products=["CuAlO2"],
    max_products_in_equation=2,  # Maximum 2 products per equation
    require_all_reactants_used=True  # Require all reactants to be used
)

for equation, r_map, p_map in results:
    print(f"Equation: {equation}")
    print(f"Reactant coefficients: {r_map}")
    print(f"Product coefficients: {p_map}")
    print()
```

## Parameters

- `reactants`: List or tuple of reactant chemical formulas
- `products`: List or tuple of product chemical formulas
- `max_products_in_equation`: Maximum number of products in each equation (default: all)
- `require_all_reactants_used`: Whether all reactants must be used (default: True)

## Return Value

Returns a list where each element contains:
1. String representation of the balanced equation
2. Dictionary of reactants with their coefficients
3. Dictionary of products with their coefficients

## Dependencies

- pymatgen >= 2024.1.0
- sympy >= 1.12.0

## License

MIT License

## Contributing

Issues and Pull Requests are welcome!

## Changelog

### 0.1.0 (2026-01-30)
- Initial release
- Support for chemical equation balancing
AbstractDatabaseService 1.0.0
Abstract base class for domain-specific database services
License: MIT
Requires Python: >=3.9

# AbstractDatabaseService

Abstract base class for domain-specific database services. This package provides the foundation for building database services tailored to specific domains (Legal, Finance, etc.).

## Installation

```bash
# From git
pip install git+https://github.com/NlpFisTeam/AbstractDBService.git

# From local
pip install -e ./modules/AbstractDBService
```

## Usage

```python
from AbstractDBService import AbstractDBService, ProcessingResult

class LegalDocumentService(AbstractDBService):
    """Legal document database service."""
    
    def _init_connections(self, **kwargs):
        # Initialize legal-specific connections
        self.arango_connector = kwargs.get("arango_connector")
    
    def process_document(self, file_path, doc_id, metadata, **kwargs):
        # Legal-specific document processing
        pass
    
    # ... implement other abstract methods
```

## Abstract Methods

All inheriting classes must implement:

- `_init_connections(**kwargs)` - Initialize domain-specific connections
- `process_document(file_path, doc_id, metadata, **kwargs)` - Process a document
- `extract_metadata(document, raw_metadata)` - Extract domain-specific metadata
- `create_chunks(document, doc_id, metadata)` - Create chunks with domain-specific logic
- `embed_text(texts)` - Create embeddings
- `create(file_path, metadata, **kwargs)` - Create/ingest a new document
- `update(doc_id, updates, **kwargs)` - Update an existing document
- `delete(doc_id, **kwargs)` - Delete a document
- `init_databases(tenant_id)` - Initialize databases for a new tenant
- `cleanup_databases(tenant_id)` - Cleanup databases for a tenant
torq-client-sdk 0.0.1
Python SDK for Torq distributed GPU job queue (coming soon)
License: MIT
Requires Python: >=3.10
Keywords: client, distributed, gpu, inference, llm, sdk, torq

# Torq Client SDK

Python SDK for submitting jobs to Torq distributed GPU queue.

**Status: Coming Soon**

## Overview
Simple SDK to submit LLM inference jobs to Torq and retrieve results.

## Features (planned)
- Async/sync job submission
- Batch job support
- Priority queuing
- Result polling and callbacks
- Automatic retries

## Quick Start
```python
from torq_client import TorqClient

client = TorqClient("https://torq.muid.io")
job = client.submit(model="llama3", prompt="Hello!")
result = job.wait()
```

## Installation
```bash
pip install torq-client-sdk
```

## Links
- Main site: https://torq.muid.io
- Documentation: https://torq.muid.io/docs
torq-worker 0.0.1
GPU worker for Torq distributed job queue (coming soon)
License: MIT
Requires Python: >=3.10
Keywords: distributed, gpu, inference, llm, torq, worker

# Torq Worker

GPU worker component for Torq distributed job queue.

**Status: Coming Soon**

## Overview
Torq Worker runs on GPU machines and processes jobs from the Torq broker.

## Features (planned)
- Multiple LLM backend support (vLLM, SGLang, TGI)
- Auto-registration with broker
- Health monitoring and heartbeats
- Graceful shutdown and job recovery

## Installation
```bash
pip install torq-worker
```

## Links
- Main site: https://torq.muid.io
- Documentation: https://torq.muid.io/docs
torq 0.0.1
High-performance task queue for GPU workloads (coming soon)
License: MIT
Requires Python: >=3.10
Keywords: batch, distributed, gpu, inference, queue, task

# Torq

High-performance task queue for GPU workloads.

**Status: Coming Soon**

This package is under active development. Stay tuned!

## Features (planned)
- Lightweight task queue optimized for GPU jobs
- Redis-backed job persistence
- Worker auto-scaling
- Built-in monitoring and metrics
- Simple SDK for job submission

## Links
- GitHub: https://github.com/muid-io/torq
- Documentation: Coming soon
qubix 0.0.1
Distributed GPU job queue for LLM inference (coming soon)
License: MIT
Requires Python: >=3.10
Keywords: batch, distributed, gpu, inference, llm, queue

# Qubix

Distributed GPU job queue for LLM inference.

**Status: Coming Soon**

This package is under active development. Stay tuned!

## Features (planned)
- Distributed job queue with Redis backend
- GPU worker management
- Support for multiple LLM backends (vLLM, SGLang, TGI)
- Priority-based job scheduling
- Automatic retries and fault tolerance

## Links
- GitHub: https://github.com/muid-io/qubix
- Documentation: Coming soon