winebox 0.1.0__py3-none-any.whl

winebox/routers/transactions.py

@@ -0,0 +1,63 @@
+"""Transaction history endpoints."""
+
+from typing import Annotated
+
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import selectinload
+
+from winebox.database import get_db
+from winebox.models import Transaction, TransactionType
+from winebox.schemas.transaction import TransactionResponse
+from winebox.services.auth import RequireAuth
+
+router = APIRouter()
+
+
+@router.get("", response_model=list[TransactionResponse])
+async def list_transactions(
+    _: RequireAuth,
+    db: Annotated[AsyncSession, Depends(get_db)],
+    skip: int = 0,
+    limit: int = 100,
+    transaction_type: TransactionType | None = None,
+    wine_id: str | None = None,
+) -> list[TransactionResponse]:
+    """List all transactions with optional filtering."""
+    query = select(Transaction).options(selectinload(Transaction.wine))
+
+    if transaction_type:
+        query = query.where(Transaction.transaction_type == transaction_type)
+
+    if wine_id:
+        query = query.where(Transaction.wine_id == wine_id)
+
+    query = query.offset(skip).limit(limit).order_by(Transaction.transaction_date.desc())
+    result = await db.execute(query)
+    transactions = result.scalars().all()
+
+    return [TransactionResponse.model_validate(t) for t in transactions]
+
+
+@router.get("/{transaction_id}", response_model=TransactionResponse)
+async def get_transaction(
+    transaction_id: str,
+    _: RequireAuth,
+    db: Annotated[AsyncSession, Depends(get_db)],
+) -> TransactionResponse:
+    """Get a single transaction by ID."""
+    result = await db.execute(
+        select(Transaction)
+        .options(selectinload(Transaction.wine))
+        .where(Transaction.id == transaction_id)
+    )
+    transaction = result.scalar_one_or_none()
+
+    if not transaction:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Transaction with ID {transaction_id} not found",
+        )
+
+    return TransactionResponse.model_validate(transaction)

winebox/routers/wines.py

@@ -0,0 +1,287 @@
+"""Wine management endpoints."""
+
+from typing import Annotated
+from uuid import UUID
+
+from fastapi import APIRouter, Depends, File, Form, HTTPException, UploadFile, status
+from sqlalchemy import 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 WineCreate, WineResponse, WineUpdate, WineWithInventory
+from winebox.services.auth import RequireAuth
+from winebox.services.image_storage import ImageStorageService
+from winebox.services.ocr import OCRService
+from winebox.services.wine_parser import WineParserService
+
+router = APIRouter()
+
+# Service dependencies
+image_storage = ImageStorageService()
+ocr_service = OCRService()
+wine_parser = WineParserService()
+
+
+@router.post("/checkin", response_model=WineWithInventory, status_code=status.HTTP_201_CREATED)
+async def checkin_wine(
+    _: RequireAuth,
+    db: Annotated[AsyncSession, Depends(get_db)],
+    front_label: Annotated[UploadFile, File(description="Front label image")],
+    quantity: Annotated[int, Form(ge=1, description="Number of bottles")] = 1,
+    back_label: Annotated[UploadFile | None, File(description="Back label image")] = None,
+    name: Annotated[str | None, Form(description="Wine name (auto-detected if not provided)")] = None,
+    winery: Annotated[str | None, Form()] = None,
+    vintage: Annotated[int | None, Form(ge=1900, le=2100)] = None,
+    grape_variety: Annotated[str | None, Form()] = None,
+    region: Annotated[str | None, Form()] = None,
+    country: Annotated[str | None, Form()] = None,
+    alcohol_percentage: Annotated[float | None, Form(ge=0, le=100)] = None,
+    notes: Annotated[str | None, Form(description="Check-in notes")] = None,
+) -> WineWithInventory:
+    """Check in wine bottles to the cellar.
+
+    Upload front (required) and back (optional) label images.
+    OCR will extract text and attempt to identify wine details.
+    You can override any auto-detected values.
+    """
+    # Save images
+    front_image_path = await image_storage.save_image(front_label)
+    back_image_path = None
+    if back_label and back_label.filename:
+        back_image_path = await image_storage.save_image(back_label)
+
+    # Extract text via OCR
+    front_text = await ocr_service.extract_text(front_image_path)
+    back_text = None
+    if back_image_path:
+        back_text = await ocr_service.extract_text(back_image_path)
+
+    # Parse wine details from OCR text
+    combined_text = front_text
+    if back_text:
+        combined_text = f"{front_text}\n{back_text}"
+    parsed_data = wine_parser.parse(combined_text)
+
+    # Use provided values or fall back to parsed values
+    wine_name = name or parsed_data.get("name") or "Unknown Wine"
+
+    # Create wine record
+    wine = Wine(
+        name=wine_name,
+        winery=winery or parsed_data.get("winery"),
+        vintage=vintage or parsed_data.get("vintage"),
+        grape_variety=grape_variety or parsed_data.get("grape_variety"),
+        region=region or parsed_data.get("region"),
+        country=country or parsed_data.get("country"),
+        alcohol_percentage=alcohol_percentage or parsed_data.get("alcohol_percentage"),
+        front_label_text=front_text,
+        back_label_text=back_text,
+        front_label_image_path=front_image_path,
+        back_label_image_path=back_image_path,
+    )
+    db.add(wine)
+    await db.flush()  # Get the wine ID
+
+    # Create transaction
+    transaction = Transaction(
+        wine_id=wine.id,
+        transaction_type=TransactionType.CHECK_IN,
+        quantity=quantity,
+        notes=notes,
+    )
+    db.add(transaction)
+
+    # Create or update inventory
+    inventory = CellarInventory(
+        wine_id=wine.id,
+        quantity=quantity,
+    )
+    db.add(inventory)
+
+    await db.commit()
+
+    # Re-query with eager loading for relationships
+    result = await db.execute(
+        select(Wine)
+        .options(selectinload(Wine.inventory))
+        .where(Wine.id == wine.id)
+    )
+    wine = result.scalar_one()
+
+    return WineWithInventory.model_validate(wine)
+
+
+@router.post("/{wine_id}/checkout", response_model=WineWithInventory)
+async def checkout_wine(
+    wine_id: str,
+    _: RequireAuth,
+    db: Annotated[AsyncSession, Depends(get_db)],
+    quantity: Annotated[int, Form(ge=1, description="Number of bottles to remove")] = 1,
+    notes: Annotated[str | None, Form(description="Check-out notes")] = None,
+) -> WineWithInventory:
+    """Check out wine bottles from the cellar.
+
+    Remove bottles from inventory. If quantity reaches 0, the wine
+    remains in history but shows as out of stock.
+    """
+    # Get wine with inventory
+    result = await db.execute(
+        select(Wine)
+        .options(selectinload(Wine.inventory))
+        .where(Wine.id == wine_id)
+    )
+    wine = result.scalar_one_or_none()
+
+    if not wine:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Wine with ID {wine_id} not found",
+        )
+
+    if not wine.inventory or wine.inventory.quantity < quantity:
+        available = wine.inventory.quantity if wine.inventory else 0
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=f"Not enough bottles in stock. Available: {available}, Requested: {quantity}",
+        )
+
+    # Create transaction
+    transaction = Transaction(
+        wine_id=wine.id,
+        transaction_type=TransactionType.CHECK_OUT,
+        quantity=quantity,
+        notes=notes,
+    )
+    db.add(transaction)
+
+    # Update inventory
+    wine.inventory.quantity -= quantity
+
+    await db.commit()
+
+    # Re-query with eager loading for relationships
+    result = await db.execute(
+        select(Wine)
+        .options(selectinload(Wine.inventory))
+        .where(Wine.id == wine_id)
+    )
+    wine = result.scalar_one()
+
+    return WineWithInventory.model_validate(wine)
+
+
+@router.get("", response_model=list[WineWithInventory])
+async def list_wines(
+    _: RequireAuth,
+    db: Annotated[AsyncSession, Depends(get_db)],
+    skip: int = 0,
+    limit: int = 100,
+    in_stock: bool | None = None,
+) -> list[WineWithInventory]:
+    """List all wines with optional filtering."""
+    query = select(Wine).options(selectinload(Wine.inventory))
+
+    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))
+        )
+
+    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]
+
+
+@router.get("/{wine_id}", response_model=WineResponse)
+async def get_wine(
+    wine_id: str,
+    _: RequireAuth,
+    db: Annotated[AsyncSession, Depends(get_db)],
+) -> WineResponse:
+    """Get wine details with full transaction history."""
+    result = await db.execute(
+        select(Wine)
+        .options(
+            selectinload(Wine.inventory),
+            selectinload(Wine.transactions),
+        )
+        .where(Wine.id == wine_id)
+    )
+    wine = result.scalar_one_or_none()
+
+    if not wine:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Wine with ID {wine_id} not found",
+        )
+
+    return WineResponse.model_validate(wine)
+
+
+@router.put("/{wine_id}", response_model=WineWithInventory)
+async def update_wine(
+    wine_id: str,
+    _: RequireAuth,
+    wine_update: WineUpdate,
+    db: Annotated[AsyncSession, Depends(get_db)],
+) -> WineWithInventory:
+    """Update wine metadata."""
+    result = await db.execute(
+        select(Wine)
+        .options(selectinload(Wine.inventory))
+        .where(Wine.id == wine_id)
+    )
+    wine = result.scalar_one_or_none()
+
+    if not wine:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Wine with ID {wine_id} not found",
+        )
+
+    # Update only provided fields
+    update_data = wine_update.model_dump(exclude_unset=True)
+    for field, value in update_data.items():
+        setattr(wine, field, value)
+
+    await db.commit()
+
+    # Re-query with eager loading for relationships
+    result = await db.execute(
+        select(Wine)
+        .options(selectinload(Wine.inventory))
+        .where(Wine.id == wine_id)
+    )
+    wine = result.scalar_one()
+
+    return WineWithInventory.model_validate(wine)
+
+
+@router.delete("/{wine_id}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_wine(
+    wine_id: str,
+    _: RequireAuth,
+    db: Annotated[AsyncSession, Depends(get_db)],
+) -> None:
+    """Delete wine and all associated history."""
+    result = await db.execute(select(Wine).where(Wine.id == wine_id))
+    wine = result.scalar_one_or_none()
+
+    if not wine:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Wine with ID {wine_id} not found",
+        )
+
+    # Delete associated images
+    await image_storage.delete_image(wine.front_label_image_path)
+    if wine.back_label_image_path:
+        await image_storage.delete_image(wine.back_label_image_path)
+
+    await db.delete(wine)
+    await db.commit()

winebox/schemas/__init__.py

@@ -0,0 +1,13 @@
+"""Pydantic schemas for WineBox API."""
+
+from winebox.schemas.transaction import TransactionCreate, TransactionResponse
+from winebox.schemas.wine import WineCreate, WineResponse, WineUpdate, WineWithInventory
+
+__all__ = [
+    "WineCreate",
+    "WineUpdate",
+    "WineResponse",
+    "WineWithInventory",
+    "TransactionCreate",
+    "TransactionResponse",
+]

winebox/schemas/transaction.py

@@ -0,0 +1,40 @@
+"""Pydantic schemas for Transaction model."""
+
+from datetime import datetime
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from winebox.models.transaction import TransactionType
+
+
+class TransactionCreate(BaseModel):
+    """Schema for creating a transaction."""
+
+    quantity: int = Field(..., ge=1)
+    notes: str | None = None
+
+
+class WineBasicInfo(BaseModel):
+    """Basic wine info for transaction response."""
+
+    id: str
+    name: str
+    vintage: int | None = None
+    winery: str | None = None
+
+    model_config = ConfigDict(from_attributes=True)
+
+
+class TransactionResponse(BaseModel):
+    """Schema for transaction response."""
+
+    id: str
+    wine_id: str
+    transaction_type: TransactionType
+    quantity: int
+    notes: str | None
+    transaction_date: datetime
+    created_at: datetime
+    wine: WineBasicInfo | None = None
+
+    model_config = ConfigDict(from_attributes=True)

winebox/schemas/wine.py

@@ -0,0 +1,79 @@
+"""Pydantic schemas for Wine model."""
+
+from datetime import datetime
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from winebox.schemas.transaction import TransactionResponse
+
+
+class WineBase(BaseModel):
+    """Base wine schema with common fields."""
+
+    name: str = Field(..., min_length=1, max_length=255)
+    winery: str | None = Field(None, max_length=255)
+    vintage: int | None = Field(None, ge=1900, le=2100)
+    grape_variety: str | None = Field(None, max_length=255)
+    region: str | None = Field(None, max_length=255)
+    country: str | None = Field(None, max_length=255)
+    alcohol_percentage: float | None = Field(None, ge=0, le=100)
+
+
+class WineCreate(WineBase):
+    """Schema for creating a wine (via form, not direct JSON)."""
+
+    pass
+
+
+class WineUpdate(BaseModel):
+    """Schema for updating wine metadata."""
+
+    name: str | None = Field(None, min_length=1, max_length=255)
+    winery: str | None = Field(None, max_length=255)
+    vintage: int | None = Field(None, ge=1900, le=2100)
+    grape_variety: str | None = Field(None, max_length=255)
+    region: str | None = Field(None, max_length=255)
+    country: str | None = Field(None, max_length=255)
+    alcohol_percentage: float | None = Field(None, ge=0, le=100)
+
+
+class InventoryInfo(BaseModel):
+    """Schema for inventory information."""
+
+    quantity: int = Field(..., ge=0)
+    updated_at: datetime
+
+    model_config = ConfigDict(from_attributes=True)
+
+
+class WineWithInventory(WineBase):
+    """Wine schema with current inventory."""
+
+    id: str
+    front_label_text: str
+    back_label_text: str | None
+    front_label_image_path: str
+    back_label_image_path: str | None
+    created_at: datetime
+    updated_at: datetime
+    inventory: InventoryInfo | None = None
+
+    model_config = ConfigDict(from_attributes=True)
+
+    @property
+    def current_quantity(self) -> int:
+        """Get current quantity in stock."""
+        return self.inventory.quantity if self.inventory else 0
+
+    @property
+    def in_stock(self) -> bool:
+        """Check if wine is in stock."""
+        return self.current_quantity > 0
+
+
+class WineResponse(WineWithInventory):
+    """Full wine response with transaction history."""
+
+    transactions: list[TransactionResponse] = []
+
+    model_config = ConfigDict(from_attributes=True)

winebox/services/__init__.py

@@ -0,0 +1,7 @@
+"""Services for WineBox application."""
+
+from winebox.services.image_storage import ImageStorageService
+from winebox.services.ocr import OCRService
+from winebox.services.wine_parser import WineParserService
+
+__all__ = ["ImageStorageService", "OCRService", "WineParserService"]

winebox/services/auth.py

@@ -0,0 +1,123 @@
+"""Authentication service for user management and JWT tokens."""
+
+import secrets
+from datetime import datetime, timedelta, timezone
+from typing import Annotated
+
+from fastapi import Depends, HTTPException, status
+from fastapi.security import HTTPBasic, HTTPBasicCredentials, OAuth2PasswordBearer
+from jose import JWTError, jwt
+from passlib.context import CryptContext
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from winebox.config import settings
+from winebox.database import get_db
+from winebox.models.user import User
+
+# Password hashing context
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+
+# OAuth2 scheme for token authentication
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/api/auth/token", auto_error=False)
+
+# HTTP Basic auth scheme (for login form)
+http_basic = HTTPBasic(auto_error=False)
+
+# JWT settings
+ALGORITHM = "HS256"
+ACCESS_TOKEN_EXPIRE_MINUTES = 60 * 24  # 24 hours
+
+
+def verify_password(plain_password: str, hashed_password: str) -> bool:
+    """Verify a password against its hash."""
+    return pwd_context.verify(plain_password, hashed_password)
+
+
+def get_password_hash(password: str) -> str:
+    """Hash a password."""
+    return pwd_context.hash(password)
+
+
+def create_access_token(data: dict, expires_delta: timedelta | None = None) -> str:
+    """Create a JWT access token."""
+    to_encode = data.copy()
+    if expires_delta:
+        expire = datetime.now(timezone.utc) + expires_delta
+    else:
+        expire = datetime.now(timezone.utc) + timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
+    to_encode.update({"exp": expire})
+    encoded_jwt = jwt.encode(to_encode, settings.secret_key, algorithm=ALGORITHM)
+    return encoded_jwt
+
+
+async def get_user_by_username(db: AsyncSession, username: str) -> User | None:
+    """Get a user by username."""
+    result = await db.execute(select(User).where(User.username == username))
+    return result.scalar_one_or_none()
+
+
+async def authenticate_user(db: AsyncSession, username: str, password: str) -> User | None:
+    """Authenticate a user with username and password."""
+    user = await get_user_by_username(db, username)
+    if not user:
+        return None
+    if not verify_password(password, user.hashed_password):
+        return None
+    if not user.is_active:
+        return None
+    return user
+
+
+async def get_current_user(
+    token: Annotated[str | None, Depends(oauth2_scheme)],
+    db: Annotated[AsyncSession, Depends(get_db)],
+) -> User | None:
+    """Get the current user from the JWT token."""
+    if not token:
+        return None
+
+    try:
+        payload = jwt.decode(token, settings.secret_key, algorithms=[ALGORITHM])
+        username: str | None = payload.get("sub")
+        if username is None:
+            return None
+    except JWTError:
+        return None
+
+    user = await get_user_by_username(db, username)
+    if user is None or not user.is_active:
+        return None
+
+    return user
+
+
+async def require_auth(
+    user: Annotated[User | None, Depends(get_current_user)],
+) -> User:
+    """Require authentication - raises 401 if not authenticated."""
+    if user is None:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Not authenticated",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+    return user
+
+
+async def require_admin(
+    user: Annotated[User, Depends(require_auth)],
+) -> User:
+    """Require admin privileges."""
+    if not user.is_admin:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Admin privileges required",
+        )
+    return user
+
+
+# Type aliases for dependency injection
+CurrentUser = Annotated[User | None, Depends(get_current_user)]
+RequireAuth = Annotated[User, Depends(require_auth)]
+RequireAdmin = Annotated[User, Depends(require_admin)]