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

{altcodepro_polydb_python-2.2.2.dist-info → altcodepro_polydb_python-2.2.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: altcodepro-polydb-python
-Version: 2.2.2
+Version: 2.2.3
 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
@@ -74,6 +74,7 @@ Requires-Dist: isort>=7.0.0; extra == "dev"
 Requires-Dist: mypy>=1.19.1; extra == "dev"
 Provides-Extra: test
 Requires-Dist: pytest>=9.0.2; extra == "test"
+Requires-Dist: pytest-asyncio>=1.2.0; extra == "test"
 Requires-Dist: pytest-cov>=7.0.0; extra == "test"
 Requires-Dist: pytest-mock>=3.15.1; extra == "test"
 Requires-Dist: moto>=5.1.21; extra == "test"

altcodepro_polydb_python-2.2.3.dist-info/RECORD

@@ -0,0 +1,54 @@
+altcodepro_polydb_python-2.2.3.dist-info/licenses/LICENSE,sha256=9X8GLocsBwy-5aR5JGOt2SAMDDPs9Qv-YnqmHBHOXrw,1067
+polydb/__init__.py,sha256=UhUzfSvmMgKbV2tSME1ooIyfshIBi7_WyU4xl1tWWiA,1454
+polydb/advanced_query.py,sha256=cxMB-EB-qT3bWXJlhmjnMCUtrzogORWyoEfS50Dy7go,4280
+polydb/batch.py,sha256=_DjWZa1ZXYSk6MLKqFe0eT7SYVRZtYNqZb9bI8Y2sao,4566
+polydb/cache.py,sha256=FGg5ln2GPhUpj3fljdJ4cygNYhdwJmfQhDhA_2MvOFY,6290
+polydb/cloudDatabaseFactory.py,sha256=P0n0iy5mpjowzz2Kik-WFi33kR9iWFjC7xXsR6AV0VQ,4743
+polydb/databaseFactory.py,sha256=N1BECm02ukmnhvHGujb1wD6X3cMEzJ2zamqDECQnMU0,40261
+polydb/decorators.py,sha256=Rzk8Bj8wHi8YFtc06HEYT5r_Vqqn7TGaCtR5qvHdY-E,420
+polydb/errors.py,sha256=rcFeBH0cenjJ86v0cmDc2Yjj4R019pLCBcTeSC4qps4,1428
+polydb/json_safe.py,sha256=R5PrqAGirqjYKPyy-8KH-lSXjLH0FPr2TSGozy4eheU,149
+polydb/models.py,sha256=HZYKB67ayoS1D4qxYfNLrUplbk7W-SIpexUnz4foyuQ,923
+polydb/monitoring.py,sha256=pwR2p-sSlt6nA29lCAJFmdT0ODIyVQ9gSxB51hgaAbQ,10137
+polydb/multitenancy.py,sha256=9kyY98RpKg8xDy9ejB_MyV_YzF7eZd4uxashw5S8vlg,6408
+polydb/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+polydb/query.py,sha256=L13FL8A06HxT0F_LGlY9IBh-62j1VWZrv2Tu_wS-Ed0,6348
+polydb/registry.py,sha256=g-jLKq5jzDvdZ24weAqZHSxUIUaBsu1TZghxRMqbUXQ,1926
+polydb/retry.py,sha256=etsj8MGo1WMvlcZMzWmFELAsWCRs-XPEuJe6K76QgbM,2548
+polydb/schema.py,sha256=VrOayX6V6AD2Qh3-lm4ZVPTpI24e4V52IYheZf2rNQ4,5812
+polydb/security.py,sha256=-bXdRjFmvq4X6ie6FrZMcO9ZbgjWFkNySSbRwFt1X1Q,16281
+polydb/types.py,sha256=XB_85Un8_aWt4dSfpjIGotHbK3KBY2WurQGXr9EOxWY,2992
+polydb/utils.py,sha256=G_ki5zKr5rGPgpFQM1CTq6twQd5OytaHKfet267MftM,1662
+polydb/validation.py,sha256=a1o1d02k3c6PWQwkBbw_0nEmIgrdB5RR8OcpNQMn4cA,4810
+polydb/adapters/AzureBlobStorageAdapter.py,sha256=U-wOph2p17F7r9OznjXh-JVMKZAWwaj8aamhevYyO78,4736
+polydb/adapters/AzureFileStorageAdapter.py,sha256=OuZY5P-FTQ36954obJN65oSMqmW3d-7QBmXxVGX0lds,6086
+polydb/adapters/AzureQueueAdapter.py,sha256=FR8uj8f6gtGVB92AeNvI-p-4PeyVvM1eezVbBp88TOE,4022
+polydb/adapters/AzureTableStorageAdapter.py,sha256=dqbCCTxXsPvaOf-z9hJ0BfgE51DomyMJOdTN8tyyDsI,18498
+polydb/adapters/DynamoDBAdapter.py,sha256=MSgIk43WT5z0fbBpZJ_5uLq0CfZS2YRfwX06-b_sl3o,18235
+polydb/adapters/EFSAdapter.py,sha256=GFHXn2fjohXxVJaM4ptbisEs5bwiwkHeQ1Av_5ILiCA,1688
+polydb/adapters/FirestoreAdapter.py,sha256=cvDOlxrEI8u81kWkjhazqb2rG4Q4I8Ftoho_cbx9nZQ,13947
+polydb/adapters/GCPPubSubAdapter.py,sha256=0xb-6nzOokaIov-Kq3Dx8i_04GZYbL0XQsXqcSMnwnI,8143
+polydb/adapters/GCPStorageAdapter.py,sha256=pIwBkEt_JNJG3P9nXXI_cLz49K2S7GXkxiFxc_8Dr5U,5733
+polydb/adapters/MongoDBAdapter.py,sha256=vX3SAHDLbTnHABGesES9N-gYSQqPqdqFLJgd7pYWZzw,7471
+polydb/adapters/PostgreSQLAdapter.py,sha256=qYrtDPxaIk_Q0W9DyXYvhbqbSLtheWuSjL1CKpVR8og,24852
+polydb/adapters/S3Adapter.py,sha256=6ZgMvRfwqqk1g0aUCxEjmuVgL6rWEis2Gmf9kVRmVTM,5415
+polydb/adapters/S3CompatibleAdapter.py,sha256=3hiOVEqyGbRX1rnpeldea8aWljSlWgCN3iE-g_Bks0I,3513
+polydb/adapters/SQSAdapter.py,sha256=Ao9IOVLuDafgnnCD7DulGTeobw4tucxuswkx1dwyvSw,5200
+polydb/adapters/VercelBlobAdapter.py,sha256=_azPYw-XBOENsdFIUiNJEaZpR4lmpfsyT7Jtr5iFZxA,5071
+polydb/adapters/VercelKVAdapter.py,sha256=QZxRkuYzVNWFCEFaJPSph8YEAut-YtlXPqbCt0JlROI,8647
+polydb/adapters/VercelQueueAdapter.py,sha256=s_Kpc6m9nIuvA3XbyEW8UH6PWm0-ckhth-taKc50LdQ,1732
+polydb/adapters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+polydb/audit/AuditStorage.py,sha256=A5HLhkWG8kef_caUuWakJf4fSK_r03NN4JLbbK7N55c,4949
+polydb/audit/__init__.py,sha256=m_GE7gjLw00zfHX-1SpkF7QZpRE72HO699ZzKzqD3kc,244
+polydb/audit/context.py,sha256=-A1FMtmr-2snVAHpTrVT80u-D_MCaqX6AoV4Ku2bz_o,1955
+polydb/audit/manager.py,sha256=KzaaOf5bDfr4M-CkCAZBG_U_4xIBCKDLRAf3hsm-DAk,1236
+polydb/audit/models.py,sha256=BgkSEQRbjbourxyGcEeJYIYzozwTM-pqTiSOM_BhWHs,2256
+polydb/base/NoSQLKVAdapter.py,sha256=hiL0QyCV-5ChOyedkOk0ydH5jbtAtKir8IpJyIikPi4,11515
+polydb/base/ObjectStorageAdapter.py,sha256=B4a_em2O5_dJ3DYrP04CvD-92Qgmfa4PVc7kGgeYDwg,1881
+polydb/base/QueueAdapter.py,sha256=u-vi8t8On1NmCyJlgOE1NJ0T3-DpK_8DjRjGwr9Kme0,770
+polydb/base/SharedFilesAdapter.py,sha256=hvmdNNhNxpN46Ob9RLAi8l46GB6JolYyZWnAMuaJ86g,708
+polydb/base/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+altcodepro_polydb_python-2.2.3.dist-info/METADATA,sha256=zEJKZXzcgWztRjKd_kUyIvtHuSWcrtC58OELzu2u62c,10920
+altcodepro_polydb_python-2.2.3.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
+altcodepro_polydb_python-2.2.3.dist-info/top_level.txt,sha256=WgLFWJoYjUhwvyPxJFl6jYLrVFuBJDX3OABf4ocwk_E,7
+altcodepro_polydb_python-2.2.3.dist-info/RECORD,,

polydb/__init__.py

@@ -4,9 +4,9 @@ PolyDB - Enterprise Cloud-Independent Database Abstraction
 Full LINQ support, field-level audit, cache, soft delete, overflow storage
 """
 
-__version__ = "2.2.2"
+__version__ = "2.2.3"
 
-from .factory import CloudDatabaseFactory
+from .cloudDatabaseFactory import CloudDatabaseFactory
 from .databaseFactory import DatabaseFactory
 from .models import CloudProvider, PartitionConfig
 from .decorators import polydb_model

polydb/adapters/AzureBlobStorageAdapter.py

@@ -1,77 +1,141 @@
 # 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 List, Optional
+
+from azure.storage.blob import BlobServiceClient, ContainerClient
+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"""
+        """Upload blob"""
         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}")
+            container = self._require_container()
+
+            blob_client = container.get_blob_client(key)
+            blob_client.upload_blob(data, overwrite=True)
+
+            self.logger.debug(f"Uploaded blob key={key}")
+
             return key
+
         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}")