PyPI - bbannotate - Versions diffs - 1.0.0__py3-none-any.whl - Mend

bbannotate 1.0.0__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (21) hide show

bbannotate-1.0.0.dist-info/METADATA +182 -0
bbannotate-1.0.0.dist-info/RECORD +21 -0
bbannotate-1.0.0.dist-info/WHEEL +4 -0
bbannotate-1.0.0.dist-info/entry_points.txt +2 -0
bbannotate-1.0.0.dist-info/licenses/LICENSE +21 -0
src/__init__.py +4 -0
src/api/__init__.py +5 -0
src/api/routes.py +339 -0
src/cli.py +263 -0
src/frontend_dist/assets/index-DFfgJzXo.css +1 -0
src/frontend_dist/assets/index-DezlWFbC.js +89 -0
src/frontend_dist/index.html +20 -0
src/frontend_dist/logo.png +0 -0
src/main.py +90 -0
src/models/__init__.py +21 -0
src/models/annotations.py +62 -0
src/py.typed +0 -0
src/services/__init__.py +6 -0
src/services/annotation_service.py +307 -0
src/services/export_service.py +488 -0
src/services/project_service.py +203 -0

src/frontend_dist/index.html ADDED Viewed

@@ -0,0 +1,20 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <script>
+      if (localStorage.getItem('darkMode') === 'true' ||
+          (!localStorage.getItem('darkMode') && window.matchMedia('(prefers-color-scheme: dark)').matches)) {
+        document.documentElement.classList.add('dark');
+      }
+    </script>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Bounding Box Annotation Tool</title>
+    <script type="module" crossorigin src="/assets/index-DezlWFbC.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-DFfgJzXo.css">
+  </head>
+  <body>
+    <div id="root"></div>
+  </body>
+</html>

src/frontend_dist/logo.png ADDED Viewed

Binary file

src/main.py ADDED Viewed

@@ -0,0 +1,90 @@
+"""FastAPI application entry point for the annotation tool."""
+import os
+from pathlib import Path
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+from src import __version__
+from src.api.routes import get_data_dir, router
+def _find_frontend_dist() -> Path | None:
+    """Find the frontend dist directory.
+    Checks in order:
+    1. Bundled with package (src/frontend_dist) - for pip install
+    2. Relative to package (frontend/dist) - for development
+    """
+    # Check bundled location (pip install includes frontend_dist in src/)
+    package_dir = Path(__file__).parent
+    bundled_path = package_dir / "frontend_dist"
+    if bundled_path.exists() and (bundled_path / "index.html").exists():
+        return bundled_path
+    # Check relative to package root (development mode with frontend/dist)
+    dev_path = package_dir.parent / "frontend" / "dist"
+    if dev_path.exists() and (dev_path / "index.html").exists():
+        return dev_path
+    return None
+# Create FastAPI app
+app = FastAPI(
+    title="Bounding Box Annotation Tool",
+    description="A lightweight annotation tool for grocery flyer product detection",
+    version=__version__,
+)
+# Configure CORS for frontend development
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=[
+        "http://localhost:5173",  # Vite dev server
+        "http://localhost:3000",
+        "http://127.0.0.1:5173",
+        "http://127.0.0.1:3000",
+    ],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+# Include API routes
+app.include_router(router, prefix="/api")
+# Ensure data directory exists
+get_data_dir().mkdir(parents=True, exist_ok=True)
+# Serve frontend static files in production
+FRONTEND_DIST = _find_frontend_dist()
+if FRONTEND_DIST:
+    app.mount("/", StaticFiles(directory=FRONTEND_DIST, html=True), name="frontend")
+@app.get("/health")
+def health_check() -> dict[str, str]:
+    """Health check endpoint."""
+    return {"status": "healthy"}
+def main() -> None:
+    """Run the development server."""
+    import uvicorn
+    host = os.getenv("HOST", "127.0.0.1")
+    port = int(os.getenv("PORT", "8000"))
+    uvicorn.run(
+        "src.main:app",
+        host=host,
+        port=port,
+        reload=True,
+    )
+if __name__ == "__main__":
+    main()

src/models/__init__.py ADDED Viewed

@@ -0,0 +1,21 @@
+"""Data models for the annotation tool."""
+from src.models.annotations import (
+    Annotation,
+    AnnotationCreate,
+    AnnotationUpdate,
+    BoundingBox,
+    ImageInfo,
+    ImageMetadata,
+    ProjectInfo,
+)
+__all__ = [
+    "Annotation",
+    "AnnotationCreate",
+    "AnnotationUpdate",
+    "BoundingBox",
+    "ImageInfo",
+    "ImageMetadata",
+    "ProjectInfo",
+]

src/models/annotations.py ADDED Viewed

@@ -0,0 +1,62 @@
+"""Pydantic models for annotation data."""
+from pydantic import BaseModel, Field
+class BoundingBox(BaseModel):
+    """Represents a bounding box with normalized coordinates (0-1)."""
+    x: float = Field(..., ge=0, le=1, description="Center X coordinate (normalized)")
+    y: float = Field(..., ge=0, le=1, description="Center Y coordinate (normalized)")
+    width: float = Field(..., ge=0, le=1, description="Box width (normalized)")
+    height: float = Field(..., ge=0, le=1, description="Box height (normalized)")
+class Annotation(BaseModel):
+    """A single annotation with bounding box and label."""
+    id: str = Field(..., description="Unique identifier for the annotation")
+    label: str = Field(..., description="Class label for the annotation")
+    class_id: int = Field(..., ge=0, description="Numeric class ID for YOLO export")
+    bbox: BoundingBox = Field(..., description="Bounding box coordinates")
+class AnnotationCreate(BaseModel):
+    """Request model for creating an annotation."""
+    label: str = Field(..., min_length=1, description="Class label")
+    class_id: int = Field(..., ge=0, description="Numeric class ID")
+    bbox: BoundingBox
+class AnnotationUpdate(BaseModel):
+    """Request model for updating an annotation."""
+    label: str | None = Field(None, min_length=1)
+    class_id: int | None = Field(None, ge=0)
+    bbox: BoundingBox | None = None
+class ImageInfo(BaseModel):
+    """Basic image information."""
+    filename: str
+    width: int
+    height: int
+class ImageMetadata(BaseModel):
+    """Complete metadata for an annotated image."""
+    image: ImageInfo
+    annotations: list[Annotation] = Field(default_factory=list)
+class ProjectInfo(BaseModel):
+    """Project-level information."""
+    name: str = Field(default="grocery-flyer-annotations")
+    labels: list[str] = Field(default_factory=list)
+    image_count: int = 0
+    annotation_count: int = 0
+    annotated_image_count: int = 0

src/py.typed ADDED Viewed

File without changes

src/services/__init__.py ADDED Viewed

@@ -0,0 +1,6 @@
+"""Services for the annotation tool."""
+from src.services.annotation_service import AnnotationService
+from src.services.export_service import ExportService
+__all__ = ["AnnotationService", "ExportService"]

src/services/annotation_service.py ADDED Viewed

@@ -0,0 +1,307 @@
+"""Service for managing annotations and images."""
+import json
+import shutil
+import uuid
+from pathlib import Path
+from PIL import Image
+from src.models.annotations import (
+    Annotation,
+    AnnotationCreate,
+    AnnotationUpdate,
+    ImageInfo,
+    ImageMetadata,
+    ProjectInfo,
+)
+class AnnotationService:
+    """Handles image and annotation storage operations."""
+    def __init__(self, data_dir: Path) -> None:
+        """Initialize the annotation service.
+        Args:
+            data_dir: Root directory for storing images and annotations.
+        """
+        self.data_dir = data_dir
+        self.images_dir = data_dir / "images"
+        self.annotations_dir = data_dir / "annotations"
+        self._ensure_directories()
+    def _ensure_directories(self) -> None:
+        """Create necessary directories if they don't exist."""
+        self.data_dir.mkdir(parents=True, exist_ok=True)
+        self.images_dir.mkdir(exist_ok=True)
+        self.annotations_dir.mkdir(exist_ok=True)
+    def _get_annotation_path(self, image_filename: str) -> Path:
+        """Get the path to the annotation JSON file for an image."""
+        stem = Path(image_filename).stem
+        return self.annotations_dir / f"{stem}.json"
+    def _load_metadata(self, image_filename: str) -> ImageMetadata | None:
+        """Load metadata for an image from JSON file."""
+        annotation_path = self._get_annotation_path(image_filename)
+        if not annotation_path.exists():
+            return None
+        with annotation_path.open("r") as f:
+            data = json.load(f)
+        return ImageMetadata.model_validate(data)
+    def _save_metadata(self, metadata: ImageMetadata) -> None:
+        """Save metadata to JSON file."""
+        annotation_path = self._get_annotation_path(metadata.image.filename)
+        with annotation_path.open("w") as f:
+            json.dump(metadata.model_dump(), f, indent=2)
+    def get_project_info(self) -> ProjectInfo:
+        """Get project-level statistics and label information."""
+        labels: set[str] = set()
+        total_annotations = 0
+        image_count = 0
+        annotated_image_count = 0
+        for annotation_file in self.annotations_dir.glob("*.json"):
+            with annotation_file.open("r") as f:
+                data = json.load(f)
+            metadata = ImageMetadata.model_validate(data)
+            image_count += 1
+            annotation_count = len(metadata.annotations)
+            total_annotations += annotation_count
+            if annotation_count > 0:
+                annotated_image_count += 1
+            for ann in metadata.annotations:
+                labels.add(ann.label)
+        return ProjectInfo(
+            labels=sorted(labels),
+            image_count=image_count,
+            annotation_count=total_annotations,
+            annotated_image_count=annotated_image_count,
+        )
+    def list_images(self) -> list[str]:
+        """List all image filenames in the project."""
+        extensions = {".jpg", ".jpeg", ".png", ".webp", ".bmp"}
+        images = []
+        for img_path in self.images_dir.iterdir():
+            if img_path.suffix.lower() in extensions:
+                images.append(img_path.name)
+        return sorted(images)
+    def upload_image(self, filename: str, content: bytes) -> ImageInfo:
+        """Upload and store an image.
+        Args:
+            filename: Original filename.
+            content: Image file bytes.
+        Returns:
+            ImageInfo with dimensions.
+        Raises:
+            ValueError: If the file is not a valid image.
+        """
+        # Validate and get image dimensions
+        from io import BytesIO
+        try:
+            img = Image.open(BytesIO(content))
+            img.verify()  # Verify it's a valid image
+            img = Image.open(BytesIO(content))  # Re-open after verify
+            width, height = img.size
+        except Exception as err:
+            raise ValueError(f"Invalid image file: {err}") from err
+        # Save image
+        safe_filename = Path(filename).name  # Prevent path traversal
+        image_path = self.images_dir / safe_filename
+        # Handle duplicate filenames
+        if image_path.exists():
+            stem = image_path.stem
+            suffix = image_path.suffix
+            counter = 1
+            while image_path.exists():
+                safe_filename = f"{stem}_{counter}{suffix}"
+                image_path = self.images_dir / safe_filename
+                counter += 1
+        image_path.write_bytes(content)
+        # Create initial metadata
+        image_info = ImageInfo(filename=safe_filename, width=width, height=height)
+        metadata = ImageMetadata(image=image_info, annotations=[])
+        self._save_metadata(metadata)
+        return image_info
+    def get_image_path(self, filename: str) -> Path | None:
+        """Get the full path to an image file."""
+        path = self.images_dir / filename
+        if path.exists() and path.is_file():
+            return path
+        return None
+    def delete_image(self, filename: str) -> bool:
+        """Delete an image and its annotations."""
+        image_path = self.images_dir / filename
+        annotation_path = self._get_annotation_path(filename)
+        deleted = False
+        if image_path.exists():
+            image_path.unlink()
+            deleted = True
+        if annotation_path.exists():
+            annotation_path.unlink()
+            deleted = True
+        return deleted
+    def get_annotations(self, image_filename: str) -> list[Annotation]:
+        """Get all annotations for an image."""
+        metadata = self._load_metadata(image_filename)
+        if metadata is None:
+            return []
+        return metadata.annotations
+    def add_annotation(
+        self, image_filename: str, annotation: AnnotationCreate
+    ) -> Annotation:
+        """Add a new annotation to an image.
+        Args:
+            image_filename: The image to annotate.
+            annotation: The annotation data.
+        Returns:
+            The created annotation with generated ID.
+        Raises:
+            FileNotFoundError: If the image doesn't exist.
+        """
+        metadata = self._load_metadata(image_filename)
+        if metadata is None:
+            image_path = self.images_dir / image_filename
+            if not image_path.exists():
+                raise FileNotFoundError(f"Image not found: {image_filename}")
+            # Create metadata if missing
+            img = Image.open(image_path)
+            image_info = ImageInfo(
+                filename=image_filename, width=img.width, height=img.height
+            )
+            metadata = ImageMetadata(image=image_info, annotations=[])
+        new_annotation = Annotation(
+            id=str(uuid.uuid4()),
+            label=annotation.label,
+            class_id=annotation.class_id,
+            bbox=annotation.bbox,
+        )
+        metadata.annotations.append(new_annotation)
+        self._save_metadata(metadata)
+        return new_annotation
+    def update_annotation(
+        self, image_filename: str, annotation_id: str, update: AnnotationUpdate
+    ) -> Annotation | None:
+        """Update an existing annotation."""
+        metadata = self._load_metadata(image_filename)
+        if metadata is None:
+            return None
+        for i, ann in enumerate(metadata.annotations):
+            if ann.id == annotation_id:
+                updated_data = ann.model_dump()
+                update_dict = update.model_dump(exclude_none=True)
+                updated_data.update(update_dict)
+                metadata.annotations[i] = Annotation.model_validate(updated_data)
+                self._save_metadata(metadata)
+                return metadata.annotations[i]
+        return None
+    def delete_annotation(self, image_filename: str, annotation_id: str) -> bool:
+        """Delete an annotation from an image."""
+        metadata = self._load_metadata(image_filename)
+        if metadata is None:
+            return False
+        original_count = len(metadata.annotations)
+        metadata.annotations = [
+            ann for ann in metadata.annotations if ann.id != annotation_id
+        ]
+        if len(metadata.annotations) < original_count:
+            self._save_metadata(metadata)
+            return True
+        return False
+    def clear_annotations(self, image_filename: str) -> int:
+        """Clear all annotations for an image."""
+        metadata = self._load_metadata(image_filename)
+        if metadata is None:
+            return 0
+        count = len(metadata.annotations)
+        metadata.annotations = []
+        self._save_metadata(metadata)
+        return count
+    def copy_annotations(self, source_filename: str, target_filename: str) -> int:
+        """Copy annotations from one image to another.
+        Useful for batch operations on similar flyer pages.
+        """
+        source_metadata = self._load_metadata(source_filename)
+        if source_metadata is None:
+            return 0
+        target_metadata = self._load_metadata(target_filename)
+        if target_metadata is None:
+            return 0
+        # Generate new IDs for copied annotations
+        copied_annotations = []
+        for ann in source_metadata.annotations:
+            copied = Annotation(
+                id=str(uuid.uuid4()),
+                label=ann.label,
+                class_id=ann.class_id,
+                bbox=ann.bbox,
+            )
+            copied_annotations.append(copied)
+        target_metadata.annotations.extend(copied_annotations)
+        self._save_metadata(target_metadata)
+        return len(copied_annotations)
+    def backup_project(self, backup_path: Path) -> Path:
+        """Create a backup of the entire project.
+        Only backs up the images and annotations directories to avoid
+        infinite recursion when backup_path is inside data_dir.
+        """
+        backup_path.mkdir(parents=True, exist_ok=True)
+        backup_dir = backup_path / f"backup_{uuid.uuid4().hex[:8]}"
+        backup_dir.mkdir(parents=True, exist_ok=True)
+        # Copy only images and annotations directories
+        if self.images_dir.exists():
+            shutil.copytree(self.images_dir, backup_dir / "images")
+        else:
+            (backup_dir / "images").mkdir()
+        if self.annotations_dir.exists():
+            shutil.copytree(self.annotations_dir, backup_dir / "annotations")
+        else:
+            (backup_dir / "annotations").mkdir()
+        return backup_dir