semvec/pypi-packages huggingface dataset:
hunyuan-3d 0.1.0
Hunyuan 3D - AI-powered 3D model generation platform by Tencent
License: MIT
Requires Python: >=3.9
Keywords: 3d-generation, ai, generative-ai, hunyuan, hunyuan-3d, tencent, text-to-3d

# Hunyuan 3D

AI-powered 3D model generation platform by Tencent.

## Official Website

Visit: [https://hunyuan-3d.org](https://hunyuan-3d.org)

## Installation

```bash
pip install hunyuan-3d
```

## Usage

```python
from hunyuan_3d import get_info, get_platform_url

info = get_info()
print(info)

url = get_platform_url()
print(url)  # https://hunyuan-3d.org
```

## Links

- Website: [https://hunyuan-3d.org](https://hunyuan-3d.org)
- PyPI: [https://pypi.org/project/hunyuan-3d/](https://pypi.org/project/hunyuan-3d/)

## License

MIT License
gitglasses 0.3.0
Visualize git branch relationships in a commit range
License: MIT
Requires Python: >=3.9

# GitGlasses

Visualize git branch relationships in a commit range.

## Installation

```bash
uv sync
```

## Usage

```bash
gitglasses [--from <ref>] [--to <ref>]
```

- `--from`: Starting commit or branch (defaults to current HEAD)
- `--to`: Target branch or commit (defaults to "main")

### Examples

```bash
# Show branches from current HEAD to main (using defaults)
gitglasses

# Explicitly specify from HEAD to main
gitglasses --from HEAD --to main

# Show branches in last 5 commits
gitglasses --from HEAD --to HEAD~5

# Show branches from feature-a to main
gitglasses --from feature-a --to main
```

## Output

GitGlasses displays branches as an ASCII tree with box-drawing characters:

```
main
├── branch-a (a1b2c3d, e4f5g6h)
│   └── branch-b (i7j8k9l)
└── branch-c (m1n2o3p)
```

Each branch shows the abbreviated commit hashes of commits in the specified range.
cronspeak 0.1.0
Translate between human-readable schedules and cron expressions
License: MIT
Requires Python: >=3.8
Keywords: cron, crontab, scheduler, cli, automation

# cronspeak

Translate between human-readable schedules and cron expressions. Both directions.

```bash
pip install cronspeak
```

## Usage

### Human → Cron

```bash
$ cronspeak to-cron "every 5 minutes"
*/5 * * * *

$ cronspeak to-cron "every day at 3pm"
0 15 * * *

$ cronspeak to-cron "every monday at 9am"
0 9 * * 1

$ cronspeak to-cron "every weekday at 8:30am"
30 8 * * 1-5
```

### Cron → Human

```bash
$ cronspeak explain "*/5 * * * *"
Every 5 minutes

$ cronspeak explain "0 15 * * *"
Every day at 3:00 PM

$ cronspeak explain "30 8 * * 1-5"
Every weekday at 8:30 AM
```

### Next Run Times

```bash
$ cronspeak next "*/15 * * * *"
Schedule: Every 15 minutes

Next 5 runs:
  2026-02-03 00:15:00 (Tuesday)
  2026-02-03 00:30:00 (Tuesday)
  2026-02-03 00:45:00 (Tuesday)
  2026-02-03 01:00:00 (Tuesday)
  2026-02-03 01:15:00 (Tuesday)
```

### JSON Output

All commands support `--json` for machine-readable output:

```bash
$ cronspeak to-cron "every tuesday at 3pm" --json --show-next 3
{
  "input": "every tuesday at 3pm",
  "cron": "0 15 * * 2",
  "explanation": "Every Tuesday at 3:00 PM",
  "next_runs": [
    "2026-02-03T15:00:00",
    "2026-02-10T15:00:00",
    "2026-02-17T15:00:00"
  ]
}
```

### Interactive Mode

```bash
$ cronspeak interactive
Cronspeak interactive mode
Enter a schedule ('every 5 minutes') or cron expression ('*/5 * * * *')
Type 'quit' to exit

> every hour
  → 0 * * * *
  Next: 2026-02-03 01:00

> 0 9 * * 1-5
  → Every weekday at 9:00 AM
  Next: 2026-02-03 09:00
```

## Supported Patterns

### Human Input

| Pattern | Example | Cron |
|---------|---------|------|
| Every N minutes | `every 5 minutes` | `*/5 * * * *` |
| Every hour | `every hour` | `0 * * * *` |
| Every N hours | `every 2 hours` | `0 */2 * * *` |
| Every day at time | `every day at 3pm` | `0 15 * * *` |
| At time | `at 9:30am` | `30 9 * * *` |
| Every weekday | `every monday` | `0 0 * * 1` |
| Weekday at time | `every friday at 5pm` | `0 17 * * 5` |
| Weekdays | `every weekday at 9am` | `0 9 * * 1-5` |
| Weekends | `every weekend at 10am` | `0 10 * * 0,6` |
| Monthly | `every month on the 1st` | `0 0 1 * *` |
| Shortcuts | `noon`, `midnight` | `0 12 * * *`, `0 0 * * *` |

### Cron Input

Standard 5-field cron expressions are supported:

```
┌───────────── minute (0-59)
│ ┌───────────── hour (0-23)
│ │ ┌───────────── day of month (1-31)
│ │ │ ┌───────────── month (1-12)
│ │ │ │ ┌───────────── day of week (0-6, 0=Sunday)
│ │ │ │ │
* * * * *
```

## Python API

```python
from cronspeak import parse_human, explain_cron, get_next_runs

# Human → Cron
expr = parse_human("every day at 3pm")
print(expr)  # "0 15 * * *"

# Cron → Human
explanation = explain_cron("0 15 * * *")
print(explanation)  # "Every day at 3:00 PM"

# Next runs
from datetime import datetime
runs = get_next_runs("*/5 * * * *", count=3)
for run in runs:
    print(run)
```

## For AI Agents

See [SKILL.md](SKILL.md) for agent-optimized documentation with command patterns and JSON output specs.

## License

MIT
engram-db 0.1.0
High-performance memory database for LLMs
License: MIT
Requires Python: >=3.8

# 🧠 Engram: Fast, Local-First Memory for LLMs

Engram is a high-performance, local-first memory database designed specifically for AI agents and RAG (Retrieval-Augmented Generation) applications. It is built in Rust for speed and provides native Python bindings for ease of use.

**Zero Config. Zero API Keys. Zero Latency.**

## ✨ Features

- **🚀 Blazing Fast**: Core engine written in Rust with HNSW indexing for sub-10ms retrieval.
- **🔒 Privacy First**: Everything stays on your machine. No data is sent to external embedding providers.
- **📦 All-in-One**: Integrated vector storage, metadata management, and local embeddings (via FastEmbed).
- **🔋 Battery Included**: Auto-downloads and manages optimized ONNX embedding models locally.

## 🛠️ Installation

```bash
# Clone the repository
git clone https://github.com/yourusername/engram
cd engram

### Python
```bash
pip install maturin
maturin develop --features python
```

### Node.js
```bash
npx napi build --release --features node
```

## 📖 Quick Start (RAG in 30 Seconds)

```python
import engram

# 1. Initialize the database (Saves to a local folder)
db = engram.EngramDB("./my_knowledge_base")

# 2. Store documents with metadata
db.store(
    "Engram is a memory database written in Rust.", 
    {"source": "docs", "priority": "high"}
)

# 3. Recall based on semantic meaning
results = db.recall("How is Engram built?", limit=1)

for content, metadata in results:
    print(f"Retrieved: {content}")
    print(f"Metadata: {metadata}")
```

## 🏗️ Architecture

Engram uses a custom binary storage engine called **Mnemo** combined with **HNSW** (Hierarchical Navigable Small World) for ultra-fast vector search.

1. **Mnemo Engine**: A low-level, append-only binary log that ensures your data is persisted safely to disk.
2. **HNSW Index**: An in-memory graph structure rebuilt from disk on startup for lightning-fast nearest neighbor search.
3. **Local Embeddings**: Uses `fastembed-rs` to run optimized ONNX models like `all-MiniLM-L6-v2` locally on your CPU/GPU.

## 🤝 Contributing

We welcome contributions! Please feel free to submit a Pull Request.

## 📄 License

MIT License. See [LICENSE](LICENSE) for details.