feat: add labeling template. refactor: switch to Poetry, build and deploy of backend Python (#79)

* feat: Enhance annotation module with template management and validation

- Added DatasetMappingCreateRequest and DatasetMappingUpdateRequest schemas to handle dataset mapping requests with camelCase and snake_case support.
- Introduced Annotation Template schemas including CreateAnnotationTemplateRequest, UpdateAnnotationTemplateRequest, and AnnotationTemplateResponse for managing annotation templates.
- Implemented AnnotationTemplateService for creating, updating, retrieving, and deleting annotation templates, including validation of configurations and XML generation.
- Added utility class LabelStudioConfigValidator for validating Label Studio configurations and XML formats.
- Updated database schema for annotation templates and labeling projects to include new fields and constraints.
- Seeded initial annotation templates for various use cases including image classification, object detection, and text classification.

* feat: Enhance TemplateForm with improved validation and dynamic field rendering; update LabelStudio config validation for camelCase support

* feat: Update docker-compose.yml to mark datamate dataset volume and network as external

* feat: Add tag configuration management and related components

- Introduced new components for tag selection and browsing in the frontend.
- Added API endpoint to fetch tag configuration from the backend.
- Implemented tag configuration management in the backend, including loading from YAML.
- Enhanced template service to support dynamic tag rendering based on configuration.
- Updated validation utilities to incorporate tag configuration checks.
- Refactored existing code to utilize the new tag configuration structure.

* feat: Refactor LabelStudioTagConfig for improved configuration loading and validation

* feat: Update Makefile to include backend-python-docker-build in the build process

* feat: Migrate to poetry for better deps management

* Add pyyaml dependency and update Dockerfile to use Poetry for dependency management

- Added pyyaml (>=6.0.3,<7.0.0) to pyproject.toml dependencies.
- Updated Dockerfile to install Poetry and manage dependencies using it.
- Improved layer caching by copying only dependency files before the application code.
- Removed unnecessary installation of build dependencies to keep the final image size small.

* feat: Remove duplicated backend-python-docker-build target from Makefile

* fix: airflow is not ready for adding yet

* feat: update Python version to 3.12 and remove project installation step in Dockerfile

scripts/images/datamate-python/Dockerfile

@@ -1,31 +1,38 @@
-FROM python:3.11-slim
+FROM python:3.12-slim
 
 # Single-stage image with build cache optimization using BuildKit cache mounts.
 # Note: to use the cache mount syntax you must build with BuildKit enabled:
 # DOCKER_BUILDKIT=1 docker build . -f scripts/images/datamate-python/Dockerfile -t datamate-backend-python
 
 ENV PYTHONDONTWRITEBYTECODE=1 \
-    PYTHONUNBUFFERED=1
+    PYTHONUNBUFFERED=1 \
+    # Poetry configuration
+    POETRY_VERSION=2.2.1 \
+    POETRY_NO_INTERACTION=1 \
+    POETRY_VIRTUALENVS_CREATE=false \
+    POETRY_CACHE_DIR=/tmp/poetry_cache
+
+ENV PATH="/root/.local/bin:$PATH"
 
 WORKDIR /app
 
-# Install build deps needed to compile some wheels. We'll remove them afterwards to keep the
-# final image small. Use --no-install-recommends to minimize installed packages.
-# RUN apt-get update \
-#     && apt-get install -y --no-install-recommends \
-#         build-essential \
-#         gcc \
-#     && apt-get purge -y --auto-remove build-essential gcc \
-#     && rm -rf /var/lib/apt/lists/*
-
-# Copy requirements first (leverages layer caching when requirements don't change)
-COPY runtime/datamate-python /app
-
-# Install Python deps. Use BuildKit cache mount for pip cache to speed subsequent builds.
-# The --mount=type=cache requires BuildKit. This keeps downloaded wheels/cache out of the final image.
+# Install Poetry via pipx as Poetry officially recommends
 RUN --mount=type=cache,target=/root/.cache/pip \
-    pip install --upgrade --root-user-action=ignore pip setuptools wheel \
-    && pip install --root-user-action=ignore -r /app/requirements.txt
+    pip install --upgrade --root-user-action=ignore pip \
+    && pip install --root-user-action=ignore pipx \
+    && pipx install "poetry==$POETRY_VERSION"
+
+# Copy only dependency files first (leverages layer caching when dependencies don't change)
+COPY runtime/datamate-python/pyproject.toml runtime/datamate-python/poetry.lock* /app/
+
+# Install dependencies using Poetry with cache mount
+# --no-root: don't install the project itself yet (only dependencies)
+# --only main: only install main dependencies, not dev dependencies
+RUN --mount=type=cache,target=$POETRY_CACHE_DIR \
+    poetry install --no-root --only main
+
+# Copy the rest of the application
+COPY runtime/datamate-python /app
 
 COPY runtime/datamate-python/deploy/docker-entrypoint.sh /docker-entrypoint.sh
 RUN chmod +x /docker-entrypoint.sh || true