winebox 0.1.0__py3-none-any.whl

winebox/__init__.py

@@ -0,0 +1,3 @@
+"""WineBox - Wine Cellar Management Application."""
+
+__version__ = "0.1.0"

winebox/cli/__init__.py

@@ -0,0 +1 @@
+"""CLI tools for WineBox."""

winebox/cli/server.py

@@ -0,0 +1,313 @@
+"""WineBox server control script.
+
+Usage:
+    winebox-server start [--port PORT] [--reload]
+    winebox-server stop
+    winebox-server restart [--port PORT]
+    winebox-server status
+"""
+
+import argparse
+import os
+import signal
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+
+# Configuration
+DATA_DIR = Path("data")
+PID_FILE = DATA_DIR / "winebox.pid"
+LOG_FILE = DATA_DIR / "winebox.log"
+DEFAULT_PORT = 8000
+DEFAULT_HOST = "0.0.0.0"
+
+
+def ensure_directories() -> None:
+    """Ensure required directories exist."""
+    DATA_DIR.mkdir(parents=True, exist_ok=True)
+    (DATA_DIR / "images").mkdir(parents=True, exist_ok=True)
+
+
+def get_pid() -> int | None:
+    """Get the PID of the running server, if any."""
+    if not PID_FILE.exists():
+        return None
+
+    try:
+        pid = int(PID_FILE.read_text().strip())
+        # Check if process is actually running
+        os.kill(pid, 0)
+        return pid
+    except (ValueError, ProcessLookupError, PermissionError):
+        # PID file exists but process is not running
+        PID_FILE.unlink(missing_ok=True)
+        return None
+
+
+def find_running_server() -> int | None:
+    """Find any running winebox uvicorn process."""
+    try:
+        result = subprocess.run(
+            ["pgrep", "-f", "uvicorn winebox.main:app"],
+            capture_output=True,
+            text=True,
+        )
+        if result.returncode == 0 and result.stdout.strip():
+            # Return first PID found
+            return int(result.stdout.strip().split()[0])
+    except Exception:
+        pass
+    return None
+
+
+def start_server(port: int = DEFAULT_PORT, host: str = DEFAULT_HOST,
+                 reload: bool = False, foreground: bool = False) -> bool:
+    """Start the WineBox server.
+
+    Args:
+        port: Port to bind to
+        host: Host to bind to
+        reload: Enable auto-reload for development
+        foreground: Run in foreground (blocking)
+
+    Returns:
+        True if server started successfully
+    """
+    # Check if already running
+    pid = get_pid() or find_running_server()
+    if pid:
+        print(f"Server is already running (PID: {pid})")
+        return False
+
+    ensure_directories()
+
+    cmd = [
+        sys.executable, "-m", "uvicorn",
+        "winebox.main:app",
+        "--host", host,
+        "--port", str(port),
+    ]
+
+    if reload:
+        cmd.append("--reload")
+
+    print(f"Starting WineBox server on http://{host}:{port}")
+
+    if foreground:
+        print("Press Ctrl+C to stop the server")
+        try:
+            subprocess.run(cmd)
+        except KeyboardInterrupt:
+            print("\nServer stopped")
+        return True
+
+    # Start in background
+    with open(LOG_FILE, "w") as log:
+        process = subprocess.Popen(
+            cmd,
+            stdout=log,
+            stderr=subprocess.STDOUT,
+            start_new_session=True,
+        )
+
+    # Wait a moment and check if it started
+    time.sleep(1)
+    if process.poll() is None:
+        PID_FILE.write_text(str(process.pid))
+        print(f"Server started with PID: {process.pid}")
+        print(f"Logs available at: {LOG_FILE}")
+        return True
+    else:
+        print("Failed to start server. Check logs for details.")
+        return False
+
+
+def stop_server() -> bool:
+    """Stop the WineBox server.
+
+    Returns:
+        True if server was stopped
+    """
+    pid = get_pid()
+
+    if not pid:
+        # Try to find running server anyway
+        pid = find_running_server()
+
+    if not pid:
+        print("Server is not running")
+        return False
+
+    print(f"Stopping server (PID: {pid})...")
+
+    try:
+        # Send SIGTERM for graceful shutdown
+        os.kill(pid, signal.SIGTERM)
+
+        # Wait for process to terminate
+        for _ in range(10):
+            time.sleep(0.5)
+            try:
+                os.kill(pid, 0)
+            except ProcessLookupError:
+                break
+        else:
+            # Process didn't stop, send SIGKILL
+            print("Server didn't stop gracefully, forcing...")
+            os.kill(pid, signal.SIGKILL)
+
+        print("Server stopped")
+        PID_FILE.unlink(missing_ok=True)
+        return True
+
+    except ProcessLookupError:
+        print("Server was not running")
+        PID_FILE.unlink(missing_ok=True)
+        return False
+    except PermissionError:
+        print(f"Permission denied to stop process {pid}")
+        return False
+
+
+def restart_server(port: int = DEFAULT_PORT, host: str = DEFAULT_HOST) -> bool:
+    """Restart the WineBox server.
+
+    Args:
+        port: Port to bind to
+        host: Host to bind to
+
+    Returns:
+        True if server restarted successfully
+    """
+    print("Restarting WineBox server...")
+    stop_server()
+    time.sleep(1)
+    return start_server(port=port, host=host)
+
+
+def server_status() -> None:
+    """Print the server status."""
+    pid = get_pid()
+
+    if not pid:
+        pid = find_running_server()
+
+    if pid:
+        print(f"WineBox server is running (PID: {pid})")
+
+        # Try to get health status
+        try:
+            import urllib.request
+            with urllib.request.urlopen("http://localhost:8000/health", timeout=2) as response:
+                import json
+                data = json.loads(response.read().decode())
+                print(f"  Status: {data.get('status', 'unknown')}")
+                print(f"  Version: {data.get('version', 'unknown')}")
+        except Exception:
+            print("  (Could not fetch health status)")
+    else:
+        print("WineBox server is not running")
+
+
+def main() -> int:
+    """Main entry point."""
+    parser = argparse.ArgumentParser(
+        description="WineBox server control script",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  %(prog)s start                  Start server on default port (8000)
+  %(prog)s start --port 8080      Start server on port 8080
+  %(prog)s start --reload         Start with auto-reload for development
+  %(prog)s start --foreground     Start in foreground (blocking)
+  %(prog)s stop                   Stop the server
+  %(prog)s restart                Restart the server
+  %(prog)s status                 Check server status
+        """,
+    )
+
+    subparsers = parser.add_subparsers(dest="command", help="Command to run")
+
+    # Start command
+    start_parser = subparsers.add_parser("start", help="Start the server")
+    start_parser.add_argument(
+        "--port", "-p",
+        type=int,
+        default=DEFAULT_PORT,
+        help=f"Port to bind to (default: {DEFAULT_PORT})",
+    )
+    start_parser.add_argument(
+        "--host",
+        default=DEFAULT_HOST,
+        help=f"Host to bind to (default: {DEFAULT_HOST})",
+    )
+    start_parser.add_argument(
+        "--reload", "-r",
+        action="store_true",
+        help="Enable auto-reload for development",
+    )
+    start_parser.add_argument(
+        "--foreground", "-f",
+        action="store_true",
+        help="Run in foreground (blocking)",
+    )
+
+    # Stop command
+    subparsers.add_parser("stop", help="Stop the server")
+
+    # Restart command
+    restart_parser = subparsers.add_parser("restart", help="Restart the server")
+    restart_parser.add_argument(
+        "--port", "-p",
+        type=int,
+        default=DEFAULT_PORT,
+        help=f"Port to bind to (default: {DEFAULT_PORT})",
+    )
+    restart_parser.add_argument(
+        "--host",
+        default=DEFAULT_HOST,
+        help=f"Host to bind to (default: {DEFAULT_HOST})",
+    )
+
+    # Status command
+    subparsers.add_parser("status", help="Check server status")
+
+    args = parser.parse_args()
+
+    if not args.command:
+        parser.print_help()
+        return 1
+
+    try:
+        if args.command == "start":
+            success = start_server(
+                port=args.port,
+                host=args.host,
+                reload=args.reload,
+                foreground=args.foreground,
+            )
+            return 0 if success else 1
+
+        elif args.command == "stop":
+            success = stop_server()
+            return 0 if success else 1
+
+        elif args.command == "restart":
+            success = restart_server(port=args.port, host=args.host)
+            return 0 if success else 1
+
+        elif args.command == "status":
+            server_status()
+            return 0
+
+    except KeyboardInterrupt:
+        print("\nInterrupted")
+        return 130
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

winebox/cli/user_admin.py

@@ -0,0 +1,258 @@
+"""User administration script for WineBox.
+
+Commands:
+    add       Add a new user
+    list      List all users
+    disable   Disable a user account
+    enable    Enable a user account
+    remove    Remove a user account
+    passwd    Change a user's password
+"""
+
+import argparse
+import asyncio
+import sys
+from getpass import getpass
+from typing import Optional
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
+
+from winebox.config import settings
+from winebox.database import Base
+from winebox.models.user import User
+from winebox.services.auth import get_password_hash
+
+
+async def get_db_session() -> AsyncSession:
+    """Create a database session, ensuring tables exist."""
+    engine = create_async_engine(settings.database_url, echo=False)
+
+    # Create tables if they don't exist
+    async with engine.begin() as conn:
+        await conn.run_sync(Base.metadata.create_all)
+
+    async_session = async_sessionmaker(engine, class_=AsyncSession, expire_on_commit=False)
+    return async_session()
+
+
+async def add_user(
+    username: str,
+    password: str,
+    email: Optional[str] = None,
+    is_admin: bool = False,
+) -> None:
+    """Add a new user."""
+    async with await get_db_session() as db:
+        # Check if user already exists
+        result = await db.execute(select(User).where(User.username == username))
+        if result.scalar_one_or_none():
+            print(f"Error: User '{username}' already exists.")
+            sys.exit(1)
+
+        # Check if email already exists
+        if email:
+            result = await db.execute(select(User).where(User.email == email))
+            if result.scalar_one_or_none():
+                print(f"Error: Email '{email}' already in use.")
+                sys.exit(1)
+
+        # Create user
+        user = User(
+            username=username,
+            email=email,
+            hashed_password=get_password_hash(password),
+            is_admin=is_admin,
+            is_active=True,
+        )
+        db.add(user)
+        await db.commit()
+
+        role = "admin" if is_admin else "user"
+        print(f"User '{username}' created successfully as {role}.")
+
+
+async def list_users() -> None:
+    """List all users."""
+    async with await get_db_session() as db:
+        result = await db.execute(select(User).order_by(User.username))
+        users = result.scalars().all()
+
+        if not users:
+            print("No users found.")
+            return
+
+        print(f"{'Username':<20} {'Email':<30} {'Admin':<6} {'Active':<6} {'Last Login':<20}")
+        print("-" * 90)
+
+        for user in users:
+            last_login = user.last_login.strftime("%Y-%m-%d %H:%M") if user.last_login else "Never"
+            admin = "Yes" if user.is_admin else "No"
+            active = "Yes" if user.is_active else "No"
+            email = user.email or ""
+            print(f"{user.username:<20} {email:<30} {admin:<6} {active:<6} {last_login:<20}")
+
+
+async def disable_user(username: str) -> None:
+    """Disable a user account."""
+    async with await get_db_session() as db:
+        result = await db.execute(select(User).where(User.username == username))
+        user = result.scalar_one_or_none()
+
+        if not user:
+            print(f"Error: User '{username}' not found.")
+            sys.exit(1)
+
+        if not user.is_active:
+            print(f"User '{username}' is already disabled.")
+            return
+
+        user.is_active = False
+        await db.commit()
+        print(f"User '{username}' has been disabled.")
+
+
+async def enable_user(username: str) -> None:
+    """Enable a user account."""
+    async with await get_db_session() as db:
+        result = await db.execute(select(User).where(User.username == username))
+        user = result.scalar_one_or_none()
+
+        if not user:
+            print(f"Error: User '{username}' not found.")
+            sys.exit(1)
+
+        if user.is_active:
+            print(f"User '{username}' is already active.")
+            return
+
+        user.is_active = True
+        await db.commit()
+        print(f"User '{username}' has been enabled.")
+
+
+async def remove_user(username: str, force: bool = False) -> None:
+    """Remove a user account."""
+    async with await get_db_session() as db:
+        result = await db.execute(select(User).where(User.username == username))
+        user = result.scalar_one_or_none()
+
+        if not user:
+            print(f"Error: User '{username}' not found.")
+            sys.exit(1)
+
+        if not force:
+            confirm = input(f"Are you sure you want to remove user '{username}'? [y/N]: ")
+            if confirm.lower() != "y":
+                print("Aborted.")
+                return
+
+        await db.delete(user)
+        await db.commit()
+        print(f"User '{username}' has been removed.")
+
+
+async def change_password(username: str, password: str) -> None:
+    """Change a user's password."""
+    async with await get_db_session() as db:
+        result = await db.execute(select(User).where(User.username == username))
+        user = result.scalar_one_or_none()
+
+        if not user:
+            print(f"Error: User '{username}' not found.")
+            sys.exit(1)
+
+        user.hashed_password = get_password_hash(password)
+        await db.commit()
+        print(f"Password for user '{username}' has been updated.")
+
+
+def get_password_interactive(confirm: bool = True) -> str:
+    """Get password interactively from user."""
+    password = getpass("Password: ")
+    if not password:
+        print("Error: Password cannot be empty.")
+        sys.exit(1)
+
+    if confirm:
+        password2 = getpass("Confirm password: ")
+        if password != password2:
+            print("Error: Passwords do not match.")
+            sys.exit(1)
+
+    return password
+
+
+def main() -> int:
+    """Main entry point."""
+    parser = argparse.ArgumentParser(
+        description="User administration for WineBox",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=__doc__,
+    )
+    subparsers = parser.add_subparsers(dest="command", help="Command to run")
+
+    # Add user command
+    add_parser = subparsers.add_parser("add", help="Add a new user")
+    add_parser.add_argument("username", help="Username for the new user")
+    add_parser.add_argument("--email", "-e", help="Email address")
+    add_parser.add_argument("--admin", "-a", action="store_true", help="Make user an admin")
+    add_parser.add_argument("--password", "-p", help="Password (will prompt if not provided)")
+
+    # List users command
+    subparsers.add_parser("list", help="List all users")
+
+    # Disable user command
+    disable_parser = subparsers.add_parser("disable", help="Disable a user account")
+    disable_parser.add_argument("username", help="Username to disable")
+
+    # Enable user command
+    enable_parser = subparsers.add_parser("enable", help="Enable a user account")
+    enable_parser.add_argument("username", help="Username to enable")
+
+    # Remove user command
+    remove_parser = subparsers.add_parser("remove", help="Remove a user account")
+    remove_parser.add_argument("username", help="Username to remove")
+    remove_parser.add_argument("--force", "-f", action="store_true", help="Skip confirmation")
+
+    # Change password command
+    passwd_parser = subparsers.add_parser("passwd", help="Change a user's password")
+    passwd_parser.add_argument("username", help="Username to change password for")
+    passwd_parser.add_argument("--password", "-p", help="New password (will prompt if not provided)")
+
+    args = parser.parse_args()
+
+    if not args.command:
+        parser.print_help()
+        return 1
+
+    try:
+        if args.command == "add":
+            password = args.password if args.password else get_password_interactive()
+            asyncio.run(add_user(args.username, password, args.email, args.admin))
+
+        elif args.command == "list":
+            asyncio.run(list_users())
+
+        elif args.command == "disable":
+            asyncio.run(disable_user(args.username))
+
+        elif args.command == "enable":
+            asyncio.run(enable_user(args.username))
+
+        elif args.command == "remove":
+            asyncio.run(remove_user(args.username, args.force))
+
+        elif args.command == "passwd":
+            password = args.password if args.password else get_password_interactive()
+            asyncio.run(change_password(args.username, password))
+
+    except KeyboardInterrupt:
+        print("\nAborted.")
+        return 1
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

winebox/config.py

@@ -0,0 +1,43 @@
+"""Configuration settings for WineBox application."""
+
+import secrets
+from pathlib import Path
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+def generate_secret_key() -> str:
+    """Generate a random secret key."""
+    return secrets.token_urlsafe(32)
+
+
+class Settings(BaseSettings):
+    """Application settings."""
+
+    model_config = SettingsConfigDict(
+        env_prefix="WINEBOX_",
+        env_file=".env",
+    )
+
+    # Application
+    app_name: str = "WineBox"
+    debug: bool = False
+
+    # Database
+    database_url: str = "sqlite+aiosqlite:///./data/winebox.db"
+
+    # Image storage
+    image_storage_path: Path = Path("data/images")
+
+    # Server
+    host: str = "0.0.0.0"
+    port: int = 8000
+
+    # OCR
+    tesseract_cmd: str | None = None  # Use system default if None
+
+    # Authentication
+    secret_key: str = generate_secret_key()  # Override with WINEBOX_SECRET_KEY env var
+    auth_enabled: bool = True  # Set to False to disable authentication
+
+
+settings = Settings()

winebox/database.py

@@ -0,0 +1,47 @@
+"""Database setup and session management."""
+
+from collections.abc import AsyncGenerator
+
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
+from sqlalchemy.orm import DeclarativeBase
+
+from winebox.config import settings
+
+engine = create_async_engine(
+    settings.database_url,
+    echo=settings.debug,
+)
+
+async_session_maker = async_sessionmaker(
+    engine,
+    class_=AsyncSession,
+    expire_on_commit=False,
+)
+
+
+class Base(DeclarativeBase):
+    """Base class for all database models."""
+
+    pass
+
+
+async def get_db() -> AsyncGenerator[AsyncSession, None]:
+    """Dependency to get database session."""
+    async with async_session_maker() as session:
+        try:
+            yield session
+            await session.commit()
+        except Exception:
+            await session.rollback()
+            raise
+
+
+async def init_db() -> None:
+    """Initialize the database, creating all tables."""
+    async with engine.begin() as conn:
+        await conn.run_sync(Base.metadata.create_all)
+
+
+async def close_db() -> None:
+    """Close database connections."""
+    await engine.dispose()