semvec/pypi-packages huggingface dataset:
mugo 0.1.1
Differentiable Combinatorial Optimization for Genomics
Requires Python: >=3.8

# MUGO: Multi-Head Genomic Optimization

[![PyPI version](https://img.shields.io/pypi/v/mugo.svg)](https://pypi.org/project/mugo/)
[![Documentation](https://img.shields.io/badge/docs-online-blue)](https://mugo-framework.netlify.app)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

**MUGO** is a differentiable combinatorial optimization framework designed for discovering causal variants in the non-coding genome. By leveraging **Gumbel-Softmax relaxation** and **Straight-Through Estimators (STE)**, MUGO enables end-to-end gradient-based optimization on discrete DNA sequences.

## Key Features

* 🧬 **Model-Agnostic**: Compatible with Borzoi, Enformer, HyenaDNA, and other PyTorch-based genomic models.
* 🎯 **Multi-Modal Objectives**: Optimize for Gene Expression, Chromatin Accessibility (ATAC), or TF Binding.
* 📉 **Variance Reduction**: Built-in Multi-Head Consensus strategy to filter stochastic noise.
* 🚀 **Production Ready**: Easy-to-use Python API for high-performance computing.

## Installation

```bash
pip install mugo
```

## Quick Start
```python
import torch
from mugo import MultiHeadSelector

# Initialize the optimizer
selector = MultiHeadSelector(num_snps=1000, snp_positions=positions, k=20)

# Optimization loop
for step in range(200):
    input_seq, mask, _ = selector(ref_seq, alt_seq, tau=1.0)
    # ... compute loss and backward ...
```

## Documentation
Comprehensive documentation, tutorials, and API references are available at: 👉 https://mugo-framework.netlify.app

## Citations
If you use MUGO in your research, please cite:
@software{mugo2026,
  author = {SciML Team},
  title = {MUGO: Differentiable Combinatorial Optimization for Genomics},
  year = {2026},
  url = {[https://github.com/anonymous/mugo](https://github.com/anonymous/mugo)}
}
openclassifier 0.1.0
Python SDK for OpenClassifier - Ultra fast classification API
Requires Python: >=3.8
Keywords: api, classification, image-classification, pdf-classification, sdk, text-classification

# OpenClassifier Python SDK

Python SDK for the OpenClassifier API - ultra fast classification for text, images, and PDFs.

## Installation

```bash
pip install openclassifier
```

## Quick Start

```python
from openclassifier import OpenClassifier

client = OpenClassifier(api_key="sk_live_...")

result = client.classify.text(
    "Hello, how can I help you today?",
    ["greeting", "question", "complaint"]
)
print(result["results"]["label"])  # "greeting"
print(result["results"]["confidence"])  # 0.95
```

## Usage

### Text Classification

```python
# Single label (default)
result = client.classify.text(
    content="I need help with my order",
    labels=["support", "sales", "billing"]
)

# Multi-label classification
result = client.classify.text(
    content="Great product but shipping was slow",
    labels=["positive", "negative", "shipping", "product"],
    multi_label=True
)
```

### Image Classification

```python
# From URL
result = client.classify.image(
    inputs=["https://example.com/photo.jpg"],
    labels=["cat", "dog", "bird"]
)

# From base64
result = client.classify.image(
    inputs=[{"base64": "...", "media_type": "image/jpeg"}],
    labels=["cat", "dog", "bird"],
    detail="high"  # "low", "high", or "auto"
)

# Multiple images
result = client.classify.image(
    inputs=[
        "https://example.com/photo1.jpg",
        "https://example.com/photo2.jpg"
    ],
    labels=["landscape", "portrait", "abstract"]
)
```

### PDF Classification

```python
# From URL
result = client.classify.pdf(
    input="https://example.com/document.pdf",
    labels=["invoice", "receipt", "contract"]
)

# With options
result = client.classify.pdf(
    input="https://example.com/document.pdf",
    labels=["invoice", "receipt", "contract"],
    aggregation="both",  # "per_page", "document", or "both"
    page_range={"start": 1, "end": 10}
)

print(result["document_label"]["label"])  # Overall classification
print(result["results"])  # Per-page results
```

## Configuration

```python
client = OpenClassifier(
    api_key="sk_live_...",  # Or set OPENCLASSIFIER_API_KEY env var
    base_url="https://api.openclassifier.com",  # Optional
    timeout=60.0  # Request timeout in seconds
)
```

## Error Handling

```python
from openclassifier import (
    OpenClassifier,
    AuthenticationError,
    InvalidRequestError,
    RateLimitError,
    InsufficientBalanceError,
    ClassificationError,
)

try:
    result = client.classify.text("Hello", ["a", "b"])
except AuthenticationError:
    print("Invalid API key")
except InvalidRequestError as e:
    print(f"Bad request: {e.message}")
except RateLimitError:
    print("Rate limit exceeded, retry later")
except InsufficientBalanceError:
    print("Add credits to your account")
except ClassificationError:
    print("Classification failed")
```

## License

Apache 2.0
tinytex 0.2.1
Lorem ipsum
Requires Python: >=3.8

![tinytex](https://raw.githubusercontent.com/Sam-Izdat/tinytex/main/doc/images/tinytex_sm.png)

* [Project site & docs](https://sam-izdat.github.io/tinytex/) 
* [PyPi](https://pypi.org/project/tinytex/)

# About

Python texture sampling, processing and synthesis library for PyTorch-involved projects.

This library is a hodgepodge of tangentially-related procedures useful for sampling, creating and 
modifying various kinds of textures. This is primarily intended for batched or unbatched 
PyTorch image tensors. This library provides:

- image resampling/rescaling, cropping and padding
- tiling

  - split images into tiles 
  - merge tiles back into images
  - seamlessly stitch textures with color or vector data for mutual tiling or self-tiling

- texture atlases

  - pack images into texture atlases
  - sample images from texture atlases
  - generate tiling masks from texture atlases

- computing and rendering 2D signed distance fields
- computing and approximating surface geometry 

  - normals to height
  - height to normals 
  - height/normals to curvature

- approximating ambient occlusion and bent normals
- blending multiple normal maps
- pseudo-random number generation
- generating tiling spatial-domain noise
- generating spectral-domain noise
- warping image coordinates
- transforming 1D and 2D images to and from Haar wavelet coefficients
- (experimental) backend-agnostic 1D/2D/3D textures for Taichi (if installed with Taichi optional dependency)
    
  - load from and save to the filesystem
  - convert textures to and from PyTorch tensors
  - sample textures with lower or higher-order interpolation/approximation


# Getting started

* Recommended: set up a clean Python environment
* [Install PyTorch  as instructed here](https://pytorch.org/get-started/locally/)
* Run  `pip install tinytex`
* Run  `ttex-setup`

[See the docs](https://sam-izdat.github.io/tinytex/) for the rest.