Merge branch 'main' into lean/yolov12-upload

Author: lrosemberg

roboflow/__init__.py

@@ -15,7 +15,11 @@
 from roboflow.models import CLIPModel, GazeModel  # noqa: F401
 from roboflow.util.general import write_line
 
+<<<<<<< HEAD
 __version__ = "1.1.55"
+=======
+__version__ = "1.1.56"
+>>>>>>> main
 
 
 def check_key(api_key, model, notebook, num_retries=0):

roboflow/adapters/rfapi.py

@@ -4,6 +4,7 @@
 from typing import Optional
 
 import requests
+from requests.exceptions import RequestException
 from requests_toolbelt.multipart.encoder import MultipartEncoder
 
 from roboflow.config import API_URL, DEFAULT_BATCH_NAME, DEFAULT_JOB_NAME
@@ -26,6 +27,7 @@ class AnnotationSaveError(RoboflowError):
     def __init__(self, message, status_code=None):
         self.message = message
         self.status_code = status_code
+        self.retries = 0
         super().__init__(self.message)
 
 
@@ -85,14 +87,21 @@ def upload_image(
                 "file": ("imageToUpload", imgjpeg, "image/jpeg"),
             }
         )
-        response = requests.post(upload_url, data=m, headers={"Content-Type": m.content_type}, timeout=(300, 300))
+
+        try:
+            response = requests.post(upload_url, data=m, headers={"Content-Type": m.content_type}, timeout=(300, 300))
+        except RequestException as e:
+            raise ImageUploadError(str(e)) from e
 
     else:
         # Hosted image upload url
         upload_url = _hosted_upload_url(api_key, project_url, image_path, split, coalesced_batch_name, tag_names)
 
-        # Get response
-        response = requests.post(upload_url, timeout=(300, 300))
+        try:
+            # Get response
+            response = requests.post(upload_url, timeout=(300, 300))
+        except RequestException as e:
+            raise ImageUploadError(str(e)) from e
 
     responsejson = None
     try:
@@ -147,12 +156,15 @@ def save_annotation(
         api_key, project_url, annotation_name, image_id, job_name, is_prediction, overwrite
     )
 
-    response = requests.post(
-        upload_url,
-        data=json.dumps({"annotationFile": annotation_string, "labelmap": annotation_labelmap}),
-        headers={"Content-Type": "application/json"},
-        timeout=(60, 60),
-    )
+    try:
+        response = requests.post(
+            upload_url,
+            data=json.dumps({"annotationFile": annotation_string, "labelmap": annotation_labelmap}),
+            headers={"Content-Type": "application/json"},
+            timeout=(60, 60),
+        )
+    except RequestException as e:
+        raise AnnotationSaveError(str(e)) from e
 
     # Handle response
     responsejson = None

roboflow/core/project.py

@@ -11,7 +11,7 @@
 import requests
 
 from roboflow.adapters import rfapi
-from roboflow.adapters.rfapi import ImageUploadError
+from roboflow.adapters.rfapi import AnnotationSaveError, ImageUploadError
 from roboflow.config import API_URL, DEMO_KEYS
 from roboflow.core.version import Version
 from roboflow.util.general import Retry
@@ -515,26 +515,34 @@ def save_annotation(
         job_name=None,
         is_prediction: bool = False,
         annotation_overwrite=False,
+        num_retry_uploads=0,
     ):
         project_url = self.id.rsplit("/")[1]
         annotation_name, annotation_str = self._annotation_params(annotation_path)
         t0 = time.time()
+        upload_retry_attempts = 0
+        retry = Retry(num_retry_uploads, AnnotationSaveError)
 
-        annotation = rfapi.save_annotation(
-            self.__api_key,
-            project_url,
-            annotation_name,  # type: ignore[type-var]
-            annotation_str,  # type: ignore[type-var]
-            image_id,
-            job_name=job_name,  # type: ignore[type-var]
-            is_prediction=is_prediction,
-            annotation_labelmap=annotation_labelmap,
-            overwrite=annotation_overwrite,
-        )
+        try:
+            annotation = rfapi.save_annotation(
+                self.__api_key,
+                project_url,
+                annotation_name,  # type: ignore[type-var]
+                annotation_str,  # type: ignore[type-var]
+                image_id,
+                job_name=job_name,  # type: ignore[type-var]
+                is_prediction=is_prediction,
+                annotation_labelmap=annotation_labelmap,
+                overwrite=annotation_overwrite,
+            )
+            upload_retry_attempts = retry.retries
+        except AnnotationSaveError as e:
+            e.retries = upload_retry_attempts
+            raise
 
         upload_time = time.time() - t0
 
-        return annotation, upload_time
+        return annotation, upload_time, upload_retry_attempts
 
     def single_upload(
         self,
@@ -563,6 +571,7 @@ def single_upload(
         uploaded_image, uploaded_annotation = None, None
         upload_time, annotation_time = None, None
         upload_retry_attempts = 0
+        annotation_upload_retry_attempts = 0
 
         if image_path:
             uploaded_image, upload_time, upload_retry_attempts = self.upload_image(
@@ -579,13 +588,14 @@ def single_upload(
             image_id = uploaded_image["id"]  # type: ignore[index]
 
         if annotation_path and image_id:
-            uploaded_annotation, annotation_time = self.save_annotation(
+            uploaded_annotation, annotation_time, annotation_upload_retry_attempts = self.save_annotation(
                 annotation_path,
                 annotation_labelmap,
                 image_id,
                 batch_name,
                 is_prediction,
                 annotation_overwrite,
+                num_retry_uploads=num_retry_uploads,
             )
 
         return {
@@ -594,6 +604,7 @@ def single_upload(
             "upload_time": upload_time,
             "annotation_time": annotation_time,
             "upload_retry_attempts": upload_retry_attempts,
+            "annotation_upload_retry_attempts": annotation_upload_retry_attempts,
         }
 
     def _annotation_params(self, annotation_path):
@@ -801,3 +812,57 @@ def image(self, image_id: str) -> Dict:
         image_details = data["image"]
 
         return image_details
+
+    def create_annotation_job(
+        self, name: str, batch_id: str, num_images: int, labeler_email: str, reviewer_email: str
+    ) -> Dict:
+        """
+        Create a new annotation job in the project.
+
+        Args:
+            name (str): The name of the annotation job
+            batch_id (str): The ID of the batch that contains the images to annotate
+            num_images (int): The number of images to include in the job
+            labeler_email (str): The email of the user who will label the images
+            reviewer_email (str): The email of the user who will review the annotations
+
+        Returns:
+            Dict: A dictionary containing the created job details
+
+        Example:
+            >>> import roboflow
+
+            >>> rf = roboflow.Roboflow(api_key="YOUR_API_KEY")
+
+            >>> project = rf.workspace().project("PROJECT_ID")
+
+            >>> job = project.create_annotation_job(
+            ...     name="Job created by API",
+            ...     batch_id="batch123",
+            ...     num_images=10,
+            ...     labeler_email="[email protected]",
+            ...     reviewer_email="[email protected]"
+            ... )
+        """
+        url = f"{API_URL}/{self.__workspace}/{self.__project_name}/jobs?api_key={self.__api_key}"
+
+        payload = {
+            "name": name,
+            "batch": batch_id,
+            "num_images": num_images,
+            "labelerEmail": labeler_email,
+            "reviewerEmail": reviewer_email,
+        }
+
+        response = requests.post(url, headers={"Content-Type": "application/json"}, json=payload)
+
+        if response.status_code != 200:
+            try:
+                error_data = response.json()
+                if "error" in error_data:
+                    raise RuntimeError(error_data["error"])
+                raise RuntimeError(response.text)
+            except ValueError:
+                raise RuntimeError(f"Failed to create annotation job: {response.text}")
+
+        return response.json()

roboflow/core/workspace.py

@@ -350,6 +350,7 @@ def _upload_image(imagedesc):
                 batch_name=batch_name,
                 sequence_number=imagedesc.get("index"),
                 sequence_size=len(images),
+                num_retry_uploads=num_retries,
             )
 
             return image, upload_time, upload_retry_attempts
@@ -372,11 +373,12 @@ def _save_annotation(image_id, imagedesc):
             if not annotation_path:
                 return None, None
 
-            annotation, upload_time = project.save_annotation(
+            annotation, upload_time, _retry_attempts = project.save_annotation(
                 annotation_path=annotation_path,
                 annotation_labelmap=labelmap,
                 image_id=image_id,
                 job_name=batch_name,
+                num_retry_uploads=num_retries,
             )
 
             return annotation, upload_time

roboflow/roboflowpy.py

@@ -81,7 +81,8 @@ def upload_model(args):
 
     if args.version_number is not None:
         # Deploy to specific version
-        project = workspace.project(args.project)
+        project_id = args.project[0] if isinstance(args.project, list) else args.project
+        project = workspace.project(project_id)
         version = project.version(args.version_number)
         version.deploy(str(args.model_type), str(args.model_path), str(args.filename))
     else:

roboflow/util/general.py

@@ -1,4 +1,6 @@
 import sys
+import time
+from random import random
 
 
 def write_line(line):
@@ -13,8 +15,16 @@ def __init__(self, max_retries, retry_on):
         self.retry_on = retry_on
         self.retries = 0
 
+    def backoff(self):
+        """
+        Backoff for a random time based on number of retries.
+        """
+        base_t_ms = 100
+        max_t_ms = 30000
+        sleep_ms = random() * min(max_t_ms, base_t_ms * 2**self.retries)
+        time.sleep(int(sleep_ms) / 1000)
+
     def __call__(self, func, *args, **kwargs):
-        self.retries = 0
         retry_on = self.retry_on
         if not retry_on:
             retry_on = (Exception,)
@@ -24,8 +34,9 @@ def __call__(self, func, *args, **kwargs):
                 return func(*args, **kwargs)
             except BaseException as e:
                 if isinstance(e, retry_on):
-                    self.retries += 1
-                    if self.retries > self.max_retries:
+                    if self.retries >= self.max_retries:
                         raise
+                    self.backoff()
+                    self.retries += 1
                 else:
                     raise

tests/test_project.py

@@ -1,5 +1,6 @@
 import requests
 import responses
+from responses.matchers import json_params_matcher
 
 from roboflow import API_URL
 from roboflow.adapters.rfapi import AnnotationSaveError, ImageUploadError
@@ -144,3 +145,81 @@ def test_image_invalid_json_response(self):
             self.project.image(image_id)
 
         self.assertIn("Expecting value", str(context.exception))
+
+    def test_create_annotation_job_success(self):
+        job_name = "Test Job"
+        batch_id = "test-batch-123"
+        num_images = 10
+        labeler_email = "[email protected]"
+        reviewer_email = "[email protected]"
+
+        expected_response = {
+            "success": True,
+            "job": {
+                "id": "job-123",
+                "name": job_name,
+                "batch": batch_id,
+                "num_images": num_images,
+                "labeler": labeler_email,
+                "reviewer": reviewer_email,
+                "status": "created",
+                "created": 1616161616,
+            },
+        }
+
+        expected_url = f"{API_URL}/{WORKSPACE_NAME}/{PROJECT_NAME}/jobs?api_key={ROBOFLOW_API_KEY}"
+
+        responses.add(
+            responses.POST,
+            expected_url,
+            json=expected_response,
+            status=200,
+            match=[
+                json_params_matcher(
+                    {
+                        "name": job_name,
+                        "batch": batch_id,
+                        "num_images": num_images,
+                        "labelerEmail": labeler_email,
+                        "reviewerEmail": reviewer_email,
+                    }
+                )
+            ],
+        )
+
+        result = self.project.create_annotation_job(
+            name=job_name,
+            batch_id=batch_id,
+            num_images=num_images,
+            labeler_email=labeler_email,
+            reviewer_email=reviewer_email,
+        )
+
+        self.assertEqual(result, expected_response)
+        self.assertTrue(result["success"])
+        self.assertEqual(result["job"]["id"], "job-123")
+        self.assertEqual(result["job"]["name"], job_name)
+
+    def test_create_annotation_job_error(self):
+        job_name = "Test Job"
+        batch_id = "invalid-batch"
+        num_images = 10
+        labeler_email = "[email protected]"
+        reviewer_email = "[email protected]"
+
+        error_response = {"error": "Batch not found"}
+
+        expected_url = f"{API_URL}/{WORKSPACE_NAME}/{PROJECT_NAME}/jobs?api_key={ROBOFLOW_API_KEY}"
+
+        responses.add(responses.POST, expected_url, json=error_response, status=404)
+
+        with self.assertRaises(RuntimeError) as context:
+            self.project.create_annotation_job(
+                name=job_name,
+                batch_id=batch_id,
+                num_images=num_images,
+                labeler_email=labeler_email,
+                reviewer_email=reviewer_email,
+            )
+
+        self.assertEqual(str(context.exception), "Batch not found")