semvec/pypi-packages huggingface dataset:
ynab-utils 1.1.0
A collection of command line utilities for YNAB (You Need a Budget) users.
Requires Python: >=3.12
Keywords: budgeting, cli, duplicate-detection, finance, ynab

# ynab-utils

A collection of command line utilities for YNAB (You Need a Budget) users.

## Installation

```bash
# Install from PyPI
pip install ynab-utils

# Or install with uv
uv tool install ynab-utils
```

## Quick Start

```bash
# Install uv (Python package manager)
curl -LsSf https://astral.sh/uv/install.sh | sh

# Clone and run
git clone <repo-url>
cd ynab-utils
uv run ynab-utils --help
```

## Commands

### detect-dupes

Find potential duplicate transactions in your YNAB export.

```bash
# Basic usage - finds exact duplicates on same date
ynab-utils detect-dupes --file transactions.csv

# Show all confidence levels (1=loosest, 5=strictest)
ynab-utils detect-dupes --file transactions.csv --confidence 1

# Only check recent transactions
ynab-utils detect-dupes --file transactions.csv --start-date 2025-01-01

# Adjust date matching window (default: 2 days)
ynab-utils detect-dupes --file transactions.csv --days 5

# Output as JSON
ynab-utils detect-dupes --file transactions.csv --output json
```

**Confidence levels:**
- 5: Same date, same amount, exact payee match
- 4: Same date, same amount, similar payee names
- 3: Within date window, same amount, exact/similar payee
- 2: Within date window, same amount, similar payee
- 1: Within date window, same amount only

## Development

```bash
# Clone the repository
git clone https://github.com/davekonopka/ynab-utils.git
cd ynab-utils

# Install dev dependencies (includes pre-commit)
uv sync --extra dev

# Set up pre-commit hooks
uv run pre-commit install
uv run pre-commit install --hook-type commit-msg

# Run the CLI during development
uv run ynab-utils --help

# Run tests
uv run pytest

# Run tests with coverage
uv run pytest --cov=ynab_utils

# Lint code
uv run ruff check src/

# Format code
uv run ruff format src/

# Run pre-commit checks manually
uv run pre-commit run --all-files
```

**Git Commits:** This project uses [Conventional Commits](https://www.conventionalcommits.org/). Examples:
- `feat(detect-dupes): add --start-date filter`
- `fix(cli): correct argument parsing for --output`
- `test: add integration tests for date filtering`

## Publishing

```bash
# Build distribution packages
uv build

# Upload to PyPI (requires PyPI token)
uv publish
```
signet-ai 0.1.0
Cryptographic state enforcement for AI Agents.
Requires Python: >=3.9

# 🔐 Signet (signet-ai)
**Cryptographic State Enforcement for AI Agents.**

[![PyPI version](https://img.shields.io/pypi/v/signet-ai.svg)](https://pypi.org/project/signet-ai/)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

**Problem:** LLMs are probabilistic. They hallucinate.
**Solution:** Signet is deterministic. It forces your agent to adhere to a strict Cryptographic State Machine.

If your agent tries to output a state that violates your business logic (e.g., refunding > $100) or your process graph (e.g., skipping "Approval"), Signet **blocks it** and auto-corrects the LLM.

## 🚀 Features

* **Graph Enforcement:** Define valid transitions (START -> ANALYZING -> APPROVED). Signet blocks illegal jumps.
* **Self-Healing Middleware:** Automatically retries LLM calls with error feedback when hallucinations occur.
* **Tamper-Proof Logs:** Every state transition is cryptographically signed (Ed25519).
* **Visual Debugger:** Includes a local Streamlit dashboard to visualize your agent's logic.

## 📦 Installation

```bash
pip install signet-ai
```

## ⚡ Quick Start

### 1. Define your Logic
```python
from signet import AgentState, StateMachineGuard, StateStatus
from pydantic import Field
from typing import Dict

class RefundState(AgentState):
    # Enforce strict types on your data
    data: Dict[str, int] = Field(..., description="Must contain 'amount'")

# Define valid moves
REFUND_GRAPH = {
    "START": ["ANALYZING"],
    "ANALYZING": ["APPROVED", "DENIED"],
    "APPROVED": [],
    "DENIED": []
}
```

### 2. Wrap your LLM (Self-Healing)
```python
from signet.middleware import SignetClient
import openai

guard = StateMachineGuard(RefundState, REFUND_GRAPH)
client = SignetClient(openai.Client(), guard)

# Run the agent
# If the LLM tries to skip steps or output bad JSON, 
# Signet catches it, feeds the error back, and retries automatically.
final_state = client.run(
    messages=[{"role": "user", "content": "Process a refund for $50"}],
    model="gpt-4"
)

print(f"Signed: {final_state.signature}")
```

## 📊 Visual Debugger
Signet comes with a built-in dashboard to test your graph logic.

1. Create a file `viz.py` (see examples folder).
2. Run:
```bash
streamlit run viz.py
```

## 🛡️ The "Why"
Existing frameworks (LangGraph, AutoGen) manage *memory*. Signet manages *trust*.
Use Signet when you need to ensure that your agent followed the rules.