LABIMP-7672 | Video Keyframe upload

.flake8

@@ -1,4 +1,4 @@
 [flake8]
 max-line-length = 200
 extend-ignore = E203, W503, E402, F405
-exclude = .git,__pycache__,.venv,build,dist,venv,driver.py
+exclude = .git,__pycache__,.venv,build,dist,venv,driver.py,.history

.github/workflows/claude-code-review.yml

@@ -2,9 +2,13 @@ name: Claude Auto Review
 on:
   pull_request:
     types: [opened, synchronize]
+    paths-ignore:
+      - "**/*.md"
+      - "docs/**"
 
 jobs:
   review:
+    if: github.event.pull_request.update_count < 3
     runs-on: ubuntu-latest
     permissions:
       contents: read
@@ -31,7 +35,7 @@ jobs:
             - Security concerns
             - Test coverage
             - Code repeatability
-            - Over engineering  
+            - Over engineering
 
             Note: The PR branch is already checked out in the current working directory.
 
@@ -40,4 +44,4 @@ jobs:
             Only post GitHub comments - don't submit review text as messages.
 
           claude_args: |
-            --allowedTools "mcp__github_inline_comment__create_inline_comment,Bash(gh pr comment:*),Bash(gh pr diff:*),Bash(gh pr view:*)"
+            --allowedTools "mcp__github_inline_comment__create_inline_comment,Bash(gh pr comment:*),Bash(gh pr diff:*),Bash(gh pr view:*)"

.gitignore

@@ -30,3 +30,4 @@ download
 labellerr/__pycache__/
 env.*
 claude.md
+.history/

labellerr/core/annotation_templates/__init__.py

@@ -1,8 +1,15 @@
-from .base import LabellerrAnnotationTemplate
-from ..schemas.annotation_templates import CreateTemplateParams, QuestionType, Option
+import uuid
+from typing import List
+
 from .. import constants
 from ..client import LabellerrClient
-import uuid
+from ..schemas.annotation_templates import (
+    CreateTemplateParams,
+    DatasetDataType,
+    Option,
+    QuestionType,
+)
+from .base import LabellerrAnnotationTemplate
 
 __all__ = [
     "LabellerrAnnotationTemplate",
@@ -62,3 +69,59 @@ def create_template(
         client=client,
         annotation_template_id=response.get("response", None).get("template_id"),
     )
+
+
+def list_templates(
+    client: LabellerrClient, data_type: DatasetDataType
+) -> List[LabellerrAnnotationTemplate]:
+    """
+    List all annotation templates for a given data type
+
+    :param client: The client to use for the request.
+    :param data_type: The data type to list templates for.
+    :return: A list of LabellerrAnnotationTemplate instances.
+    """
+    unique_id = str(uuid.uuid4())
+    url = (
+        f"{constants.BASE_URL}/annotations/list_questions_templates?client_id={client.client_id}&data_type={data_type.value}"
+        f"&uuid={unique_id}"
+    )
+
+    response = client.make_request(
+        "GET",
+        url,
+        extra_headers={"content-type": "application/json"},
+        request_id=unique_id,
+    )
+    return [
+        LabellerrAnnotationTemplate.from_annotation_template_data(client, **item)
+        for item in response.get("response", [])
+    ]
+
+
+def list_templates(
+    client: LabellerrClient, data_type: DatasetDataType
+) -> List[LabellerrAnnotationTemplate]:
+    """
+    List all annotation templates for a given data type
+
+    :param client: The client to use for the request.
+    :param data_type: The data type to list templates for.
+    :return: A list of LabellerrAnnotationTemplate instances.
+    """
+    unique_id = str(uuid.uuid4())
+    url = (
+        f"{constants.BASE_URL}/annotations/list_questions_templates?client_id={client.client_id}&data_type={data_type.value}"
+        f"&uuid={unique_id}"
+    )
+
+    response = client.make_request(
+        "GET",
+        url,
+        extra_headers={"content-type": "application/json"},
+        request_id=unique_id,
+    )
+    return [
+        LabellerrAnnotationTemplate.from_annotation_template_data(client, **item)
+        for item in response.get("response", [])
+    ]

labellerr/core/annotation_templates/base.py

@@ -1,7 +1,8 @@
+import uuid
+
 from .. import constants
 from ..client import LabellerrClient
 from ..exceptions import InvalidAnnotationTemplateError
-import uuid
 
 
 class LabellerrAnnotationTemplate:
@@ -24,8 +25,18 @@ def get_annotation_template(client: "LabellerrClient", annotation_template_id: s
 
     """Base class for all Labellerr projects with factory behavior"""
 
-    def __new__(cls, client: "LabellerrClient", annotation_template_id: str):
-        # Validate that the annotation template exists before creating the instance
+    def __new__(
+        cls,
+        client: "LabellerrClient",
+        annotation_template_id: str,
+        _skip_api_fetch: bool = False,
+        **kwargs,
+    ):
+        # If skip flag is set, create instance without API call
+        if _skip_api_fetch:
+            return super().__new__(cls)
+
+        # Otherwise, fetch from API and validate
         annotation_template_data = cls.get_annotation_template(
             client, annotation_template_id
         )
@@ -37,14 +48,82 @@ def __new__(cls, client: "LabellerrClient", annotation_template_id: str):
                 f"Annotation template with ID '{annotation_template_id}' does not exist or could not be retrieved."
             )
 
-        # Create the instance only if validation passes
-        instance = super().__new__(cls)
-        # Store the data on the instance to avoid calling API again in __init__
-        instance.__annotation_template_data = annotation_template_data
-        return instance
+        # Pass fetched data to __init__ via kwargs
+        kwargs["_fetched_data"] = annotation_template_data
+        return super().__new__(cls)
 
-    def __init__(self, client: "LabellerrClient", annotation_template_id: str):
+    def __init__(
+        self,
+        client: "LabellerrClient",
+        annotation_template_id: str,
+        _skip_api_fetch: bool = False,
+        **kwargs,
+    ):
         self.client = client
-        self.annotation_template_id = annotation_template_id
-        # Use the data already fetched in __new__
-        self.annotation_template_data = self.__annotation_template_data
+        self.__annotation_template_id = annotation_template_id
+
+        # Set __annotation_template_data from either source
+        if "_cached_data" in kwargs:
+            # Data provided directly (from factory method)
+            self.__annotation_template_data = kwargs["_cached_data"]
+        elif "_fetched_data" in kwargs:
+            # Data fetched in __new__
+            self.__annotation_template_data = kwargs["_fetched_data"]
+        else:
+            # Fallback - shouldn't happen in normal usage
+            self.__annotation_template_data = {}
+
+    @classmethod
+    def from_annotation_template_data(cls, client: "LabellerrClient", **kwargs):
+        """
+        Create a LabellerrAnnotationTemplate instance from annotation template data.
+
+        :param client: LabellerrClient instance
+        :param kwargs: Annotation template fields (template_id, template_name, questions, etc.)
+        :return: Instance of LabellerrAnnotationTemplate
+        """
+        # Validate required fields
+        required_fields = {
+            "template_id",
+            "template_name",
+            "questions",
+            "created_at",
+            "created_by",
+        }
+        missing_fields = required_fields - set(kwargs.keys())
+        if missing_fields:
+            raise ValueError(
+                f"Missing required fields in annotation_template_data: {missing_fields}"
+            )
+
+        # Create instance without API call - explicit flag makes intent clear
+        return cls(
+            client,
+            annotation_template_id=kwargs.get("template_id"),
+            _skip_api_fetch=True,
+            _cached_data=kwargs,
+        )
+
+    @property
+    def template_name(self):
+        return self.__annotation_template_data.get("template_name")
+
+    @property
+    def data_type(self):
+        return self.__annotation_template_data.get("data_type")
+
+    @property
+    def annotation_template_id(self):
+        return self.__annotation_template_id
+
+    @property
+    def created_at(self):
+        return self.__annotation_template_data.get("created_at")
+
+    @property
+    def created_by(self):
+        return self.__annotation_template_data.get("created_by")
+
+    @property
+    def questions(self):
+        return self.__annotation_template_data.get("questions")

labellerr/core/constants.py

@@ -1,4 +1,4 @@
-BASE_URL = "https://api.labellerr.com"
+BASE_URL = "https://api-gateway-qcb3iv2gaa-uc.a.run.app"
 ALLOWED_ORIGINS = "https://pro.labellerr.com"
 
 
@@ -7,7 +7,7 @@
 TOTAL_FILES_SIZE_LIMIT_PER_DATASET = 2.5 * 1024 * 1024 * 1024  # 2.5GB
 TOTAL_FILES_COUNT_LIMIT_PER_DATASET = 2500
 
-ANNOTATION_FORMAT = ["json", "coco_json", "csv", "png"]
+ANNOTATION_FORMAT = ["json", "coco_json", "csv", "png", "video_json"]
 LOCAL_EXPORT_FORMAT = ["json", "coco_json", "csv", "png"]
 LOCAL_EXPORT_STATUS = [
     "review",

labellerr/core/datasets/base.py

@@ -4,14 +4,13 @@
 import logging
 import uuid
 from abc import ABCMeta
-from typing import Dict, Any, List, TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, Dict, Generator
 
 from .. import constants
-from ..exceptions import InvalidDatasetError, LabellerrError
 from ..client import LabellerrClient
-
-from ..files import LabellerrFile
 from ..connectors import LabellerrConnection
+from ..exceptions import InvalidDatasetError, LabellerrError
+from ..files import LabellerrFile
 
 if TYPE_CHECKING:
     from ..projects import LabellerrProject
@@ -175,15 +174,22 @@ def on_success(dataset_data):
             on_success=on_success,
         )
 
-    def fetch_files(self, page_size: int = 1000) -> List[LabellerrFile]:
+    def fetch_files(
+        self, page_size: int = 1000
+    ) -> Generator[LabellerrFile, None, None]:
+    def fetch_files(
+        self, page_size: int = 1000
+    ) -> Generator[LabellerrFile, None, None]:
         """
         Fetch all files in this dataset as LabellerrFile instances.
 
-        :param page_size: Number of files to fetch per API request (default: 10)
-        :return: List of file IDs
+        :param page_size: Number of files to fetch per API request (default: 1000)
+        :return: Generator yielding LabellerrFile instances
+        :param page_size: Number of files to fetch per API request (default: 1000)
+        :return: Generator yielding LabellerrFile instances
         """
-        print(f"Fetching files for dataset: {self.dataset_id}")
-        file_ids = []
+        logging.info(f"Fetching files for dataset: {self.dataset_id}")
+        logging.info(f"Fetching files for dataset: {self.dataset_id}")
         next_search_after = None  # Start with None for first page
 
         while True:
@@ -205,15 +211,26 @@ def fetch_files(self, page_size: int = 1000) -> List[LabellerrFile]:
             response = self.client.make_request(
                 "GET", url, extra_headers=None, request_id=unique_id, params=params
             )
-            print(response)
             # Extract files from the response
             files = response.get("response", {}).get("files", [])
 
             # Collect file IDs
-            for file_info in files:
-                file_id = file_info.get("file_id")
-                if file_id:
-                    file_ids.append(file_id)
+            for file_data in files:
+                try:
+                    _file = LabellerrFile.from_file_data(self.client, file_data)
+                    yield _file
+                except LabellerrError as e:
+                    logging.warning(
+                        f"Warning: Failed to create file instance for {file_data.get('file_id')}: {str(e)}"
+                    )
+            for file_data in files:
+                try:
+                    _file = LabellerrFile.from_file_data(self.client, file_data)
+                    yield _file
+                except LabellerrError as e:
+                    logging.warning(
+                        f"Warning: Failed to create file instance for {file_data.get('file_id')}: {str(e)}"
+                    )
 
             # Get next_search_after for pagination
             next_search_after = response.get("response", {}).get("next_search_after")
@@ -222,23 +239,6 @@ def fetch_files(self, page_size: int = 1000) -> List[LabellerrFile]:
             if not next_search_after or not files:
                 break
 
-        files = []
-
-        for file_id in file_ids:
-            try:
-                _file = LabellerrFile(
-                    client=self.client,
-                    file_id=file_id,
-                    dataset_id=self.dataset_id,
-                )
-                files.append(_file)
-            except LabellerrError as e:
-                logging.warning(
-                    f"Warning: Failed to create file instance for {file_id}: {str(e)}"
-                )
-
-        return files
-
     def sync_with_connection(
         self,
         project: "LabellerrProject",

labellerr/core/exports/base.py

@@ -2,9 +2,9 @@
 Export class for handling export operations with status tracking and polling.
 """
 
-from typing import TYPE_CHECKING, Dict, Any, Optional
-import logging
 import json
+import logging
+from typing import TYPE_CHECKING, Any, Dict, Optional
 
 if TYPE_CHECKING:
     from ..projects.base import LabellerrProject
@@ -39,9 +39,6 @@ def report_id(self) -> str:
     def _status(self) -> Dict[str, Any]:
         """Get current export status (single check)."""
         response = self._project.check_export_status([self._report_id])
-        if isinstance(response, str):
-            response = json.loads(response)
-
         for status_item in response.get("status", []):
             if status_item.get("report_id") == self._report_id:
                 return status_item
@@ -58,8 +55,6 @@ def status(
 
         def get_status():
             response = self._project.check_export_status([self._report_id])
-            if isinstance(response, str):
-                response = json.loads(response)
             return response
 
         def is_completed(response_data):