semvec/pypi-packages huggingface dataset:
image-utils-spin 0.1.4
A simple CLI and Python tool to rotate images
License: MIT
Requires Python: >=3.9
Keywords: image, rotate, CLI, python

# Image Utils

A small Python package to rotate images from Python or the command line.

---

## Installation

### ✅ pip (recommended)

```bash
pip install image-utils-spin
```

---

### ✅ pipx (best for CLI usage)

If you mainly want the CLI command:

```bash
pipx install image-utils-spin
```

---

### ✅ uv

```bash
uv pip install image-utils-spin
```

Or inside a project:

```bash
uv add image-utils-spin
```

---

### ✅ Development (editable install)

For testing or contributing:

```bash
git clone https://github.com/rick-rocks123/image_spinner.git
cd <repo-folder>
pip install -e .
```

---

## Usage

---

### ✅ Command-line usage

After installing, you can use the CLI command `rotate-image` instead of `py main.py`:

```bash
rotate-image input.png 90 output.png
```

Overwrite existing file:

```bash
rotate-image input.png 90 output.png --force
```

---

### ✅ Python usage
## Example 1: direct usage
```python
from image_utils_spin import rotate_image

rotate_image(
    "input.png",
    90,
    "output.png",
    force=True
)
```
## Example 2: usage with CLI-style arguments
```python
from image_utils_spin import rotate_image, argparse_arguments
image_path, rotate_angle, save_path, force = argparse_arguments()

rotate_image(
    image_path,
    rotate_angle,
    save_path,
    force
)
```

### ✅ Bash commands
## Disclaimer: you can use -h or --help
```bash
rotate-image --help
```
or
```bash
py script.py --help
```
menupapi-cm 1.0.0
MENUPAPI Claude Session Monitor - real 5-hour resets from Claude.ai usage API with fallback estimate mode
License: MIT
Requires Python: >=3.9
Keywords: claude, claude-code, monitor, usage, tokens, menubar, terminal, dashboard, session, anthropic

# MENUPAPI-CM (cm)

A lightweight terminal monitor that shows your **Claude Code 5-hour reset timer** and utilization.

Unlike most monitors, this supports **REAL Claude web session reset data** by pulling:

```
https://claude.ai/api/organizations/{org_id}/usage
```

If cookies are missing, it runs instantly in **estimate mode**.

---

## Install

```bash
pip install menupapi-cm
```

## Run

```bash
cm
```

## Features

- Shows real `five_hour.utilization` and `five_hour.resets_at`
- Shows real `seven_day.utilization` and `seven_day.resets_at`
- Works instantly without setup (estimate mode)
- Optional "real mode" using cookie file
- Includes `cm setup` and `cm doctor`

## Usage

```bash
# Run monitor
cm

# Setup real usage mode
cm setup

# Diagnose cookie + API access
cm doctor
```

## Enable REAL MODE (Claude Web API)

Cookie stored here:

```
~/.claude_cookie.txt
```

Permissions required:

```bash
chmod 600 ~/.claude_cookie.txt
```

Example cookie file format (ONE line only):

```
sessionKey=sk-ant-sid02-xxxxx; cf_clearance=xxxxx; lastActiveOrg=xxxxxxxx
```

## Works Out The Box

This tool cannot auto-grab browser cookies safely.
Auto-extracting cookies from Chrome would become malware-adjacent.

So the correct UX is:

- `cm` runs immediately in estimate mode
- `cm setup` enables real mode
- `cm doctor` validates cookie + prints fix steps

## Build + Publish (for maintainer)

```bash
# Build
python3 -m build

# Upload to PyPI
python3 -m twine upload dist/*
```

## Author

**Sylvester Assiamah** — The Menu Papi
agentstateprotocol 0.1.0
Checkpointing and recovery protocol for AI agents
License: MIT
Requires Python: >=3.9
Keywords: ai, agents, checkpointing, recovery, state-management, llm, reasoning, rollback, branching

# AgentStateProtocol

Checkpointing and recovery protocol for AI agents.

`AgentStateProtocol` lets an agent save state at each reasoning step, branch into alternatives, and roll back safely after failures.

## Install

```bash
pip install agentstateprotocol
```

## Quick Start

```python
from agentstateprotocol import AgentStateProtocol

agent = AgentStateProtocol("my-agent")

agent.checkpoint(
    state={"task": "summarize quarterly report", "stage": "parsed"},
    metadata={"confidence": 0.91},
    description="Initial parse",
    logic_step="parse_input",
)

agent.checkpoint(
    state={"task": "summarize quarterly report", "stage": "drafted"},
    metadata={"confidence": 0.86},
    description="Draft generated",
    logic_step="draft_summary",
)

# Roll back one step if needed
agent.rollback()
```

## Core Operations

- `agent.checkpoint(...)`: save a state snapshot
- `agent.rollback(...)`: restore a previous checkpoint
- `agent.branch(name)`: start an alternate reasoning path
- `agent.switch_branch(name)`: move between branches
- `agent.merge(source_branch)`: merge branch outcomes
- `agent.history()`: inspect checkpoint timeline
- `agent.visualize_tree()`: show decision tree

## Decorators

```python
from agentstateprotocol.decorators import agentstateprotocol_step

@agentstateprotocol_step("analyze")
def analyze(state):
    return {"result": "ok", **state}
```

## Storage

```python
from agentstateprotocol.storage import FileSystemStorage, SQLiteStorage

file_storage = FileSystemStorage(".agentstateprotocol")
sqlite_storage = SQLiteStorage(".agentstateprotocol/agentstateprotocol.db")
```

## CLI

```bash
agentstateprotocol demo
agentstateprotocol log
agentstateprotocol tree
agentstateprotocol branches
agentstateprotocol diff <checkpoint_a> <checkpoint_b>
agentstateprotocol metrics
```

## Project

- Repository: https://github.com/ekessh/agentstateprotocol
- License: MIT