altcodepro-polydb-python 2.3.8__tar.gz → 2.3.10__tar.gz

{altcodepro_polydb_python-2.3.8/src/altcodepro_polydb_python.egg-info → altcodepro_polydb_python-2.3.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: altcodepro-polydb-python
-Version: 2.3.8
+Version: 2.3.10
 Summary: Production-ready multi-cloud database abstraction layer with connection pooling, retry logic, and thread safety
 Author: AltCodePro
 Project-URL: Homepage, https://github.com/altcodepro/polydb-python
@@ -28,6 +28,16 @@ Requires-Dist: tenacity>=9.1.4
 Requires-Dist: redis>=6.4.0
 Requires-Dist: python-dotenv>=1.1.1
 Requires-Dist: azure-storage-queue>=12.15.0
+Requires-Dist: azure-storage-blob>=12.29.0
+Requires-Dist: boto3>=1.43.18
+Requires-Dist: google-cloud-storage>=3.10.1
+Requires-Dist: azure-storage-file-share>=12.25.0
+Requires-Dist: azure-data-tables>=12.7.0
+Requires-Dist: ipfshttpclient>=0.7.0
+Requires-Dist: web3>=7.16.0
+Requires-Dist: google-cloud-firestore>=2.27.0
+Requires-Dist: google-cloud-pubsub>=2.38.0
+Requires-Dist: pymongo>=4.17.0
 Provides-Extra: aws
 Requires-Dist: boto3>=1.42.47; extra == "aws"
 Requires-Dist: botocore>=1.42.47; extra == "aws"

{altcodepro_polydb_python-2.3.8 → altcodepro_polydb_python-2.3.10}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "altcodepro-polydb-python"
-version = "2.3.8"
+version = "2.3.10"
 description = "Production-ready multi-cloud database abstraction layer with connection pooling, retry logic, and thread safety"
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.11"
@@ -47,6 +47,16 @@ dependencies = [
     "redis>=6.4.0",
     "python-dotenv>=1.1.1",
     "azure-storage-queue>=12.15.0",
+    "azure-storage-blob>=12.29.0",
+    "boto3>=1.43.18",
+    "google-cloud-storage>=3.10.1",
+    "azure-storage-file-share>=12.25.0",
+    "azure-data-tables>=12.7.0",
+    "ipfshttpclient>=0.7.0",
+    "web3>=7.16.0",
+    "google-cloud-firestore>=2.27.0",
+    "google-cloud-pubsub>=2.38.0",
+    "pymongo>=4.17.0",
 ]
 
 # Generic/Open-source stack (cheapest option)

{altcodepro_polydb_python-2.3.8 → altcodepro_polydb_python-2.3.10/src/altcodepro_polydb_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: altcodepro-polydb-python
-Version: 2.3.8
+Version: 2.3.10
 Summary: Production-ready multi-cloud database abstraction layer with connection pooling, retry logic, and thread safety
 Author: AltCodePro
 Project-URL: Homepage, https://github.com/altcodepro/polydb-python
@@ -28,6 +28,16 @@ Requires-Dist: tenacity>=9.1.4
 Requires-Dist: redis>=6.4.0
 Requires-Dist: python-dotenv>=1.1.1
 Requires-Dist: azure-storage-queue>=12.15.0
+Requires-Dist: azure-storage-blob>=12.29.0
+Requires-Dist: boto3>=1.43.18
+Requires-Dist: google-cloud-storage>=3.10.1
+Requires-Dist: azure-storage-file-share>=12.25.0
+Requires-Dist: azure-data-tables>=12.7.0
+Requires-Dist: ipfshttpclient>=0.7.0
+Requires-Dist: web3>=7.16.0
+Requires-Dist: google-cloud-firestore>=2.27.0
+Requires-Dist: google-cloud-pubsub>=2.38.0
+Requires-Dist: pymongo>=4.17.0
 Provides-Extra: aws
 Requires-Dist: boto3>=1.42.47; extra == "aws"
 Requires-Dist: botocore>=1.42.47; extra == "aws"

{altcodepro_polydb_python-2.3.8 → altcodepro_polydb_python-2.3.10}/src/altcodepro_polydb_python.egg-info/SOURCES.txt

@@ -1,7 +1,6 @@
 LICENSE
 MANIFEST.in
 README.md
-example_usage.py
 pyproject.toml
 requirements-aws.txt
 requirements-azure.txt
@@ -42,11 +41,13 @@ src/polydb/adapters/AzureFileStorageAdapter.py
 src/polydb/adapters/AzureQueueAdapter.py
 src/polydb/adapters/AzureTableStorageAdapter.py
 src/polydb/adapters/BlockchainBlobAdapter.py
+src/polydb/adapters/BlockchainFileAdapter.py
 src/polydb/adapters/BlockchainKVAdapter.py
 src/polydb/adapters/BlockchainQueueAdapter.py
 src/polydb/adapters/DynamoDBAdapter.py
 src/polydb/adapters/EFSAdapter.py
 src/polydb/adapters/FirestoreAdapter.py
+src/polydb/adapters/GCPFilestoreAdapter.py
 src/polydb/adapters/GCPPubSubAdapter.py
 src/polydb/adapters/GCPStorageAdapter.py
 src/polydb/adapters/MongoDBAdapter.py
@@ -55,6 +56,7 @@ src/polydb/adapters/S3Adapter.py
 src/polydb/adapters/S3CompatibleAdapter.py
 src/polydb/adapters/SQSAdapter.py
 src/polydb/adapters/VercelBlobAdapter.py
+src/polydb/adapters/VercelFileAdapter.py
 src/polydb/adapters/VercelKVAdapter.py
 src/polydb/adapters/VercelQueueAdapter.py
 src/polydb/adapters/__init__.py

{altcodepro_polydb_python-2.3.8 → altcodepro_polydb_python-2.3.10}/src/altcodepro_polydb_python.egg-info/requires.txt

@@ -3,6 +3,16 @@ tenacity>=9.1.4
 redis>=6.4.0
 python-dotenv>=1.1.1
 azure-storage-queue>=12.15.0
+azure-storage-blob>=12.29.0
+boto3>=1.43.18
+google-cloud-storage>=3.10.1
+azure-storage-file-share>=12.25.0
+azure-data-tables>=12.7.0
+ipfshttpclient>=0.7.0
+web3>=7.16.0
+google-cloud-firestore>=2.27.0
+google-cloud-pubsub>=2.38.0
+pymongo>=4.17.0
 
 [all]
 boto3>=1.42.47

altcodepro_polydb_python-2.3.10/src/polydb/adapters/AzureBlobStorageAdapter.py

@@ -0,0 +1,184 @@
+# src/polydb/adapters/AzureBlobStorageAdapter.py
+
+import os
+import threading
+import mimetypes
+from typing import Any, Dict, List, Optional
+from ..base.ObjectStorageAdapter import ObjectStorageAdapter
+from ..errors import ConnectionError, StorageError
+from ..retry import retry
+
+
+class AzureBlobStorageAdapter(ObjectStorageAdapter):
+    """
+    Production-grade Azure Blob Storage adapter.
+
+    - One BlobServiceClient, many containers (resolved + cached per call)
+    - Container auto-creation
+    - Thread-safe, retryable, structured logging
+    - put/get/delete are symmetric: a blob is stored at `key` and fetched at `key`
+    """
+
+    def __init__(self, connection_string: str = "", container_name: str = ""):
+        super().__init__()
+
+        self.connection_string = connection_string or os.getenv("AZURE_STORAGE_CONNECTION_STRING")
+        self.container_name = container_name or os.getenv("AZURE_CONTAINER_NAME", "polydb")
+
+        if not self.connection_string:
+            raise ConnectionError("AZURE_STORAGE_CONNECTION_STRING is not configured")
+
+        self._client = None
+        self._containers = {}
+        self._lock = threading.Lock()
+
+        self._initialize_client()
+
+    # ------------------------------------------------------------------
+    # CLIENT / CONTAINER RESOLUTION
+    # ------------------------------------------------------------------
+    def _initialize_client(self) -> None:
+        """Initialize the shared Azure Blob service client."""
+        from azure.storage.blob import BlobServiceClient
+
+        try:
+            with self._lock:
+                if self._client is None and self.connection_string is not None:
+                    self._client = BlobServiceClient.from_connection_string(self.connection_string)
+                    self.logger.info("Azure Blob Storage client initialized")
+        except Exception as e:
+            raise ConnectionError(f"Failed to initialize Azure Blob Storage: {e}")
+
+    def _get_container(self, container_name: Optional[str] = None):
+        """Resolve (and cache) a ContainerClient, auto-creating the container."""
+        from azure.core.exceptions import ResourceExistsError
+
+        if self._client is None:
+            raise ConnectionError("Azure Blob Storage client is not initialized")
+
+        name = container_name or self.container_name
+
+        cached = self._containers.get(name)
+        if cached is not None:
+            return cached
+
+        with self._lock:
+            cached = self._containers.get(name)  # re-check under lock
+            if cached is not None:
+                return cached
+
+            container = self._client.get_container_client(name)
+            try:
+                container.create_container()
+                self.logger.info(f"Created container: {name}")
+            except ResourceExistsError:
+                pass
+
+            self._containers[name] = container
+            return container
+
+    # ------------------------------------------------------------------
+    # PUT
+    # ------------------------------------------------------------------
+    def put(
+        self,
+        key: str,
+        data: bytes,
+        fileName: str = "",
+        optimize: bool = True,
+        media_type: Optional[str] = None,
+        metadata: Dict[str, Any] | None = None,
+        container_name: Optional[str] = None,
+    ) -> str:
+        if optimize and media_type:
+            data = self._optimize_media(data, media_type)
+        return self._put_raw(
+            key=key,
+            data=data,
+            fileName=fileName,
+            media_type=media_type,
+            metadata=metadata,
+            container_name=container_name,
+        )
+
+    @retry(max_attempts=3, delay=1.0, exceptions=(StorageError,))
+    def _put_raw(
+        self,
+        key: str,
+        data: bytes,
+        fileName: str = "",
+        media_type: Optional[str] = None,
+        metadata: Dict[str, Any] | None = None,
+        container_name: Optional[str] = None,
+    ) -> str:
+        """Upload blob. Stored at `key` so get/delete can find it by the same key."""
+        from azure.storage.blob import ContentSettings
+
+        try:
+            container = self._get_container(container_name)
+
+            # filename is metadata only — it must NOT alter the blob key
+            filename = fileName or os.path.basename(key) or key
+            if media_type:
+                ext = mimetypes.guess_extension(media_type) or ""
+                if ext and not filename.lower().endswith(ext):
+                    filename += ext
+
+            blob_client = container.get_blob_client(key)
+            blob_client.upload_blob(
+                data,
+                overwrite=True,
+                content_settings=ContentSettings(
+                    content_type=media_type or "application/octet-stream"
+                ),
+                metadata={**(metadata or {}), "filename": filename},
+            )
+
+            self.logger.debug(
+                f"Uploaded blob key={key} container={container.container_name} type={media_type}"
+            )
+            return blob_client.url
+
+        except Exception as e:
+            raise StorageError(f"Azure Blob put failed: {e}")
+
+    # ------------------------------------------------------------------
+    # GET / DELETE / LIST
+    # ------------------------------------------------------------------
+    @retry(max_attempts=3, delay=1.0, exceptions=(StorageError,))
+    def get(self, key: str, container_name: Optional[str] = None) -> bytes | None:
+        from azure.core.exceptions import ResourceNotFoundError
+
+        try:
+            container = self._get_container(container_name)
+            data = container.get_blob_client(key).download_blob().readall()
+            self.logger.debug(f"Downloaded blob key={key}")
+            return data
+        except ResourceNotFoundError:
+            return None
+        except Exception as e:
+            raise StorageError(f"Azure Blob get failed: {e}")
+
+    @retry(max_attempts=3, delay=1.0, exceptions=(StorageError,))
+    def delete(self, key: str, container_name: Optional[str] = None) -> bool:
+        from azure.core.exceptions import ResourceNotFoundError
+
+        try:
+            container = self._get_container(container_name)
+            container.get_blob_client(key).delete_blob(delete_snapshots="include")
+            self.logger.debug(f"Deleted blob key={key}")
+            return True
+        except ResourceNotFoundError:
+            return False
+        except Exception as e:
+            raise StorageError(f"Azure Blob delete failed: {e}")
+
+    @retry(max_attempts=3, delay=1.0, exceptions=(StorageError,))
+    def list(self, prefix: str = "", container_name: Optional[str] = None) -> List[str]:
+        try:
+            container = self._get_container(container_name)
+            results = [b.name for b in container.list_blobs(name_starts_with=prefix)]
+            self.logger.debug(f"Listed {len(results)} blobs prefix={prefix}")
+            return results
+        except Exception as e:
+            raise StorageError(f"Azure Blob list failed: {e}")

{altcodepro_polydb_python-2.3.8 → altcodepro_polydb_python-2.3.10}/src/polydb/adapters/AzureFileStorageAdapter.py

@@ -4,10 +4,7 @@ from __future__ import annotations
 
 import os
 import threading
-from typing import List, Optional
-
-from azure.storage.fileshare import ShareServiceClient
-from azure.core.exceptions import ResourceExistsError, ResourceNotFoundError
+from typing import Any, Dict, List, Optional
 
 from ..base.SharedFilesAdapter import SharedFilesAdapter
 from ..errors import ConnectionError, StorageError
@@ -18,12 +15,9 @@ class AzureFileStorageAdapter(SharedFilesAdapter):
     """
     Production-grade Azure File Storage adapter.
 
-    Fixes:
-    - Adds upload/download methods expected by tests
-    - Ensures share exists
-    - Ensures directory structure exists
-    - Correct Azure file creation before upload
-    - Keeps write/read compatibility
+    - One service client, many shares (resolved + cached per call)
+    - Auto-creates share + nested directory structure
+    - per-call `share_name` overrides the configured share on every method
     """
 
     def __init__(self, connection_string: str = "", share_name: str = ""):
@@ -32,153 +26,159 @@ class AzureFileStorageAdapter(SharedFilesAdapter):
         self.connection_string = (
             connection_string or os.getenv("AZURE_STORAGE_CONNECTION_STRING") or ""
         )
-
         self.share_name = share_name or os.getenv("AZURE_SHARE_NAME", "polydb")
 
         if not self.connection_string:
             raise ConnectionError("AZURE_STORAGE_CONNECTION_STRING not configured")
 
-        self._client: Optional[ShareServiceClient] = None
-        self._share = None
+        self._client = None
+        self._shares: Dict[str, Any] = {}
         self._lock = threading.Lock()
 
         self._initialize_client()
 
     # --------------------------------------------------
-    # Client initialization
+    # Client / share resolution
     # --------------------------------------------------
-
     def _initialize_client(self):
+        from azure.storage.fileshare import ShareServiceClient
+
         try:
             with self._lock:
                 if self._client:
                     return
-
                 self._client = ShareServiceClient.from_connection_string(self.connection_string)
+                self.logger.info("Initialized Azure File Storage client")
+        except Exception as e:
+            raise ConnectionError(f"Failed to initialize Azure File Storage: {str(e)}")
 
-                self._share = self._client.get_share_client(self.share_name)
+    def _get_share(self, share_name: Optional[str] = None):
+        """Resolve (and cache) a ShareClient, auto-creating the share."""
+        if self._client is None:
+            raise ConnectionError("Azure File Storage client is not initialized")
 
-                try:
-                    self._share.create_share()
-                except ResourceExistsError:
-                    pass
+        name = share_name or self.share_name
 
-                self.logger.info("Initialized Azure File Storage client")
+        cached = self._shares.get(name)
+        if cached is not None:
+            return cached
 
-        except Exception as e:
-            raise ConnectionError(f"Failed to initialize Azure File Storage: {str(e)}")
+        from azure.core.exceptions import ResourceExistsError
+
+        with self._lock:
+            cached = self._shares.get(name)  # re-check under lock
+            if cached is not None:
+                return cached
+
+            share = self._client.get_share_client(name)
+            try:
+                share.create_share()
+                self.logger.info(f"Created share: {name}")
+            except ResourceExistsError:
+                pass
+
+            self._shares[name] = share
+            return share
 
     # --------------------------------------------------
     # Helpers
     # --------------------------------------------------
-
     def _split_path(self, path: str):
         if "/" not in path:
             return "", path
-
         directory, filename = path.rsplit("/", 1)
         return directory, filename
 
-    def _ensure_directory(self, directory: str):
-        if not directory and self._share:
-            return self._share.get_directory_client("")
-        if not self._share:
-            raise ConnectionError("Azure File Storage share not initialized")
-        dir_client = self._share.get_directory_client(directory)
-
-        try:
-            dir_client.create_directory()
-        except ResourceExistsError:
-            pass
-
+    def _ensure_directory(self, share, directory: str):
+        """Create each directory level (Azure requires parents to exist)."""
+        if not directory:
+            return share.get_directory_client("")
+
+        from azure.core.exceptions import ResourceExistsError
+
+        current = ""
+        dir_client = share.get_directory_client("")
+        for part in (p for p in directory.split("/") if p):
+            current = f"{current}/{part}" if current else part
+            dir_client = share.get_directory_client(current)
+            try:
+                dir_client.create_directory()
+            except ResourceExistsError:
+                pass
         return dir_client
 
     # --------------------------------------------------
     # Core operations
     # --------------------------------------------------
-
     @retry(max_attempts=3, delay=1.0, exceptions=(StorageError,))
-    def upload(self, path: str, data: bytes) -> str:
+    def upload(self, path: str, data: bytes, share_name: Optional[str] = None) -> str:
         """Upload file"""
         try:
+            share = self._get_share(share_name)
             directory, filename = self._split_path(path)
-
-            dir_client = self._ensure_directory(directory)
+            dir_client = self._ensure_directory(share, directory)
             file_client = dir_client.get_file_client(filename)
 
             file_client.create_file(len(data))
             file_client.upload_file(data)
-
             return path
-
         except Exception as e:
             raise StorageError(f"Azure File upload failed: {str(e)}")
 
     @retry(max_attempts=3, delay=1.0, exceptions=(StorageError,))
-    def download(self, path: str) -> bytes:
+    def download(self, path: str, share_name: Optional[str] = None) -> bytes:
         """Download file"""
+        from azure.core.exceptions import ResourceNotFoundError
+
         try:
+            share = self._get_share(share_name)
             directory, filename = self._split_path(path)
-            if not self._share:
-                raise ConnectionError("Azure File Storage share not initialized")
-            dir_client = self._share.get_directory_client(directory or "")
+            dir_client = share.get_directory_client(directory or "")
             file_client = dir_client.get_file_client(filename)
-
             return file_client.download_file().readall()
-
         except ResourceNotFoundError:
             raise StorageError(f"File not found: {path}")
         except Exception as e:
             raise StorageError(f"Azure File download failed: {str(e)}")
 
     @retry(max_attempts=3, delay=1.0, exceptions=(StorageError,))
-    def delete(self, path: str) -> bool:
+    def delete(self, path: str, share_name: Optional[str] = None) -> bool:
         """Delete file"""
+        from azure.core.exceptions import ResourceNotFoundError
+
         try:
+            share = self._get_share(share_name)
             directory, filename = self._split_path(path)
-            if not self._share:
-                raise ConnectionError("Azure File Storage share not initialized")
-            dir_client = self._share.get_directory_client(directory or "")
+            dir_client = share.get_directory_client(directory or "")
             file_client = dir_client.get_file_client(filename)
-
             file_client.delete_file()
             return True
-
         except ResourceNotFoundError:
             return False
         except Exception as e:
             raise StorageError(f"Azure File delete failed: {str(e)}")
 
     @retry(max_attempts=3, delay=1.0, exceptions=(StorageError,))
-    def list(self, directory: str = "") -> List[str]:
+    def list(self, directory: str = "", share_name: Optional[str] = None) -> List[str]:
         """List files"""
         try:
-            if not self._share:
-                raise ConnectionError("Azure File Storage share not initialized")
-            dir_client = self._share.get_directory_client(directory or "")
-
-            results: List[str] = []
-
-            for item in dir_client.list_directories_and_files():
-                results.append(item.name)
-
-            return results
-
+            share = self._get_share(share_name)
+            dir_client = share.get_directory_client(directory or "")
+            return [item.name for item in dir_client.list_directories_and_files()]
         except Exception as e:
             raise StorageError(f"Azure File list failed: {str(e)}")
 
     # --------------------------------------------------
-    # Backward compatibility
+    # Backward compatibility (base interface)
     # --------------------------------------------------
-
-    def write(self, path: str, data: bytes) -> bool:
+    def write(self, path: str, data: bytes, share_name: Optional[str] = None) -> bool:
         """Alias for upload"""
-        self.upload(path, data)
+        self.upload(path, data, share_name=share_name)
         return True
 
-    def read(self, path: str) -> bytes | None:
+    def read(self, path: str, share_name: Optional[str] = None) -> bytes | None:
         """Alias for download"""
         try:
-            return self.download(path)
+            return self.download(path, share_name=share_name)
         except StorageError:
             return None

{altcodepro_polydb_python-2.3.8 → altcodepro_polydb_python-2.3.10}/src/polydb/adapters/AzureQueueAdapter.py

@@ -7,8 +7,6 @@ import re
 
 from typing import Any, Dict, List, Optional
 
-from azure.storage.queue import QueueServiceClient, QueueClient
-from azure.core.exceptions import ResourceExistsError, ResourceNotFoundError
 
 from ..base.QueueAdapter import QueueAdapter
 from ..errors import ConnectionError, QueueError
@@ -35,8 +33,8 @@ class AzureQueueAdapter(QueueAdapter):
         if not self.connection_string:
             raise ConnectionError("AZURE_STORAGE_CONNECTION_STRING is not configured")
 
-        self._client: Optional[QueueServiceClient] = None
-        self._queues: Dict[str, QueueClient] = {}
+        self._client = None
+        self._queues = {}
 
         self._lock = threading.Lock()
 
@@ -50,6 +48,8 @@ class AzureQueueAdapter(QueueAdapter):
 
     def _initialize_client(self) -> None:
         """Initialize Azure Queue client"""
+        from azure.storage.queue import QueueServiceClient
+
         try:
             with self._lock:
                 if self._client is not None:
@@ -63,8 +63,10 @@ class AzureQueueAdapter(QueueAdapter):
         except Exception as e:
             raise ConnectionError(f"Failed to initialize Azure Queue Storage: {e}")
 
-    def _get_queue(self, queue_name: str) -> QueueClient:
+    def _get_queue(self, queue_name: str):
         """Get or create queue client"""
+        from azure.core.exceptions import ResourceExistsError
+
         if self._client is None:
             raise ConnectionError("Azure Queue client not initialized")
         queue_name = self._normalize_queue_name(queue_name)
@@ -123,6 +125,8 @@ class AzureQueueAdapter(QueueAdapter):
 
     def delete(self, message_id: str, queue_name: str = "default", pop_receipt: str = "") -> bool:
         """Delete message from queue"""
+        from azure.core.exceptions import ResourceNotFoundError
+
         try:
             queue_name = self._normalize_queue_name(queue_name)
             queue_client = self._get_queue(queue_name)

{altcodepro_polydb_python-2.3.8 → altcodepro_polydb_python-2.3.10}/src/polydb/adapters/AzureTableStorageAdapter.py

@@ -8,6 +8,8 @@ import json
 import base64
 import hashlib
 import threading
+import logging
+
 from datetime import datetime, date
 from decimal import Decimal
 from typing import Any, Dict, List, Optional
@@ -19,7 +21,6 @@ from ..errors import NoSQLError, ConnectionError
 from ..retry import retry
 from ..types import JsonDict
 from ..models import PartitionConfig
-import logging
 
 logger = logging.getLogger(__name__)
 
@@ -540,7 +541,7 @@ class AzureTableStorageAdapter(NoSQLKVAdapter):
             if "ResourceNotFound" in str(e):
                 return None
             raise NoSQLError(f"Azure Table get failed: {str(e)}")
-    
+
     @retry(max_attempts=3, delay=1.0, exceptions=(NoSQLError,))
     def _query_raw(
         self, model: type, filters: Dict[str, Any], limit: Optional[int]
@@ -561,9 +562,7 @@ class AzureTableStorageAdapter(NoSQLKVAdapter):
                     sk = "RowKey"
                 else:
                     sk = (
-                        self._sanitize_prop_name(orig_k)
-                        if orig_k != _MODEL_FIELD
-                        else _MODEL_FIELD
+                        self._sanitize_prop_name(orig_k) if orig_k != _MODEL_FIELD else _MODEL_FIELD
                     )
 
                 ev = self._encode_value(orig_v)
@@ -611,6 +610,7 @@ class AzureTableStorageAdapter(NoSQLKVAdapter):
 
         except Exception as e:
             raise NoSQLError(f"Azure Table query failed: {str(e)}")
+
     @retry(max_attempts=3, delay=1.0, exceptions=(NoSQLError,))
     def _delete_raw(self, model: type, pk: str, rk: str, etag: Optional[str]) -> JsonDict:
         try:

{altcodepro_polydb_python-2.3.8 → altcodepro_polydb_python-2.3.10}/src/polydb/adapters/BlockchainBlobAdapter.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import os
 from typing import Any, Dict, List, Optional
 
-import ipfshttpclient
+
 from dotenv import load_dotenv
 
 from ..base.ObjectStorageAdapter import ObjectStorageAdapter