winebox 0.1.0__py3-none-any.whl

winebox/main.py

@@ -0,0 +1,78 @@
+"""FastAPI application entry point for WineBox."""
+
+from contextlib import asynccontextmanager
+from pathlib import Path
+from typing import AsyncGenerator
+
+from fastapi import FastAPI
+from fastapi.responses import JSONResponse, RedirectResponse
+from fastapi.staticfiles import StaticFiles
+
+from winebox import __version__
+from winebox.config import settings
+from winebox.database import close_db, init_db
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
+    """Application lifespan manager."""
+    # Startup
+    # Ensure data directories exist
+    settings.image_storage_path.mkdir(parents=True, exist_ok=True)
+    Path("data").mkdir(parents=True, exist_ok=True)
+
+    # Initialize database
+    await init_db()
+
+    yield
+
+    # Shutdown
+    await close_db()
+
+
+app = FastAPI(
+    title=settings.app_name,
+    description="Wine Cellar Management Application with OCR label scanning",
+    version=__version__,
+    lifespan=lifespan,
+)
+
+
+# Root redirect to web interface - defined first to ensure it's matched
+@app.get("/", tags=["Root"])
+async def root() -> RedirectResponse:
+    """Root endpoint - redirects to web interface."""
+    return RedirectResponse(url="/static/index.html")
+
+
+# Health check endpoint
+@app.get("/health", tags=["Health"])
+async def health_check() -> JSONResponse:
+    """Health check endpoint."""
+    return JSONResponse(
+        content={
+            "status": "healthy",
+            "version": __version__,
+            "app_name": settings.app_name,
+        }
+    )
+
+
+# Import and include routers
+from winebox.routers import auth, cellar, search, transactions, wines
+
+app.include_router(auth.router, prefix="/api/auth", tags=["Authentication"])
+app.include_router(wines.router, prefix="/api/wines", tags=["Wines"])
+app.include_router(cellar.router, prefix="/api/cellar", tags=["Cellar"])
+app.include_router(transactions.router, prefix="/api/transactions", tags=["Transactions"])
+app.include_router(search.router, prefix="/api/search", tags=["Search"])
+
+# Serve static files - mounted after routes to avoid conflicts
+static_path = Path(__file__).parent / "static"
+if static_path.exists():
+    app.mount("/static", StaticFiles(directory=str(static_path)), name="static")
+
+# Serve images
+images_path = settings.image_storage_path
+if images_path.exists():
+    app.mount("/api/images", StaticFiles(directory=str(images_path)), name="images")

winebox/models/__init__.py

@@ -0,0 +1,8 @@
+"""Database models for WineBox."""
+
+from winebox.models.wine import Wine
+from winebox.models.transaction import Transaction, TransactionType
+from winebox.models.inventory import CellarInventory
+from winebox.models.user import User
+
+__all__ = ["Wine", "Transaction", "TransactionType", "CellarInventory", "User"]

winebox/models/inventory.py

@@ -0,0 +1,46 @@
+"""Cellar inventory model for tracking current stock levels."""
+
+import uuid
+from datetime import datetime
+from typing import TYPE_CHECKING
+
+from sqlalchemy import DateTime, ForeignKey, Integer, func
+from sqlalchemy.dialects.sqlite import CHAR
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from winebox.database import Base
+
+if TYPE_CHECKING:
+    from winebox.models.wine import Wine
+
+
+class CellarInventory(Base):
+    """Cellar inventory model tracking current wine quantities."""
+
+    __tablename__ = "cellar_inventory"
+
+    id: Mapped[str] = mapped_column(
+        CHAR(36),
+        primary_key=True,
+        default=lambda: str(uuid.uuid4()),
+    )
+    wine_id: Mapped[str] = mapped_column(
+        CHAR(36),
+        ForeignKey("wines.id", ondelete="CASCADE"),
+        nullable=False,
+        unique=True,
+        index=True,
+    )
+    quantity: Mapped[int] = mapped_column(Integer, nullable=False, default=0)
+    updated_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True),
+        server_default=func.now(),
+        onupdate=func.now(),
+        nullable=False,
+    )
+
+    # Relationships
+    wine: Mapped["Wine"] = relationship("Wine", back_populates="inventory")
+
+    def __repr__(self) -> str:
+        return f"<CellarInventory(wine_id={self.wine_id}, quantity={self.quantity})>"

winebox/models/transaction.py

@@ -0,0 +1,64 @@
+"""Transaction model for tracking wine check-ins and check-outs."""
+
+import enum
+import uuid
+from datetime import datetime
+from typing import TYPE_CHECKING
+
+from sqlalchemy import DateTime, Enum, ForeignKey, Integer, String, Text, func
+from sqlalchemy.dialects.sqlite import CHAR
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from winebox.database import Base
+
+if TYPE_CHECKING:
+    from winebox.models.wine import Wine
+
+
+class TransactionType(str, enum.Enum):
+    """Type of transaction."""
+
+    CHECK_IN = "CHECK_IN"
+    CHECK_OUT = "CHECK_OUT"
+
+
+class Transaction(Base):
+    """Transaction model for tracking wine movements."""
+
+    __tablename__ = "transactions"
+
+    id: Mapped[str] = mapped_column(
+        CHAR(36),
+        primary_key=True,
+        default=lambda: str(uuid.uuid4()),
+    )
+    wine_id: Mapped[str] = mapped_column(
+        CHAR(36),
+        ForeignKey("wines.id", ondelete="CASCADE"),
+        nullable=False,
+        index=True,
+    )
+    transaction_type: Mapped[TransactionType] = mapped_column(
+        Enum(TransactionType),
+        nullable=False,
+        index=True,
+    )
+    quantity: Mapped[int] = mapped_column(Integer, nullable=False)
+    notes: Mapped[str | None] = mapped_column(Text, nullable=True)
+    transaction_date: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True),
+        server_default=func.now(),
+        nullable=False,
+        index=True,
+    )
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True),
+        server_default=func.now(),
+        nullable=False,
+    )
+
+    # Relationships
+    wine: Mapped["Wine"] = relationship("Wine", back_populates="transactions")
+
+    def __repr__(self) -> str:
+        return f"<Transaction(id={self.id}, type={self.transaction_type}, quantity={self.quantity})>"

winebox/models/user.py

@@ -0,0 +1,55 @@
+"""User model for authentication."""
+
+import uuid
+from datetime import datetime
+
+from sqlalchemy import Boolean, DateTime, String, func
+from sqlalchemy.dialects.sqlite import CHAR
+from sqlalchemy.orm import Mapped, mapped_column
+
+from winebox.database import Base
+
+
+class User(Base):
+    """User model for authentication."""
+
+    __tablename__ = "users"
+
+    id: Mapped[str] = mapped_column(
+        CHAR(36),
+        primary_key=True,
+        default=lambda: str(uuid.uuid4()),
+    )
+    username: Mapped[str] = mapped_column(
+        String(50),
+        unique=True,
+        nullable=False,
+        index=True,
+    )
+    email: Mapped[str | None] = mapped_column(
+        String(255),
+        unique=True,
+        nullable=True,
+        index=True,
+    )
+    hashed_password: Mapped[str] = mapped_column(String(255), nullable=False)
+    is_active: Mapped[bool] = mapped_column(Boolean, default=True, nullable=False)
+    is_admin: Mapped[bool] = mapped_column(Boolean, default=False, nullable=False)
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True),
+        server_default=func.now(),
+        nullable=False,
+    )
+    updated_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True),
+        server_default=func.now(),
+        onupdate=func.now(),
+        nullable=False,
+    )
+    last_login: Mapped[datetime | None] = mapped_column(
+        DateTime(timezone=True),
+        nullable=True,
+    )
+
+    def __repr__(self) -> str:
+        return f"<User(id={self.id}, username={self.username}, is_active={self.is_active})>"

winebox/models/wine.py

@@ -0,0 +1,66 @@
+"""Wine model for storing wine information."""
+
+import uuid
+from datetime import datetime
+from typing import TYPE_CHECKING
+
+from sqlalchemy import DateTime, Float, Integer, String, Text, func
+from sqlalchemy.dialects.sqlite import CHAR
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from winebox.database import Base
+
+if TYPE_CHECKING:
+    from winebox.models.inventory import CellarInventory
+    from winebox.models.transaction import Transaction
+
+
+class Wine(Base):
+    """Wine model representing a wine in the cellar."""
+
+    __tablename__ = "wines"
+
+    id: Mapped[str] = mapped_column(
+        CHAR(36),
+        primary_key=True,
+        default=lambda: str(uuid.uuid4()),
+    )
+    name: Mapped[str] = mapped_column(String(255), nullable=False, index=True)
+    winery: Mapped[str | None] = mapped_column(String(255), nullable=True, index=True)
+    vintage: Mapped[int | None] = mapped_column(Integer, nullable=True, index=True)
+    grape_variety: Mapped[str | None] = mapped_column(String(255), nullable=True, index=True)
+    region: Mapped[str | None] = mapped_column(String(255), nullable=True, index=True)
+    country: Mapped[str | None] = mapped_column(String(255), nullable=True, index=True)
+    alcohol_percentage: Mapped[float | None] = mapped_column(Float, nullable=True)
+    front_label_text: Mapped[str] = mapped_column(Text, nullable=False, default="")
+    back_label_text: Mapped[str | None] = mapped_column(Text, nullable=True)
+    front_label_image_path: Mapped[str] = mapped_column(String(512), nullable=False)
+    back_label_image_path: Mapped[str | None] = mapped_column(String(512), nullable=True)
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True),
+        server_default=func.now(),
+        nullable=False,
+    )
+    updated_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True),
+        server_default=func.now(),
+        onupdate=func.now(),
+        nullable=False,
+    )
+
+    # Relationships
+    transactions: Mapped[list["Transaction"]] = relationship(
+        "Transaction",
+        back_populates="wine",
+        cascade="all, delete-orphan",
+        order_by="Transaction.transaction_date.desc()",
+    )
+    inventory: Mapped["CellarInventory | None"] = relationship(
+        "CellarInventory",
+        back_populates="wine",
+        uselist=False,
+        cascade="all, delete-orphan",
+    )
+
+    def __repr__(self) -> str:
+        return f"<Wine(id={self.id}, name={self.name}, vintage={self.vintage})>"

winebox/routers/__init__.py

@@ -0,0 +1,5 @@
+"""API routers for WineBox."""
+
+from winebox.routers import auth, cellar, search, transactions, wines
+
+__all__ = ["auth", "wines", "cellar", "transactions", "search"]

winebox/routers/auth.py

@@ -0,0 +1,90 @@
+"""Authentication endpoints."""
+
+from datetime import datetime, timedelta, timezone
+from typing import Annotated
+
+from fastapi import APIRouter, Depends, HTTPException, status
+from fastapi.security import OAuth2PasswordRequestForm
+from pydantic import BaseModel
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from winebox.database import get_db
+from winebox.models.user import User
+from winebox.services.auth import (
+    ACCESS_TOKEN_EXPIRE_MINUTES,
+    authenticate_user,
+    create_access_token,
+    get_current_user,
+    require_auth,
+    CurrentUser,
+    RequireAuth,
+)
+
+router = APIRouter()
+
+
+class Token(BaseModel):
+    """Token response model."""
+
+    access_token: str
+    token_type: str = "bearer"
+    expires_in: int = ACCESS_TOKEN_EXPIRE_MINUTES * 60  # seconds
+
+
+class UserResponse(BaseModel):
+    """User response model."""
+
+    id: str
+    username: str
+    email: str | None
+    is_active: bool
+    is_admin: bool
+    created_at: datetime
+    last_login: datetime | None
+
+    model_config = {"from_attributes": True}
+
+
+@router.post("/token", response_model=Token)
+async def login(
+    form_data: Annotated[OAuth2PasswordRequestForm, Depends()],
+    db: Annotated[AsyncSession, Depends(get_db)],
+) -> Token:
+    """Login with username and password to get an access token."""
+    user = await authenticate_user(db, form_data.username, form_data.password)
+    if not user:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Incorrect username or password",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+
+    # Update last login time
+    user.last_login = datetime.now(timezone.utc)
+    await db.commit()
+
+    # Create access token
+    access_token = create_access_token(
+        data={"sub": user.username},
+        expires_delta=timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES),
+    )
+
+    return Token(access_token=access_token)
+
+
+@router.get("/me", response_model=UserResponse)
+async def get_current_user_info(
+    current_user: RequireAuth,
+) -> UserResponse:
+    """Get the current authenticated user's information."""
+    return UserResponse.model_validate(current_user)
+
+
+@router.post("/logout")
+async def logout() -> dict:
+    """Logout the current user.
+
+    Note: Since we use JWT tokens, logout is handled client-side
+    by discarding the token. This endpoint is provided for API completeness.
+    """
+    return {"message": "Successfully logged out"}

winebox/routers/cellar.py

@@ -0,0 +1,102 @@
+"""Cellar inventory endpoints."""
+
+from typing import Annotated
+
+from fastapi import APIRouter, Depends
+from sqlalchemy import func, select
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import selectinload
+
+from winebox.database import get_db
+from winebox.models import CellarInventory, Wine
+from winebox.schemas.wine import WineWithInventory
+from winebox.services.auth import RequireAuth
+
+router = APIRouter()
+
+
+@router.get("", response_model=list[WineWithInventory])
+async def get_cellar_inventory(
+    _: RequireAuth,
+    db: Annotated[AsyncSession, Depends(get_db)],
+    skip: int = 0,
+    limit: int = 100,
+) -> list[WineWithInventory]:
+    """Get current cellar inventory (wines in stock)."""
+    result = await db.execute(
+        select(Wine)
+        .options(selectinload(Wine.inventory))
+        .join(CellarInventory)
+        .where(CellarInventory.quantity > 0)
+        .offset(skip)
+        .limit(limit)
+        .order_by(Wine.name)
+    )
+    wines = result.scalars().all()
+
+    return [WineWithInventory.model_validate(wine) for wine in wines]
+
+
+@router.get("/summary")
+async def get_cellar_summary(
+    _: RequireAuth,
+    db: Annotated[AsyncSession, Depends(get_db)],
+) -> dict:
+    """Get cellar summary statistics."""
+    # Total bottles in cellar
+    total_bottles_result = await db.execute(
+        select(func.sum(CellarInventory.quantity)).where(CellarInventory.quantity > 0)
+    )
+    total_bottles = total_bottles_result.scalar() or 0
+
+    # Unique wines in stock
+    unique_wines_result = await db.execute(
+        select(func.count(CellarInventory.id)).where(CellarInventory.quantity > 0)
+    )
+    unique_wines = unique_wines_result.scalar() or 0
+
+    # Total wines ever tracked (including out of stock)
+    total_wines_result = await db.execute(select(func.count(Wine.id)))
+    total_wines_tracked = total_wines_result.scalar() or 0
+
+    # Wines by vintage (in stock)
+    vintage_result = await db.execute(
+        select(Wine.vintage, func.sum(CellarInventory.quantity))
+        .join(CellarInventory)
+        .where(CellarInventory.quantity > 0)
+        .where(Wine.vintage.isnot(None))
+        .group_by(Wine.vintage)
+        .order_by(Wine.vintage.desc())
+    )
+    by_vintage = {str(row[0]): row[1] for row in vintage_result.all()}
+
+    # Wines by country (in stock)
+    country_result = await db.execute(
+        select(Wine.country, func.sum(CellarInventory.quantity))
+        .join(CellarInventory)
+        .where(CellarInventory.quantity > 0)
+        .where(Wine.country.isnot(None))
+        .group_by(Wine.country)
+        .order_by(func.sum(CellarInventory.quantity).desc())
+    )
+    by_country = {row[0]: row[1] for row in country_result.all()}
+
+    # Wines by grape variety (in stock)
+    grape_result = await db.execute(
+        select(Wine.grape_variety, func.sum(CellarInventory.quantity))
+        .join(CellarInventory)
+        .where(CellarInventory.quantity > 0)
+        .where(Wine.grape_variety.isnot(None))
+        .group_by(Wine.grape_variety)
+        .order_by(func.sum(CellarInventory.quantity).desc())
+    )
+    by_grape = {row[0]: row[1] for row in grape_result.all()}
+
+    return {
+        "total_bottles": total_bottles,
+        "unique_wines": unique_wines,
+        "total_wines_tracked": total_wines_tracked,
+        "by_vintage": by_vintage,
+        "by_country": by_country,
+        "by_grape_variety": by_grape,
+    }

winebox/routers/search.py

@@ -0,0 +1,127 @@
+"""Search endpoints."""
+
+from datetime import datetime
+from typing import Annotated
+
+from fastapi import APIRouter, Depends, Query
+from sqlalchemy import and_, or_, select
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import selectinload
+
+from winebox.database import get_db
+from winebox.models import CellarInventory, Transaction, TransactionType, Wine
+from winebox.schemas.wine import WineWithInventory
+from winebox.services.auth import RequireAuth
+
+router = APIRouter()
+
+
+@router.get("", response_model=list[WineWithInventory])
+async def search_wines(
+    _: RequireAuth,
+    db: Annotated[AsyncSession, Depends(get_db)],
+    q: Annotated[str | None, Query(description="Full-text search query")] = None,
+    vintage: Annotated[int | None, Query(description="Wine vintage year")] = None,
+    grape: Annotated[str | None, Query(description="Grape variety")] = None,
+    winery: Annotated[str | None, Query(description="Winery name")] = None,
+    region: Annotated[str | None, Query(description="Wine region")] = None,
+    country: Annotated[str | None, Query(description="Country")] = None,
+    checked_in_after: Annotated[datetime | None, Query(description="Checked in after date")] = None,
+    checked_in_before: Annotated[datetime | None, Query(description="Checked in before date")] = None,
+    checked_out_after: Annotated[datetime | None, Query(description="Checked out after date")] = None,
+    checked_out_before: Annotated[datetime | None, Query(description="Checked out before date")] = None,
+    in_stock: Annotated[bool | None, Query(description="Only wines currently in stock")] = None,
+    skip: int = 0,
+    limit: int = 100,
+) -> list[WineWithInventory]:
+    """Search wines by various criteria.
+
+    Use `q` for full-text search across name, winery, region, and label text.
+    Other parameters filter on specific fields.
+    """
+    query = select(Wine).options(selectinload(Wine.inventory))
+    conditions = []
+
+    # Full-text search (simple LIKE-based search for SQLite)
+    if q:
+        search_pattern = f"%{q}%"
+        conditions.append(
+            or_(
+                Wine.name.ilike(search_pattern),
+                Wine.winery.ilike(search_pattern),
+                Wine.region.ilike(search_pattern),
+                Wine.country.ilike(search_pattern),
+                Wine.grape_variety.ilike(search_pattern),
+                Wine.front_label_text.ilike(search_pattern),
+                Wine.back_label_text.ilike(search_pattern),
+            )
+        )
+
+    # Exact/partial matches on specific fields
+    if vintage:
+        conditions.append(Wine.vintage == vintage)
+
+    if grape:
+        conditions.append(Wine.grape_variety.ilike(f"%{grape}%"))
+
+    if winery:
+        conditions.append(Wine.winery.ilike(f"%{winery}%"))
+
+    if region:
+        conditions.append(Wine.region.ilike(f"%{region}%"))
+
+    if country:
+        conditions.append(Wine.country.ilike(f"%{country}%"))
+
+    # Date-based filters (based on transactions)
+    if checked_in_after or checked_in_before:
+        # Subquery to find wines with check-in transactions in date range
+        checkin_subquery = (
+            select(Transaction.wine_id)
+            .where(Transaction.transaction_type == TransactionType.CHECK_IN)
+        )
+        if checked_in_after:
+            checkin_subquery = checkin_subquery.where(
+                Transaction.transaction_date >= checked_in_after
+            )
+        if checked_in_before:
+            checkin_subquery = checkin_subquery.where(
+                Transaction.transaction_date <= checked_in_before
+            )
+        conditions.append(Wine.id.in_(checkin_subquery))
+
+    if checked_out_after or checked_out_before:
+        # Subquery to find wines with check-out transactions in date range
+        checkout_subquery = (
+            select(Transaction.wine_id)
+            .where(Transaction.transaction_type == TransactionType.CHECK_OUT)
+        )
+        if checked_out_after:
+            checkout_subquery = checkout_subquery.where(
+                Transaction.transaction_date >= checked_out_after
+            )
+        if checked_out_before:
+            checkout_subquery = checkout_subquery.where(
+                Transaction.transaction_date <= checked_out_before
+            )
+        conditions.append(Wine.id.in_(checkout_subquery))
+
+    # Stock filter
+    if in_stock is True:
+        query = query.join(CellarInventory).where(CellarInventory.quantity > 0)
+    elif in_stock is False:
+        query = query.outerjoin(CellarInventory).where(
+            (CellarInventory.quantity == 0) | (CellarInventory.quantity.is_(None))
+        )
+
+    # Apply all conditions
+    if conditions:
+        query = query.where(and_(*conditions))
+
+    # Pagination and ordering
+    query = query.offset(skip).limit(limit).order_by(Wine.created_at.desc())
+
+    result = await db.execute(query)
+    wines = result.scalars().all()
+
+    return [WineWithInventory.model_validate(wine) for wine in wines]