altcodepro-polydb-python 2.2.2__py3-none-any.whl → 2.2.4__py3-none-any.whl

polydb/adapters/AzureBlobStorageAdapter.py

@@ -1,77 +1,182 @@
 # src/polydb/adapters/AzureBlobStorageAdapter.py
 
-from polydb.base.ObjectStorageAdapter import ObjectStorageAdapter
-from polydb.errors import ConnectionError, StorageError
-from polydb.retry import retry
 import os
 import threading
-from typing import List
+from typing import Any, Dict, List, Optional
+import mimetypes
+from azure.storage.blob import BlobServiceClient, ContainerClient, ContentSettings
+from azure.core.exceptions import ResourceExistsError, ResourceNotFoundError
+
+from ..base.ObjectStorageAdapter import ObjectStorageAdapter
+from ..errors import ConnectionError, StorageError
+from ..retry import retry
+
 
 class AzureBlobStorageAdapter(ObjectStorageAdapter):
-    """Azure Blob Storage with client reuse"""
+    """
+    Production-grade Azure Blob Storage adapter.
+
+    Features
+    - Thread-safe client initialization
+    - Container auto-creation
+    - Retry support
+    - Structured logging
+    - Connection reuse
+    """
 
-    def __init__(self):
+    def __init__(self, connection_string: str = "", container_name: str = ""):
         super().__init__()
-        self.connection_string = os.getenv("AZURE_STORAGE_CONNECTION_STRING") or ""
-        self.container_name = os.getenv("AZURE_CONTAINER_NAME", "default") or ""
-        self._client = None
+
+        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: Optional[BlobServiceClient] = None
+        self._container: Optional[ContainerClient] = None
         self._lock = threading.Lock()
+
         self._initialize_client()
 
-    def _initialize_client(self):
-        """Initialize Azure Blob Storage client once"""
+    def _initialize_client(self) -> None:
+        """Initialize Azure Blob client and container"""
         try:
-            from azure.storage.blob import BlobServiceClient
-
             with self._lock:
-                if not self._client:
-                    self._client = BlobServiceClient.from_connection_string(self.connection_string)
-                    self.logger.info("Initialized Azure Blob Storage client")
+                if self._client is not None:
+                    return
+                if not self.connection_string:
+                    raise ConnectionError("AZURE_STORAGE_CONNECTION_STRING is not configured")
+                self._client = BlobServiceClient.from_connection_string(self.connection_string)
+
+                self._container = self._client.get_container_client(self.container_name)
+
+                try:
+                    self._container.create_container()
+                    self.logger.info(f"Created container: {self.container_name}")
+                except ResourceExistsError:
+                    pass
+
+                self.logger.info(
+                    f"Azure Blob Storage initialized (container={self.container_name})"
+                )
+
         except Exception as e:
-            raise ConnectionError(f"Failed to initialize Azure Blob Storage: {str(e)}")
+            raise ConnectionError(f"Failed to initialize Azure Blob Storage: {e}")
+
+    def _require_container(self) -> ContainerClient:
+        """Ensure container exists"""
+        if self._container is None:
+            raise ConnectionError("Azure Blob Storage client is not initialized")
+        return self._container
 
     @retry(max_attempts=3, delay=1.0, exceptions=(StorageError,))
-    def _put_raw(self, key: str, data: bytes) -> str:
-        """Store blob"""
+    def _put_raw(
+        self,
+        key: str,
+        data: bytes,
+        fileName: str = "",
+        media_type: Optional[str] = None,
+        metadata: Dict[str, Any] | None = None,
+    ) -> str:
+        """Upload blob with filename, media type, and metadata"""
         try:
-            if self._client:
-                blob_client = self._client.get_blob_client(self.container_name, key)
-                blob_client.upload_blob(data, overwrite=True)
-                self.logger.debug(f"Uploaded blob: {key}")
-            return key
+            container = self._require_container()
+
+            # --------------------------------------------------
+            # Resolve filename
+            # --------------------------------------------------
+            filename = fileName or os.path.basename(key)
+
+            # --------------------------------------------------
+            # Ensure extension from media_type if missing
+            # --------------------------------------------------
+            if media_type:
+                ext = mimetypes.guess_extension(media_type) or ""
+                if ext and not filename.lower().endswith(ext):
+                    filename += ext
+
+            # --------------------------------------------------
+            # Final blob key (include filename if needed)
+            # --------------------------------------------------
+            blob_key = key
+            if fileName:
+                blob_key = f"{key.rstrip('/')}/{filename}"
+
+            blob_client = container.get_blob_client(blob_key)
+
+            # --------------------------------------------------
+            # Upload with content type + metadata
+            # --------------------------------------------------
+            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={blob_key}, type={media_type}")
+
+            return blob_client.url
+
         except Exception as e:
-            raise StorageError(f"Azure Blob put failed: {str(e)}")
+            raise StorageError(f"Azure Blob put failed: {e}")
 
     @retry(max_attempts=3, delay=1.0, exceptions=(StorageError,))
     def get(self, key: str) -> bytes | None:
-        """Get blob"""
+        """Download blob"""
         try:
-            if self._client:
-                blob_client = self._client.get_blob_client(self.container_name, key)
-                return blob_client.download_blob().readall()
+            container = self._require_container()
+
+            blob_client = container.get_blob_client(key)
+
+            downloader = blob_client.download_blob()
+            data = downloader.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: {str(e)}")
+            raise StorageError(f"Azure Blob get failed: {e}")
 
     @retry(max_attempts=3, delay=1.0, exceptions=(StorageError,))
     def delete(self, key: str) -> bool:
         """Delete blob"""
         try:
-            if self._client:
-                blob_client = self._client.get_blob_client(self.container_name, key)
-                blob_client.delete_blob()
-                return True
+            container = self._require_container()
+
+            blob_client = container.get_blob_client(key)
+            blob_client.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: {str(e)}")
+            raise StorageError(f"Azure Blob delete failed: {e}")
 
     @retry(max_attempts=3, delay=1.0, exceptions=(StorageError,))
     def list(self, prefix: str = "") -> List[str]:
-        """List blobs with prefix"""
+        """List blobs"""
         try:
-            if self._client:
-                container_client = self._client.get_container_client(self.container_name)
-                return [blob.name for blob in container_client.list_blobs(name_starts_with=prefix)]
-            return []
+            container = self._require_container()
+
+            blobs = container.list_blobs(name_starts_with=prefix)
+            results = [blob.name for blob in blobs]
+
+            self.logger.debug(f"Listed {len(results)} blobs prefix={prefix}")
+
+            return results
+
         except Exception as e:
-            raise StorageError(f"Azure Blob list failed: {str(e)}")
+            raise StorageError(f"Azure Blob list failed: {e}")

polydb/adapters/AzureFileStorageAdapter.py

@@ -1,79 +1,184 @@
 # src/polydb/adapters/AzureFileStorageAdapter.py
 
-from polydb.base.SharedFilesAdapter import SharedFilesAdapter
-from polydb.errors import ConnectionError, StorageError
-from polydb.retry import retry
+from __future__ import annotations
+
 import os
 import threading
-from typing import List
+from typing import List, Optional
+
+from azure.storage.fileshare import ShareServiceClient
+from azure.core.exceptions import ResourceExistsError, ResourceNotFoundError
+
+from ..base.SharedFilesAdapter import SharedFilesAdapter
+from ..errors import ConnectionError, StorageError
+from ..retry import retry
+
 
 class AzureFileStorageAdapter(SharedFilesAdapter):
-    """Azure File Storage with client reuse"""
+    """
+    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
+    """
 
-    def __init__(self):
+    def __init__(self, connection_string: str = "", share_name: str = ""):
         super().__init__()
-        self.connection_string = os.getenv("AZURE_STORAGE_CONNECTION_STRING") or ""
-        self.share_name = os.getenv("AZURE_SHARE_NAME", "default") or ""
-        self._client = None
+
+        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._lock = threading.Lock()
+
         self._initialize_client()
 
+    # --------------------------------------------------
+    # Client initialization
+    # --------------------------------------------------
+
     def _initialize_client(self):
-        """Initialize Azure File Storage client once"""
         try:
-            from azure.storage.fileshare import ShareServiceClient
-
             with self._lock:
-                if not self._client:
-                    self._client = ShareServiceClient.from_connection_string(self.connection_string)
-                    self.logger.info("Initialized Azure File Storage client")
+                if self._client:
+                    return
+
+                self._client = ShareServiceClient.from_connection_string(self.connection_string)
+
+                self._share = self._client.get_share_client(self.share_name)
+
+                try:
+                    self._share.create_share()
+                except ResourceExistsError:
+                    pass
+
+                self.logger.info("Initialized Azure File Storage client")
+
         except Exception as e:
             raise ConnectionError(f"Failed to initialize Azure File Storage: {str(e)}")
 
+    # --------------------------------------------------
+    # 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
+
+        return dir_client
+
+    # --------------------------------------------------
+    # Core operations
+    # --------------------------------------------------
+
     @retry(max_attempts=3, delay=1.0, exceptions=(StorageError,))
-    def write(self, path: str, data: bytes) -> bool:
-        """Write file"""
+    def upload(self, path: str, data: bytes) -> str:
+        """Upload file"""
         try:
-            if self._client:
-                file_client = self._client.get_share_client(self.share_name).get_file_client(path)
-                file_client.upload_file(data)
-                return True
-            return False
+            directory, filename = self._split_path(path)
+
+            dir_client = self._ensure_directory(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 write failed: {str(e)}")
+            raise StorageError(f"Azure File upload failed: {str(e)}")
 
     @retry(max_attempts=3, delay=1.0, exceptions=(StorageError,))
-    def read(self, path: str) -> bytes | None:
-        """Read file"""
+    def download(self, path: str) -> bytes:
+        """Download file"""
         try:
-            if self._client:
-                file_client = self._client.get_share_client(self.share_name).get_file_client(path)
-                return file_client.download_file().readall()
-            return None
+            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 "")
+            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 read failed: {str(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:
         """Delete file"""
         try:
-            if self._client:
-                file_client = self._client.get_share_client(self.share_name).get_file_client(path)
-                file_client.delete_file()
-                return True
+            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 "")
+            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]:
-        """List files in directory"""
+    def list(self, directory: str = "") -> List[str]:
+        """List files"""
         try:
-            if self._client:
-                dir_client = self._client.get_share_client(self.share_name).get_directory_client(
-                    directory
-                )
-                return [item.name for item in dir_client.list_directories_and_files()]
-            return []
+            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
+
         except Exception as e:
-            raise StorageError(f"Azure File list failed: {str(e)}")
+            raise StorageError(f"Azure File list failed: {str(e)}")
+
+    # --------------------------------------------------
+    # Backward compatibility
+    # --------------------------------------------------
+
+    def write(self, path: str, data: bytes) -> bool:
+        """Alias for upload"""
+        self.upload(path, data)
+        return True
+
+    def read(self, path: str) -> bytes | None:
+        """Alias for download"""
+        try:
+            return self.download(path)
+        except StorageError:
+            return None

polydb/adapters/AzureQueueAdapter.py

@@ -1,63 +1,125 @@
 # src/polydb/adapters/AzureQueueAdapter.py
-from polydb.base.QueueAdapter import QueueAdapter
-from polydb.errors import ConnectionError, QueueError
-from polydb.retry import retry
+
 import os
 import threading
-from typing import Any, Dict, List
+import json
+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
+from ..retry import retry
 from ..json_safe import json_safe
 
+
 class AzureQueueAdapter(QueueAdapter):
-    """Azure Queue Storage with client reuse"""
+    """
+    Azure Queue Storage adapter.
+
+    Features
+    - Thread-safe initialization
+    - Automatic queue creation
+    - Client reuse
+    - Retry support
+    """
 
-    def __init__(self):
+    def __init__(self, connection_string: str = ""):
         super().__init__()
-        self.connection_string = os.getenv("AZURE_STORAGE_CONNECTION_STRING") or ""
-        self._client = None
+
+        self.connection_string = connection_string or os.getenv("AZURE_STORAGE_CONNECTION_STRING")
+
+        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._lock = threading.Lock()
+
         self._initialize_client()
 
-    def _initialize_client(self):
-        """Initialize Azure Queue Storage client once"""
+    def _initialize_client(self) -> None:
+        """Initialize Azure Queue client"""
         try:
-            from azure.storage.queue import QueueServiceClient
-
             with self._lock:
-                if not self._client:
-                    self._client = QueueServiceClient.from_connection_string(self.connection_string)
-                    self.logger.info("Initialized Azure Queue Storage client")
+                if self._client is not None:
+                    return
+                if not self.connection_string:
+                    raise ConnectionError("AZURE_STORAGE_CONNECTION_STRING is not configured")
+                self._client = QueueServiceClient.from_connection_string(self.connection_string)
+
+                self.logger.info("Initialized Azure Queue Storage client")
+
         except Exception as e:
-            raise ConnectionError(f"Failed to initialize Azure Queue Storage: {str(e)}")
+            raise ConnectionError(f"Failed to initialize Azure Queue Storage: {e}")
+
+    def _get_queue(self, queue_name: str) -> QueueClient:
+        """Get or create queue client"""
+        if self._client is None:
+            raise ConnectionError("Azure Queue client not initialized")
+
+        if queue_name not in self._queues:
+            queue_client = self._client.get_queue_client(queue_name)
+
+            try:
+                queue_client.create_queue()
+            except ResourceExistsError:
+                pass
+
+            self._queues[queue_name] = queue_client
+
+        return self._queues[queue_name]
 
     @retry(max_attempts=3, delay=1.0, exceptions=(QueueError,))
     def send(self, message: Dict[str, Any], queue_name: str = "default") -> str:
         """Send message to queue"""
         try:
-            import json
+            queue_client = self._get_queue(queue_name)
+
+            response = queue_client.send_message(json.dumps(message, default=json_safe))
+
+            return response.id
 
-            if self._client:
-                queue_client = self._client.get_queue_client(queue_name)
-                response = queue_client.send_message(json.dumps(message,default=json_safe))
-                return response.id
-            return ""
         except Exception as e:
-            raise QueueError(f"Azure Queue send failed: {str(e)}")
+            raise QueueError(f"Azure Queue send failed: {e}")
 
     @retry(max_attempts=3, delay=1.0, exceptions=(QueueError,))
     def receive(self, queue_name: str = "default", max_messages: int = 1) -> List[Dict[str, Any]]:
-        """Receive messages from queue"""
+        """Receive messages"""
         try:
-            import json
+            queue_client = self._get_queue(queue_name)
+
+            messages = queue_client.receive_messages(max_messages=max_messages)
+
+            results = []
+
+            for msg in messages:
+                payload = json.loads(msg.content)
+                results.append(
+                    {
+                        "id": msg.id,
+                        "pop_receipt": msg.pop_receipt,
+                        "body": payload,
+                    }
+                )
+
+            return results
 
-            if self._client:
-                queue_client = self._client.get_queue_client(queue_name)
-                messages = queue_client.receive_messages(max_messages=max_messages)
-                return [json.loads(msg.content) for msg in messages]
-            return []
         except Exception as e:
-            raise QueueError(f"Azure Queue receive failed: {str(e)}")
+            raise QueueError(f"Azure Queue receive failed: {e}")
+
+    def delete(self, message_id: str, queue_name: str = "default", pop_receipt: str = "") -> bool:
+        """Delete message from queue"""
+        try:
+            queue_client = self._get_queue(queue_name)
 
-    def delete(self, message_id: str, queue_name: str = "default") -> bool:
-        """Delete message from queue (requires receipt handle)"""
-        return True
+            queue_client.delete_message(message_id, pop_receipt)
+
+            return True
+
+        except ResourceNotFoundError:
+            return False
+        except Exception as e:
+            raise QueueError(f"Azure Queue delete failed: {e}")