paint-tracker 0.1.0__tar.gz

paint_tracker-0.1.0/PKG-INFO

@@ -0,0 +1,134 @@
+Metadata-Version: 2.4
+Name: paint-tracker
+Version: 0.1.0
+Summary: Paint and stain shelf tracker – self-updating, one-command deploy for Raspberry Pi
+License: MIT
+Project-URL: Homepage, https://github.com/FlaccidFacade/paint-tracker
+Project-URL: Bug Tracker, https://github.com/FlaccidFacade/paint-tracker/issues
+Keywords: paint,tracker,raspberry-pi,home
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Home Automation
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: fastapi>=0.115
+Requires-Dist: uvicorn[standard]>=0.35
+Requires-Dist: sqlalchemy>=2.0
+Requires-Dist: pydantic>=2.0
+
+# paint-tracker
+
+Paint and stain shelf tracker with:
+
+- **FastAPI** API
+- **SQLite** auto-configured database (no setup required)
+- **React + Vite** frontend bundled into the Python package
+- **Self-updating** – checks PyPI for new versions on every start
+
+---
+
+## 🚀 One-click install on Raspberry Pi Zero 2 W
+
+Run this single command on the Pi (requires Python 3.11+ and internet access):
+
+```bash
+bash <(curl -fsSL https://raw.githubusercontent.com/FlaccidFacade/paint-tracker/main/scripts/install_pi.sh)
+```
+
+The script will:
+1. Install `paint-tracker` from PyPI.
+2. Create and enable a **systemd service** that starts automatically on every boot.
+3. Open port 8000 in the firewall (if ufw is active).
+4. Print the local URL where the UI is reachable (e.g. `http://raspberrypi.local:8000`).
+
+After installation, the tracker is accessible from any device on your network.
+
+---
+
+## 📦 Install from PyPI (any machine)
+
+```bash
+pip install paint-tracker
+paint-tracker
+```
+
+On first launch Paint Tracker will:
+- Check PyPI for a newer version and prompt you to upgrade.
+- Auto-create the SQLite database at `~/.local/share/paint-tracker/paint_tracker.db`.
+- Start the web server on `http://0.0.0.0:8000`.
+
+### CLI options
+
+```
+paint-tracker --help
+
+  --host HOST            Bind host (default: 0.0.0.0)
+  --port PORT            Bind port (default: 8000)
+  --no-update-check      Skip the PyPI update check on startup
+```
+
+---
+
+## 🔧 Development setup
+
+### Backend
+
+```bash
+cd backend
+pip install -r requirements.txt
+pip install -e ..          # install paint_tracker package in editable mode
+uvicorn paint_tracker.main:app --reload
+```
+
+`DATABASE_URL` defaults to `~/.local/share/paint-tracker/paint_tracker.db`. Override for PostgreSQL:
+
+```bash
+export DATABASE_URL='postgresql+psycopg://user:password@localhost:5432/paint_tracker'
+```
+
+Run tests:
+
+```bash
+cd backend
+pytest
+```
+
+### Frontend (standalone dev server)
+
+```bash
+cd frontend
+npm install
+npm run dev
+```
+
+Optional API override:
+
+```bash
+export VITE_API_BASE_URL='http://localhost:8000/api'
+```
+
+---
+
+## 📤 Publishing to PyPI
+
+Build the frontend, bundle it into the Python package, and publish in one step:
+
+```bash
+pip install build twine
+bash scripts/build_and_publish.sh          # publish to PyPI
+bash scripts/build_and_publish.sh --test   # publish to TestPyPI
+```
+
+---
+
+## Included behavior
+
+- Create paints with required `room`, `shelf_level`, `shelf_depth`
+- Room suggestions while typing; new room names are saved automatically
+- Search paints by room, color, and coordinates
+- Edit existing paints from the list (✏️ button)
+- Confirmation/decline controls use green check and red X buttons

paint_tracker-0.1.0/README.md

@@ -0,0 +1,112 @@
+# paint-tracker
+
+Paint and stain shelf tracker with:
+
+- **FastAPI** API
+- **SQLite** auto-configured database (no setup required)
+- **React + Vite** frontend bundled into the Python package
+- **Self-updating** – checks PyPI for new versions on every start
+
+---
+
+## 🚀 One-click install on Raspberry Pi Zero 2 W
+
+Run this single command on the Pi (requires Python 3.11+ and internet access):
+
+```bash
+bash <(curl -fsSL https://raw.githubusercontent.com/FlaccidFacade/paint-tracker/main/scripts/install_pi.sh)
+```
+
+The script will:
+1. Install `paint-tracker` from PyPI.
+2. Create and enable a **systemd service** that starts automatically on every boot.
+3. Open port 8000 in the firewall (if ufw is active).
+4. Print the local URL where the UI is reachable (e.g. `http://raspberrypi.local:8000`).
+
+After installation, the tracker is accessible from any device on your network.
+
+---
+
+## 📦 Install from PyPI (any machine)
+
+```bash
+pip install paint-tracker
+paint-tracker
+```
+
+On first launch Paint Tracker will:
+- Check PyPI for a newer version and prompt you to upgrade.
+- Auto-create the SQLite database at `~/.local/share/paint-tracker/paint_tracker.db`.
+- Start the web server on `http://0.0.0.0:8000`.
+
+### CLI options
+
+```
+paint-tracker --help
+
+  --host HOST            Bind host (default: 0.0.0.0)
+  --port PORT            Bind port (default: 8000)
+  --no-update-check      Skip the PyPI update check on startup
+```
+
+---
+
+## 🔧 Development setup
+
+### Backend
+
+```bash
+cd backend
+pip install -r requirements.txt
+pip install -e ..          # install paint_tracker package in editable mode
+uvicorn paint_tracker.main:app --reload
+```
+
+`DATABASE_URL` defaults to `~/.local/share/paint-tracker/paint_tracker.db`. Override for PostgreSQL:
+
+```bash
+export DATABASE_URL='postgresql+psycopg://user:password@localhost:5432/paint_tracker'
+```
+
+Run tests:
+
+```bash
+cd backend
+pytest
+```
+
+### Frontend (standalone dev server)
+
+```bash
+cd frontend
+npm install
+npm run dev
+```
+
+Optional API override:
+
+```bash
+export VITE_API_BASE_URL='http://localhost:8000/api'
+```
+
+---
+
+## 📤 Publishing to PyPI
+
+Build the frontend, bundle it into the Python package, and publish in one step:
+
+```bash
+pip install build twine
+bash scripts/build_and_publish.sh          # publish to PyPI
+bash scripts/build_and_publish.sh --test   # publish to TestPyPI
+```
+
+---
+
+## Included behavior
+
+- Create paints with required `room`, `shelf_level`, `shelf_depth`
+- Room suggestions while typing; new room names are saved automatically
+- Search paints by room, color, and coordinates
+- Edit existing paints from the list (✏️ button)
+- Confirmation/decline controls use green check and red X buttons

paint_tracker-0.1.0/paint_tracker/__init__.py

@@ -0,0 +1,5 @@
+"""Paint Tracker – paint and stain shelf tracker."""
+
+from __future__ import annotations
+
+__version__ = "0.1.0"

paint_tracker-0.1.0/paint_tracker/__main__.py

@@ -0,0 +1,5 @@
+"""Allow `python -m paint_tracker` to launch the server."""
+
+from paint_tracker.cli import main
+
+main()

paint_tracker-0.1.0/paint_tracker/cli.py

@@ -0,0 +1,119 @@
+"""Command-line entry point for the Paint Tracker server.
+
+Usage::
+
+    paint-tracker [--host HOST] [--port PORT] [--no-update-check]
+
+On startup the CLI will:
+
+1. Check PyPI for a newer version and prompt the user to upgrade.
+2. Auto-configure the database (SQLite at
+   ``~/.local/share/paint-tracker/paint_tracker.db`` unless
+   ``DATABASE_URL`` is set).
+3. Launch the uvicorn ASGI server.
+"""
+
+from __future__ import annotations
+
+import argparse
+import importlib.metadata
+import subprocess
+import sys
+
+from paint_tracker import __version__
+from paint_tracker.updater import check_for_update
+
+_BANNER = r"""
+ ____       _       _     _____               _
+|  _ \ __ _(_)_ __ | |_  |_   _| __ __ _  __| | _____ _ __
+| |_) / _` | | '_ \| __|   | || '__/ _` |/ _` |/ / _ \ '__|
+|  __/ (_| | | | | | |_    | || | | (_| | (_| |   <  __/ |
+|_|   \__,_|_|_| |_|\__|   |_||_|  \__,_|\__,_|\_\___|_|
+
+"""
+
+
+def _prompt_update(new_version: str) -> bool:
+    """Return *True* if the user agrees to upgrade."""
+    print(f"\n🔔  A new version of paint-tracker is available: {new_version}")
+    print(f"    Currently installed: {__version__}")
+    try:
+        answer = input("    Upgrade now? [Y/n] ").strip().lower()
+    except EOFError:
+        return False
+    return answer in ("", "y", "yes")
+
+
+def _do_upgrade() -> None:
+    """Run ``pip install --upgrade paint-tracker`` and restart the process."""
+    print("⬆️  Upgrading paint-tracker …")
+    subprocess.check_call(
+        [sys.executable, "-m", "pip", "install", "--upgrade", "paint-tracker"],
+        stdout=sys.stdout,
+        stderr=sys.stderr,
+    )
+    print("✅  Upgrade complete – restarting …\n")
+    # Replace the current process with the freshly installed version.
+    import os
+
+    os.execv(sys.executable, [sys.executable, "-m", "paint_tracker"] + sys.argv[1:])
+
+
+def main(argv: list[str] | None = None) -> None:
+    parser = argparse.ArgumentParser(
+        prog="paint-tracker",
+        description="Start the Paint Tracker server.",
+    )
+    parser.add_argument("--host", default="0.0.0.0", help="Bind host (default: 0.0.0.0)")
+    parser.add_argument("--port", type=int, default=8000, help="Bind port (default: 8000)")
+    parser.add_argument(
+        "--no-update-check",
+        action="store_true",
+        help="Skip the PyPI update check on startup.",
+    )
+    args = parser.parse_args(argv)
+
+    print(_BANNER)
+
+    try:
+        installed = importlib.metadata.version("paint-tracker")
+    except importlib.metadata.PackageNotFoundError:
+        installed = __version__
+    print(f"Paint Tracker v{installed}")
+
+    # ── 1. Update check ──────────────────────────────────────────────────────
+    if not args.no_update_check:
+        print("🔍  Checking PyPI for updates …", end=" ", flush=True)
+        new_version = check_for_update()
+        if new_version:
+            print()  # newline after the ellipsis
+            if _prompt_update(new_version):
+                _do_upgrade()
+                return  # unreachable after execv, but keeps linters happy
+        else:
+            print("up to date.")
+
+    # ── 2. Database auto-configuration ───────────────────────────────────────
+    # Importing the database module triggers directory creation and engine setup.
+    from paint_tracker.database import DATABASE_URL  # noqa: F401
+
+    print(f"\n🗄️  Database: {DATABASE_URL}")
+
+    # ── 3. Start server ───────────────────────────────────────────────────────
+    print(f"🚀  Starting server on http://{args.host}:{args.port}\n")
+
+    try:
+        import uvicorn
+    except ImportError as exc:
+        sys.exit(f"uvicorn is required to run the server: {exc}")
+
+    uvicorn.run(
+        "paint_tracker.main:app",
+        host=args.host,
+        port=args.port,
+        reload=False,
+    )
+
+
+if __name__ == "__main__":
+    main()

paint_tracker-0.1.0/paint_tracker/database.py

@@ -0,0 +1,38 @@
+"""Database engine / session factory with automatic data-directory creation."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Generator
+
+from sqlalchemy import create_engine
+from sqlalchemy.orm import Session, sessionmaker
+
+
+def _default_db_path() -> str:
+    """Return a sensible default SQLite path inside the user's data directory.
+
+    Priority:
+    1. ``DATABASE_URL`` environment variable (any SQLAlchemy URL).
+    2. ``~/.local/share/paint-tracker/paint_tracker.db``  (XDG-ish default).
+    """
+    data_dir = Path.home() / ".local" / "share" / "paint-tracker"
+    data_dir.mkdir(parents=True, exist_ok=True)
+    return f"sqlite:///{data_dir / 'paint_tracker.db'}"
+
+
+DATABASE_URL: str = os.getenv("DATABASE_URL") or _default_db_path()
+
+connect_args = {"check_same_thread": False} if DATABASE_URL.startswith("sqlite") else {}
+
+engine = create_engine(DATABASE_URL, connect_args=connect_args, future=True)
+session_local = sessionmaker(bind=engine, autocommit=False, autoflush=False, future=True)
+
+
+def get_db() -> Generator[Session, None, None]:
+    db = session_local()
+    try:
+        yield db
+    finally:
+        db.close()

paint_tracker-0.1.0/paint_tracker/main.py

@@ -0,0 +1,144 @@
+from __future__ import annotations
+
+from difflib import get_close_matches
+from pathlib import Path
+
+from fastapi import Depends, FastAPI, HTTPException, Query
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+from sqlalchemy import select
+from sqlalchemy.orm import Session
+
+from .database import engine, get_db
+from .models import Base, Paint, Room
+from .schemas import PaintCreate, PaintOut, PaintUpdate, RoomOut
+
+Base.metadata.create_all(bind=engine)
+
+app = FastAPI(title="Paint Tracker API")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=False,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+def _normalize_room_name(room_name: str) -> str:
+    return room_name.strip()
+
+
+def _get_or_create_room(db: Session, room_name: str) -> Room:
+    normalized_name = _normalize_room_name(room_name)
+    existing = db.execute(select(Room).where(Room.name.ilike(normalized_name))).scalar_one_or_none()
+    if existing:
+        return existing
+
+    room = Room(name=normalized_name)
+    db.add(room)
+    db.flush()
+    return room
+
+
+def _paint_to_schema(paint: Paint) -> PaintOut:
+    return PaintOut(
+        id=paint.id,
+        color_code=paint.color_code,
+        color_name=paint.color_name,
+        finish_style=paint.finish_style,
+        bucket_image_url=paint.bucket_image_url,
+        notes=paint.notes,
+        shelf_level=paint.shelf_level,
+        shelf_depth=paint.shelf_depth,
+        room=paint.room.name,
+    )
+
+
+@app.get("/api/paints", response_model=list[PaintOut])
+def list_paints(
+    query: str | None = Query(default=None, max_length=100),
+    db: Session = Depends(get_db),
+) -> list[PaintOut]:
+    statement = select(Paint).join(Room)
+    if query:
+        q = f"%{query.strip()}%"
+        statement = statement.where(
+            Paint.color_name.ilike(q)
+            | Paint.color_code.ilike(q)
+            | Room.name.ilike(q)
+            | Paint.shelf_level.ilike(q)
+            | Paint.shelf_depth.ilike(q)
+        )
+
+    paints = db.execute(statement.order_by(Room.name, Paint.shelf_level, Paint.shelf_depth)).scalars().all()
+    return [_paint_to_schema(paint) for paint in paints]
+
+
+@app.post("/api/paints", response_model=PaintOut, status_code=201)
+def create_paint(payload: PaintCreate, db: Session = Depends(get_db)) -> PaintOut:
+    room = _get_or_create_room(db, payload.room)
+    paint = Paint(
+        color_code=payload.color_code,
+        color_name=payload.color_name,
+        finish_style=payload.finish_style,
+        bucket_image_url=payload.bucket_image_url,
+        notes=payload.notes,
+        shelf_level=payload.shelf_level,
+        shelf_depth=payload.shelf_depth,
+        room_id=room.id,
+    )
+    db.add(paint)
+    db.commit()
+    db.refresh(paint)
+    db.refresh(paint, attribute_names=["room"])
+    return _paint_to_schema(paint)
+
+
+@app.put("/api/paints/{paint_id}", response_model=PaintOut)
+def update_paint(paint_id: int, payload: PaintUpdate, db: Session = Depends(get_db)) -> PaintOut:
+    paint = db.get(Paint, paint_id)
+    if not paint:
+        raise HTTPException(status_code=404, detail="Paint not found")
+
+    room = _get_or_create_room(db, payload.room)
+    paint.color_code = payload.color_code
+    paint.color_name = payload.color_name
+    paint.finish_style = payload.finish_style
+    paint.bucket_image_url = payload.bucket_image_url
+    paint.notes = payload.notes
+    paint.shelf_level = payload.shelf_level
+    paint.shelf_depth = payload.shelf_depth
+    paint.room_id = room.id
+
+    db.commit()
+    db.refresh(paint)
+    db.refresh(paint, attribute_names=["room"])
+    return _paint_to_schema(paint)
+
+
+@app.get("/api/rooms", response_model=list[RoomOut])
+def list_rooms(
+    suggest: str | None = Query(default=None, max_length=30),
+    db: Session = Depends(get_db),
+) -> list[RoomOut]:
+    rooms = db.execute(select(Room).order_by(Room.name)).scalars().all()
+    if not suggest:
+        return rooms
+
+    room_names = [room.name for room in rooms]
+    suggestion = suggest.strip()
+    prefix_matches = [name for name in room_names if suggestion.lower() in name.lower()]
+    close_matches = get_close_matches(suggestion, room_names, n=5, cutoff=0.5)
+    ordered_names = list(dict.fromkeys(prefix_matches + close_matches))
+
+    return [room for room in rooms if room.name in ordered_names]
+
+
+# Serve the pre-built React frontend when it exists inside the package.
+# This mount must be registered AFTER all API routes so that API paths take
+# priority over the catch-all "/" prefix handled by StaticFiles.
+_STATIC_DIR = Path(__file__).parent / "static"
+if (_STATIC_DIR / "index.html").exists():
+    app.mount("/", StaticFiles(directory=str(_STATIC_DIR), html=True), name="static")

paint_tracker-0.1.0/paint_tracker/models.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from sqlalchemy import ForeignKey, String
+from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column, relationship
+
+
+class Base(DeclarativeBase):
+    pass
+
+
+class Room(Base):
+    __tablename__ = "rooms"
+
+    id: Mapped[int] = mapped_column(primary_key=True, index=True)
+    name: Mapped[str] = mapped_column(String(30), unique=True, index=True)
+    paints: Mapped[list["Paint"]] = relationship(back_populates="room", cascade="all, delete-orphan")
+
+
+class Paint(Base):
+    __tablename__ = "paints"
+
+    id: Mapped[int] = mapped_column(primary_key=True, index=True)
+    color_code: Mapped[str | None] = mapped_column(String(50), nullable=True)
+    color_name: Mapped[str | None] = mapped_column(String(100), nullable=True)
+    finish_style: Mapped[str | None] = mapped_column(String(50), nullable=True)
+    bucket_image_url: Mapped[str | None] = mapped_column(String(500), nullable=True)
+    notes: Mapped[str | None] = mapped_column(String(500), nullable=True)
+    shelf_level: Mapped[str] = mapped_column(String(10), index=True)
+    shelf_depth: Mapped[str] = mapped_column(String(10), index=True)
+    room_id: Mapped[int] = mapped_column(ForeignKey("rooms.id"), index=True)
+    room: Mapped[Room] = relationship(back_populates="paints")

paint_tracker-0.1.0/paint_tracker/schemas.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class PaintBase(BaseModel):
+    color_code: str | None = Field(default=None, max_length=50)
+    color_name: str | None = Field(default=None, max_length=100)
+    finish_style: str | None = Field(default=None, max_length=50)
+    bucket_image_url: str | None = Field(default=None, max_length=500)
+    notes: str | None = Field(default=None, max_length=500)
+    shelf_level: str = Field(min_length=1, max_length=10)
+    shelf_depth: str = Field(min_length=1, max_length=10)
+    room: str = Field(min_length=1, max_length=30)
+
+
+class PaintCreate(PaintBase):
+    pass
+
+
+class PaintUpdate(PaintBase):
+    pass
+
+
+class PaintOut(PaintBase):
+    id: int
+
+    model_config = ConfigDict(from_attributes=True)
+
+
+class RoomOut(BaseModel):
+    id: int
+    name: str
+
+    model_config = ConfigDict(from_attributes=True)

paint_tracker-0.1.0/paint_tracker/static/assets/index-BIhKSoZQ.css

@@ -0,0 +1 @@
+:root{color:#111827;background-color:#f3f4f6;font-family:Inter,system-ui,-apple-system,BlinkMacSystemFont,Segoe UI,sans-serif}*{box-sizing:border-box}body{margin:0}#root{min-height:100vh}.layout{gap:1rem;max-width:960px;margin:0 auto;padding:2rem 1rem 4rem;display:grid}.card{background:#fff;border-radius:12px;padding:1rem;box-shadow:0 3px 12px #11182714}.grid{grid-template-columns:repeat(auto-fit,minmax(200px,1fr));gap:.75rem;display:grid}label{gap:.25rem;font-size:.9rem;display:grid}input,textarea,button{font:inherit}input,textarea{border:1px solid #d1d5db;border-radius:8px;padding:.5rem}textarea{min-height:72px}.full-width{grid-column:1/-1}.actions{gap:.5rem;margin-top:.75rem;display:flex}.actions button,.edit{cursor:pointer;border:none;border-radius:999px;width:2.25rem;height:2.25rem}.confirm{color:#fff;background-color:#22c55e}.decline{color:#fff;background-color:#ef4444}.edit{background-color:#e5e7eb}.search-row{gap:.5rem;margin-bottom:.75rem;display:flex}.search-row button{color:#fff;background-color:#111827;border:none;border-radius:8px;padding:.5rem .75rem}.paint-list{gap:.5rem;margin:0;padding:0;list-style:none;display:grid}.paint-list li{border:1px solid #e5e7eb;border-radius:8px;justify-content:space-between;align-items:center;padding:.75rem;display:flex}.paint-list p{margin:.1rem 0}.error{color:#b91c1c}