semvec/pypi-packages huggingface dataset:
hanzo-tools-fs 0.3.1
Filesystem tools for Hanzo AI - read, write, edit, search, find
License: MIT
Requires Python: >=3.12
Keywords: hanzo, tools, filesystem, mcp, ai

# hanzo-tools-fs

Filesystem tools for Hanzo MCP.

## Installation

```bash
pip install hanzo-tools-fs
```

## Tools

### read - Read Files
```python
read(file_path="/path/to/file.py")
read(file_path="/path/to/file.py", offset=100, limit=50)
```

### write - Write Files
```python
write(file_path="/path/to/file.py", content="...")
```

### edit - Edit Files
```python
edit(
    file_path="/path/to/file.py",
    old_string="def old():",
    new_string="def new():"
)
```

### tree - Directory Structure
```python
tree(path="/project", depth=3)
```

### find - File Discovery
```python
find(pattern="*.py", path="/project")
```

### search - Content Search
```python
search(pattern="TODO|FIXME", path="./src")
```

### ast - Code Structure
```python
ast(pattern="class.*Service", path="/src")
```

## License

MIT
biostrings 0.0.2
Efficient manipulation of genomic sequences
License: MIT
Requires Python: >=3.9

[![PyPI-Server](https://img.shields.io/pypi/v/biostrings.svg)](https://pypi.org/project/biostrings/)
![Unit tests](https://github.com/biocpy/biostrings/actions/workflows/run-tests.yml/badge.svg)

# biostrings

Efficient manipulation of genomic sequences in Python, inspired by the design of Bioconductor's [Biostrings](https://bioconductor.org/packages/Biostrings) package.

The core design relies on a **"pool and ranges"** memory model:

- **DNAStringSet** stores all sequences in a single contiguous block of memory (the pool).
- Individual sequences are defined by `start` and `width` coordinates (the ranges).
- Slicing a `DNAStringSet` returns a **view** (a new set of ranges pointing to the same pool), making subsetting operations virtually instantaneous and memory-free, regardless of the data size.

## Install

To get started, install the package from [PyPI](https://pypi.org/project/biostrings/)

```bash
pip install biostrings
```

## Quick Start

### Working with Single Sequences

The `DNAString` class represents a single DNA sequence. It enforces the IUPAC DNA alphabet and supports efficient byte-level operations.

```py
from biostrings import DNAString

# Create a DNA string
dna = DnaString("TTGAAAA-CTC-N")
print(dna)
# Output: TTGAAAA-CTC-N

# Basic operations
print(len(dna))            # 13
print(dna[0:3])            # DnaString(length=3, sequence='TTG')

# Reverse Complement
# Handles IUPAC ambiguity codes correctly (e.g., N -> N, M -> K)
rc = dna.reverse_complement()
print(rc)
# Output: N-GAG-TTTTCAA
```

### Working with Sets of Sequences

The `DNAStringSet` is the primary container for handling collections of sequences (e.g., reads from a FASTA file).

```py
from biostrings import DNAStringSet

# Efficiently create a set from a list of strings
seqs = [
    "ACGT",
    "GATTACA",
    "TTGAAAA-CTC-N",
    "ACGTACGT"
]
dss = DNAStringSet(seqs, names=["s1", "s2", "s3", "s4"])

print(dss)
# Output:
# <DNAStringSet of length 4>
#   [ 1]   4 ACGT                 s1
#   [ 2]   7 GATTACA              s2
#   [ 3]  13 TTGAAAA-CTC-N        s3
#   [ 4]   8 ACGTACGT             s4
```

<!-- biocsetup-notes -->

## Note

This project has been set up using [BiocSetup](https://github.com/biocpy/biocsetup)
and [PyScaffold](https://pyscaffold.org/).
metaleig 0.0.4
GPU-Accelerated Eigendecomposition on Apple Metal for PyTorch
License: MIT
Requires Python: >=3.9

# metaleig

GPU-Accelerated Eigendecomposition on Apple Metal for PyTorch.

## Installation

```bash
pip install metaleig
```

**Requirements:**
- macOS with Apple Silicon (M1/M2/M3/M4)
- Python 3.9+
- PyTorch 2.0+ with MPS backend

## Usage

```python
import torch
import metaleig

# Create a symmetric matrix on MPS
A = torch.randn(64, 128, 128, device='mps')
A = A + A.transpose(-2, -1)  # Make symmetric

# Compute eigenvalues and eigenvectors
eigenvalues, eigenvectors = metaleig.eigh(A)

# Or just eigenvalues
eigenvalues = metaleig.eigvalsh(A)
```

## Performance

metaleig provides significant speedups for **batched small matrices**:

| Size | Batch | Speedup vs CPU |
|------|-------|----------------|
| 64×64 | 64 | **2.6x** |
| 128×128 | 64 | **2.3x** |

For single matrices and larger sizes, metaleig automatically uses CPU (which is faster due to optimized LAPACK Divide & Conquer).

### Strategy Selection

```python
# Auto-select best strategy (default)
L, V = metaleig.eigh(A, strategy='auto')

# Force specific strategy
L, V = metaleig.eigh(A, strategy='jacobi')   # Metal Jacobi kernels
L, V = metaleig.eigh(A, strategy='cpu')      # CPU fallback
L, V = metaleig.eigh(A, strategy='tridiag')  # Tridiagonalization (experimental)
```

**Auto-selection logic:**
- Batched, N ≤ 128: Uses Jacobi (2-3x speedup)
- Otherwise: Uses CPU (faster for single/large matrices)

## API

### `metaleig.eigh(A, strategy='auto')`
Computes eigenvalues and eigenvectors of a symmetric matrix.

**Args:**
- `A`: Symmetric tensor of shape `(..., N, N)`
- `strategy`: Algorithm selection ('auto', 'jacobi', 'cpu', 'tridiag')

**Returns:**
- `eigenvalues`: Tensor of shape `(..., N)` in ascending order
- `eigenvectors`: Tensor of shape `(..., N, N)`

### `metaleig.eigvalsh(A, strategy='auto')`
Computes only eigenvalues (may be faster for some strategies).

## License

MIT License