semvec/pypi-packages huggingface dataset:
MotifQu 1.0.1
Quantum motif search and discovery using Grover's algorithm over genomic FASTA sequences.
License: MIT
Requires Python: >=3.9
Keywords: bioinformatics, motif, grover, qiskit, quantum, discovery, k-mer

# MotifQu

MotifQu is a quantum motif search and discovery tool using Grover's algorithm. It provides two main functions:

1. **Motif Search**: Find occurrences of a known motif pattern in a genome
2. **Motif Discovery**: Discover all significant motifs (k-mers) in a genome using quantum amplitude amplification

## Install

```bash
pip install MotifQu
```

## Usage

### Discover Motifs (New!)

Find all significant k-mers in a genome:

```bash
# Discover 6-mers appearing at least 3 times
motifqu discover --fasta genome.fa -k 6 --min-count 3

# Discover 8-mers, show top 20 results
motifqu discover --fasta genome.fa -k 8 --min-count 2 --topk 20

# Ignore reverse complement
motifqu discover --fasta genome.fa -k 6 --min-count 3 --no-revcomp
```

### Search for Specific Motif

```bash
# Exact match
motifqu search --fasta genome.fa --motif GTTGTTGGAGAAG --mismatches 0

# Allow 1 mismatch
motifqu search --fasta genome.fa --motif TATAAA --mismatches 1
```

### List Known Biological Motifs

```bash
motifqu list-motifs
```

### Expand IUPAC Pattern

```bash
# Expand E-box pattern (CANNTG)
motifqu expand CANNTG
```

## Coordinate Output

MotifQu prints both:

- 1-based inclusive coordinates: contig:start-end
- 0-based half-open interval: [start,end)

These coordinates are relative to the FASTA sequence provided.

## Biological Context

The quantum motif discovery tool is designed for:

- **Transcription Factor Binding Sites (TFBS)** - identifying regulatory sequences
- **Repeat elements** - finding tandem repeats and microsatellites
- **Conserved sequences** - detecting evolutionarily preserved patterns

The algorithm uses Grover's search to amplify the probability of significant k-mers (those appearing >= threshold times), providing a quadratic speedup over classical enumeration for the 4^k k-mer search space.

## Notes

- For discovery, k-mer lengths 4-10bp are recommended (4^k states require 2k qubits)
- The oracle is built from classical pre-computation of k-mer counts
- Reverse complement is counted as the same motif by default (biological DNA is double-stranded)
remembers 0.1.0
A blazing-fast, async-friendly, thread-safe caching decorator for Python that just works. Drop it on any function and watch it remember results like magic.
License: MIT
Requires Python: >=3.12
Keywords: cache, caching, lru, decorator, async, thread-safe, persistent, ttl, memoization

# 🥜 remembers

**Remember everything. Forget nothing (until you want to).**

A blazing-fast, async-friendly, thread-safe caching decorator for Python that just works. Drop it on any function and watch it remember results like magic.

## ✨ Features

- 🎯 **One decorator, zero config** - Just `@remember()` and you're done
- ⚡ **Async/await ready** - Works seamlessly with sync and async functions
- 🔒 **Thread-safe** - Battle-tested for concurrent access
- 💾 **Optional persistence** - Cache survives restarts with disk storage
- ⏱️ **TTL support** - Auto-expire entries when you want
- 🎨 **Smart key building** - Cache by specific args or nested paths
- 📊 **Built-in stats** - Track hits, misses, and hit rates

## Quick Start

```python
from remembers import remember

@remember(maxsize=128, ttl_seconds=300)
def expensive_api_call(user_id: int):
    # This only runs once per user_id (for 5 minutes)
    return fetch_user_data(user_id)

# Works with async too!
@remember(maxsize=64)
async def fetch_weather(city: str):
    return await weather_api.get(city)
```

## Advanced Usage

### Custom Cache Keys

```python
@remember(key_args=['user.id', 'config.api_key'])
def process_user(user, config):
    # Only caches based on user.id and config.api_key
    return expensive_processing(user, config)
```

### Persistent Cache

```python
@remember(maxsize=100, persist=True, cache_dir=".cache")
def expensive_computation(x: int):
    # Results survive restarts!
    return heavy_calculation(x)
```

### Check Cache Stats

```python
@remember(maxsize=50)
def my_function(arg):
    return process(arg)

my_function("test")
info = my_function.cache_info()
print(f"Hit rate: {info['hit_rate']:.2%}")
# Hit rate: 85.00%
```

## Installation

```bash
pip install remembers
```

## Requirements

- Python 3.12+

## License

MIT