rapidata 2.7.1__tar.gz → 2.7.2__tar.gz

{rapidata-2.7.1 → rapidata-2.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: rapidata
-Version: 2.7.1
+Version: 2.7.2
 Summary: Rapidata package containing the Rapidata Python Client to interact with the Rapidata Web API in an easy way.
 License: Apache-2.0
 Author: Rapidata AG

{rapidata-2.7.1 → rapidata-2.7.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "rapidata"
-version = "2.7.1"
+version = "2.7.2"
 description = "Rapidata package containing the Rapidata Python Client to interact with the Rapidata Web API in an easy way."
 authors = ["Rapidata AG <info@rapidata.ai>"]
 license = "Apache-2.0"

{rapidata-2.7.1 → rapidata-2.7.2}/src/rapidata/rapidata_client/assets/_media_asset.py

@@ -1,6 +1,7 @@
-"""Media Asset Module
+"""Media Asset Module with Lazy Loading
 
 Defines the MediaAsset class for handling media file paths within assets.
+Implements lazy loading for URL-based media to prevent unnecessary downloads.
 """
 
 import os
@@ -12,18 +13,20 @@ from PIL import Image
 from tinytag import TinyTag
 import tempfile
 from pydantic import StrictStr, StrictBytes
-from typing import Optional
+from typing import Optional, cast
 import logging
+from functools import cached_property
 
 
 class MediaAsset(BaseAsset):
-    """MediaAsset Class
+    """MediaAsset Class with Lazy Loading
 
-    Represents a media asset by storing the file path.
+    Represents a media asset by storing the file path or URL.
+    Only downloads URL content when needed.
     Supports local files and URLs for images, MP3, and MP4.
 
     Args:
-        path (str): The file system path to the media asset.
+        path (str): The file system path to the media asset or URL.
 
     Raises:
         FileNotFoundError: If the provided file path does not exist.
@@ -67,23 +70,40 @@ class MediaAsset(BaseAsset):
 
         Raises:
             FileNotFoundError: If the provided file path does not exist.
-            ValueError: If media type is unsupported or duration exceeds 25 seconds.
+            ValueError: If path is not a string.
         """
         if not isinstance(path, str):
             raise ValueError("Media must be a string, either a local file path or a URL")
         
+        self._url = None
+        self._content = None
+        
         if re.match(r'^https?://', path):
-            self.path = self.__get_media_bytes(path)
+            self._url = path
             self.name = path.split('/')[-1]
             self.name = self.__check_name_ending(self.name)
+            self.path = None  # Will be set when content is downloaded
             return
         
         if not os.path.exists(path):
             raise FileNotFoundError(f"File not found: {path}")
         
-        self.path: str | bytes = path
+        self.path = path
         self.name = path
 
+    @cached_property
+    def content(self) -> bytes:
+        """
+        Lazy loader for URL content. Only downloads when first accessed.
+        Uses cached_property to store the result after first download.
+        """
+        if self._url is None:
+            self.path = cast(str, self.path)
+            with open(self.path, 'rb') as f:
+                return f.read()
+            
+        return self.__get_media_bytes(self._url)
+
     def get_duration(self) -> int:
         """
         Get the duration of audio/video files in milliseconds.
@@ -97,27 +117,22 @@ class MediaAsset(BaseAsset):
         """
         path_to_check = self.name.lower()
         
-        # Return 0 for other static images
+        # Return 0 for static images
         if any(path_to_check.endswith(ext) for ext in ('.jpg', '.jpeg', '.png', '.webp', '.gif')):
             return 0
 
         try:
-            # For URL downloads (bytes), write to temporary file first
-            if isinstance(self.path, bytes):
-                with tempfile.NamedTemporaryFile(suffix=os.path.splitext(self.name)[1], delete=False) as tmp:
-                    tmp.write(self.path)
-                    tmp.flush()
-                    # Close the file so it can be read
-                    tmp_path = tmp.name
+            # Create temporary file from content
+            with tempfile.NamedTemporaryFile(suffix=os.path.splitext(self.name)[1], delete=False) as tmp:
+                tmp.write(self.content)
+                tmp.flush()
+                tmp_path = tmp.name
                 
                 try:
                     tag = TinyTag.get(tmp_path)
                 finally:
                     # Clean up the temporary file
                     os.unlink(tmp_path)
-            else:
-                # For local files, use path directly
-                tag = TinyTag.get(self.path)
             
             if tag.duration is None:
                 raise ValueError("Could not read duration from file")
@@ -136,17 +151,14 @@ class MediaAsset(BaseAsset):
             return None
             
         try:
-            if isinstance(self.path, bytes):
-                img = Image.open(BytesIO(self.path))
-            else:
-                img = Image.open(self.path)
+            img = Image.open(BytesIO(self.content))
             return img.size
         except Exception:
             return None
 
     def set_custom_name(self, name: str) -> 'MediaAsset':
         """Set a custom name for the media asset (only works with URLs)."""
-        if isinstance(self.path, bytes):
+        if self._url is not None:
             self.name = self.__check_name_ending(name)
         else:
             raise ValueError("Custom name can only be set for URLs.")
@@ -265,8 +277,10 @@ class MediaAsset(BaseAsset):
         self._logger.error(error_msg)
         raise ValueError(error_msg)
     
-    def to_file(self) -> StrictStr | tuple[StrictStr, StrictBytes] | StrictBytes: # types for autogenerated models
-        if isinstance(self.path, str):
+    def to_file(self) -> StrictStr | tuple[StrictStr, StrictBytes] | StrictBytes:
+        """Convert the media asset to a file representation."""
+        if self._url is None:
+            self.path = cast(str, self.path)
             return self.path
-        else: # isinstance(self.path, bytes)
-            return (self.name, self.path)
+        else:
+            return (self.name, self.content)

{rapidata-2.7.1 → rapidata-2.7.2}/src/rapidata/rapidata_client/order/rapidata_order_manager.py

@@ -36,6 +36,8 @@ from rapidata.api_client.models.root_filter import RootFilter
 from rapidata.api_client.models.filter import Filter
 from rapidata.api_client.models.sort_criterion import SortCriterion
 
+from tqdm import tqdm
+
 
 class RapidataOrderManager:
     """
@@ -444,7 +446,7 @@ class RapidataOrderManager:
 
         assets = [MediaAsset(path=path) for path in datapoints]
 
-        for asset in assets:
+        for asset in tqdm(assets, desc="Downloading assets and checking duration"):
             if not asset.get_duration():
                 raise ValueError("The datapoints for this order must have a duration. (e.g. video or audio)")
 

{rapidata-2.7.1 → rapidata-2.7.2}/src/rapidata/rapidata_client/validation/validation_set_manager.py

@@ -15,6 +15,7 @@ from urllib3._collections import HTTPHeaderDict
 from rapidata.rapidata_client.validation.rapids.box import Box
 
 from rapidata.api_client.models.query_validation_set_model import QueryValidationSetModel
+from tqdm import tqdm
 
 
 class ValidationSetManager:
@@ -404,7 +405,7 @@ class ValidationSetManager:
             openapi_service=self.__openapi_service
         )
 
-        for rapid in rapids:
+        for rapid in tqdm(rapids, desc="Uploading validation tasks"):
             validation_set.add_rapid(rapid)
         
         return validation_set