containerio 2.2.0__tar.gz → 2.3.0__tar.gz

{containerio-2.2.0 → containerio-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: containerio
-Version: 2.2.0
+Version: 2.3.0
 Summary: Azure Blob Storage handler with unified local/cloud interface
 Author: Alliance SwissPass
 Requires-Dist: polars>=1.30.0

{containerio-2.2.0 → containerio-2.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "containerio"
-version = "2.2.0"
+version = "2.3.0"
 description = "Azure Blob Storage handler with unified local/cloud interface"
 readme = "README.md"
 requires-python = ">=3.11"

{containerio-2.2.0 → containerio-2.3.0}/src/containerio/handler.py

@@ -377,7 +377,24 @@ class StorageHandler:
             )
         }
 
-    def _read_blob_as_bytes(self, blob_name: str) -> bytes:
+    def read_blob_as_bytes(self, blob_name: str) -> bytes:
+        """Read a blob's raw bytes from local or Azure storage.
+
+        Args:
+            blob_name (str): The path/name of the blob to read.
+
+        Returns:
+            bytes: The blob's raw contents.
+
+        Raises:
+            FileNotFoundError: If the blob does not exist.
+        """
+        if self.local:
+            try:
+                return (self.base_path / blob_name).read_bytes()
+            except FileNotFoundError as error:
+                raise FileNotFoundError(f"Blob not found: {blob_name}") from error
+
         try:
             return self._get_blob_client(blob_name=blob_name).download_blob().readall()
         except ResourceNotFoundError as error:
@@ -686,12 +703,8 @@ class StorageHandler:
             pl.DataFrame: The content of the CSV file as a Polars
             DataFrame.
         """
-        if self.local:
-            file_path = self.base_path / blob_name
-            return pl.read_csv(source=file_path, **kwargs)
-        else:
-            data = self._read_blob_as_bytes(blob_name)
-            return pl.read_csv(source=BytesIO(data), **kwargs)
+        data = self.read_blob_as_bytes(blob_name=blob_name)
+        return pl.read_csv(source=BytesIO(data), **kwargs)
 
     def scan_csv_blob(self, blob_name: str, **kwargs: Dict) -> pl.LazyFrame:
         """Scans a CSV file or multiple files from storage.
@@ -731,12 +744,8 @@ class StorageHandler:
             pl.DataFrame: The content of the Excel file as a Polars
             DataFrame.
         """
-        if self.local:
-            file_path = self.base_path / blob_name
-            df = pl.read_excel(source=file_path, **kwargs)
-        else:
-            data = self._read_blob_as_bytes(blob_name)
-            df = pl.read_excel(source=BytesIO(data), **kwargs)
+        data = self.read_blob_as_bytes(blob_name=blob_name)
+        df = pl.read_excel(source=BytesIO(data), **kwargs)
 
         if not isinstance(df, pl.DataFrame):
             raise TypeError(
@@ -757,16 +766,10 @@ class StorageHandler:
             Tuple[pl.DataFrame, Dict]: A tuple containing the DataFrame
             and the Parquet file's metadata.
         """
-        if self.local:
-            file_path = self.base_path / blob_name
-            df = pl.read_parquet(source=file_path)
-            metadata = pl.read_parquet_metadata(source=file_path)
-            return df, metadata
-        else:
-            data = self._read_blob_as_bytes(blob_name)
-            df = pl.read_parquet(source=BytesIO(data))
-            metadata = pl.read_parquet_metadata(source=BytesIO(data))
-            return df, metadata
+        data = self.read_blob_as_bytes(blob_name=blob_name)
+        df = pl.read_parquet(source=BytesIO(data))
+        metadata = pl.read_parquet_metadata(source=BytesIO(data))
+        return df, metadata
 
     def scan_parquet_blob(
         self, blob_name: str, **kwargs: Dict
@@ -845,15 +848,43 @@ class StorageHandler:
 
         return download_path
 
-    def _write_blob_as_bytes(self, blob_name: str, data: bytes) -> Dict[str, Any]:
+    def write_blob_as_bytes(
+        self, blob_name: str, data: bytes
+    ) -> Optional[Dict[str, Any]]:
+        """Write raw bytes to a blob in local or Azure storage.
+
+        Existing blobs are overwritten. For local storage, parent
+        directories are created as needed.
+
+        Args:
+            blob_name (str): The path/name of the blob to write.
+            data (bytes): The raw bytes to write.
+
+        Returns:
+            Optional[Dict[str, Any]]: The Azure upload response, or
+                `None` for local storage.
+
+        Raises:
+            ValueError: If `blob_name` is empty or not a string.
+            TypeError: If `data` is not bytes.
+        """
         if not isinstance(blob_name, str) or not blob_name:
             raise ValueError("Blob name must be str and not empty")
         if not isinstance(data, bytes):
             raise TypeError("Data must be bytes")
+
+        if self.local:
+            file_path = self.base_path / blob_name
+            file_path.parent.mkdir(parents=True, exist_ok=True)
+            file_path.write_bytes(data)
+            return None
+
         # Overwrite if the blob exists
         try:
             blob_client = self._get_blob_client(blob_name=blob_name)
-            return blob_client.upload_blob(data, blob_type="BlockBlob", overwrite=True)
+            return blob_client.upload_blob(
+                data=data, blob_type="BlockBlob", overwrite=True
+            )
         except Exception as e:
             raise RuntimeError(f"Failed to write blob '{blob_name}': {e}") from e
 
@@ -893,17 +924,9 @@ class StorageHandler:
         Returns:
             None
         """
-        if self.local:
-            file_path = self.base_path / blob_name
-            file_path.parent.mkdir(parents=True, exist_ok=True)
-            df.write_csv(file=file_path, **kwargs)
-        else:
-            # Write the DataFrame to an in-memory stream
-            buffer = BytesIO()
-            df.write_csv(file=buffer, **kwargs)
-            buffer.seek(0)
-            # Upload the bytes to Azure Blob Storage
-            self._write_blob_as_bytes(blob_name, buffer.getvalue())
+        buffer = BytesIO()
+        df.write_csv(file=buffer, **kwargs)
+        self.write_blob_as_bytes(blob_name=blob_name, data=buffer.getvalue())
 
     def write_excel_blob(
         self, blob_name: str, df: pl.DataFrame, **kwargs: Dict
@@ -919,17 +942,9 @@ class StorageHandler:
         Returns:
             None
         """
-        if self.local:
-            file_path = self.base_path / blob_name
-            file_path.parent.mkdir(parents=True, exist_ok=True)
-            df.write_excel(workbook=file_path, **kwargs)
-        else:
-            # Write the DataFrame to an in-memory stream
-            buffer = BytesIO()
-            df.write_excel(workbook=buffer, **kwargs)
-            buffer.seek(0)
-            # Upload the bytes to Azure Blob Storage
-            self._write_blob_as_bytes(blob_name, buffer.getvalue())
+        buffer = BytesIO()
+        df.write_excel(workbook=buffer, **kwargs)
+        self.write_blob_as_bytes(blob_name=blob_name, data=buffer.getvalue())
 
     def write_parquet_blob(
         self, blob_name: str, df: pl.DataFrame, **kwargs: Dict
@@ -945,17 +960,9 @@ class StorageHandler:
         Returns:
             None
         """
-        if self.local:
-            file_path = self.base_path / blob_name
-            file_path.parent.mkdir(parents=True, exist_ok=True)
-            df.write_parquet(file=file_path, **kwargs)
-        else:
-            # Write the DataFrame to an in-memory stream
-            buffer = BytesIO()
-            df.write_parquet(file=buffer, **kwargs)
-            buffer.seek(0)
-            # Upload the bytes to Azure Blob Storage
-            self._write_blob_as_bytes(blob_name, buffer.getvalue())
+        buffer = BytesIO()
+        df.write_parquet(file=buffer, **kwargs)
+        self.write_blob_as_bytes(blob_name=blob_name, data=buffer.getvalue())
 
     def sink_parquet_blob(
         self, blob_name: str, lf: pl.LazyFrame, **kwargs: Dict
@@ -1049,18 +1056,22 @@ class StorageHandler:
             prefix = blob_name.rstrip("/") + "/"
             children = list(self.container_client.list_blobs(name_starts_with=prefix))
 
-            # Try exact blob match
+            # Delete children deepest-first. On hierarchical-namespace
+            # (ADLS Gen2) accounts a directory placeholder cannot be
+            # removed until empty, and a parent path always sorts before
+            # its descendants, so reverse order empties each placeholder
+            # before deleting it. Flat namespaces are order-independent.
+            for blob in sorted(children, key=lambda child: child.name, reverse=True):
+                self._get_blob_client(blob_name=blob.name).delete_blob()
+                deleted.append(blob.name)
+
+            # Delete the exact blob (file or now-empty dir) last.
             try:
                 self._get_blob_client(blob_name=blob_name).delete_blob()
                 deleted.append(blob_name)
             except ResourceNotFoundError:
                 pass
 
-            # Delete all blobs under the prefix
-            for blob in children:
-                self._get_blob_client(blob_name=blob.name).delete_blob()
-                deleted.append(blob.name)
-
             if not deleted:
                 raise FileNotFoundError(f"Blob not found: {blob_name}")