altcodepro-polydb-python 2.3.9__py3-none-any.whl → 2.3.11__py3-none-any.whl

{altcodepro_polydb_python-2.3.9.dist-info → altcodepro_polydb_python-2.3.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: altcodepro-polydb-python
-Version: 2.3.9
+Version: 2.3.11
 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.11.dist-info/RECORD

@@ -0,0 +1,61 @@
+altcodepro_polydb_python-2.3.11.dist-info/licenses/LICENSE,sha256=9X8GLocsBwy-5aR5JGOt2SAMDDPs9Qv-YnqmHBHOXrw,1067
+polydb/PolyDB.py,sha256=DJjS1a-gjkqqo32avhRM-4CT-9ZZO3LZJ_sUOfZ99L0,23485
+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=JBXF1XEK-fY80ar8SDE893Z1Z116YtXAEG0PaJ0Nkcw,7658
+polydb/cloudDatabaseFactory.py,sha256=Gp6L__YtgrkGahD8B7ItzXMHCoj2ZUGDjXLS9w0TujY,17780
+polydb/databaseFactory.py,sha256=xbcQTJ4kSsayV7rmWfQ3akvbvbCzOnpxjO-KNXykNeE,40862
+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=9uu_BaJ95194n-vnd0Rx9KLc6aPS-mxn10P4W5grUcI,8155
+polydb/monitoring.py,sha256=UMm3ybyRJjAQi-prXXMLl9zuHhnhMnYBzMD3XWK66y8,9571
+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=RD_elvFXcmhTdCyZDm2f3ej0elxqhArnSJ2aO9k5VCU,2352
+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=4vD55Z8DBTzBK66jIJbo5bNMY-AQ61MlP0-P2Fv_JgQ,7083
+polydb/adapters/AzureFileStorageAdapter.py,sha256=VZNprqlBXCuWUgtqClNT-NrQmRf-XFYEiRA2BLbf-Sc,7046
+polydb/adapters/AzureQueueAdapter.py,sha256=5PrKAX4OQxUD5nReZKrInF_mjQVdFcj2aYd0Xp-HjjQ,5254
+polydb/adapters/AzureTableStorageAdapter.py,sha256=EA7v5YUJwe0S3ql0EPg-ObNtX2iNJ38fJiwvRU-1Blo,23295
+polydb/adapters/BlockchainBlobAdapter.py,sha256=D01Yua9mkKfaQrxKYApblIyI6DSP0dtNAh4Tav51HJ4,3299
+polydb/adapters/BlockchainFileAdapter.py,sha256=G749xOVpG20HuKS8zCgi6PMjoJNu-YXK7zitygjLdzM,8335
+polydb/adapters/BlockchainKVAdapter.py,sha256=UFYHyTgvdW-sZUBqyHEG3Cdx6wSTiF2QowEVWL3XPTg,4564
+polydb/adapters/BlockchainQueueAdapter.py,sha256=XsN5ag9Wulaelfkb3RCuBuSBw_4MUx9Wi3Gd3DBn7ME,4196
+polydb/adapters/DynamoDBAdapter.py,sha256=bS4t-XgVMIqMEVfr4K2XMvs-YA1ORTI0Plg5jJ0tW_Q,18429
+polydb/adapters/EFSAdapter.py,sha256=Ca7-Esm3KNVm90Qo6tWmmftwk8Nq54DIzU3fAHX53io,2937
+polydb/adapters/FirestoreAdapter.py,sha256=e3DEODOZ-UAWULLtGTIED-Ym1JrxOKaOLPQVKhhehvk,13939
+polydb/adapters/GCPFilestoreAdapter.py,sha256=yjFQQwsWYWc8mo8XwMViVTWb5_D--xAyTMvE-4AOpNM,3006
+polydb/adapters/GCPPubSubAdapter.py,sha256=7XNots2VA0ReEDku-rjg-OTYmftIpx5UgnXYDdXNkOo,8692
+polydb/adapters/GCPStorageAdapter.py,sha256=9yS1Jhcn5_rCRdZ5uOqcRW6Ba-UNb6VOYpwENP-C6Qk,7133
+polydb/adapters/MongoDBAdapter.py,sha256=vX3SAHDLbTnHABGesES9N-gYSQqPqdqFLJgd7pYWZzw,7471
+polydb/adapters/PostgreSQLAdapter.py,sha256=atK8MEm2ui5kb-xWaDW0-6kn4vwTmaBl5G4BPhK4Gh0,24867
+polydb/adapters/S3Adapter.py,sha256=5R0zHAL2SkGFjp1L3bp-IU468bXYdSf6nKx974MN104,7586
+polydb/adapters/S3CompatibleAdapter.py,sha256=jpafqbAjA8-irdXBrfXa1QJySIzrcUQ6UrFt5h5FAEc,7006
+polydb/adapters/SQSAdapter.py,sha256=1vfbNoqIDy-b8t2xcxy91SoxSYBPFDfUh7yCQWxdS84,5778
+polydb/adapters/VercelBlobAdapter.py,sha256=Hu1u8vE-3rvJMBDotnPKeRoVaH1Vl9PdM1hBKphgj2w,6983
+polydb/adapters/VercelFileAdapter.py,sha256=-fLRCi0AUbyXAR4nkHCV-wXkociHF2hzzEDqWtixIpE,1033
+polydb/adapters/VercelKVAdapter.py,sha256=QZxRkuYzVNWFCEFaJPSph8YEAut-YtlXPqbCt0JlROI,8647
+polydb/adapters/VercelQueueAdapter.py,sha256=cWtPaMIWCako0HHr_rzAE6vMLugSR6zBXqp3VP9MXwY,2375
+polydb/adapters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+polydb/audit/AuditStorage.py,sha256=A5HLhkWG8kef_caUuWakJf4fSK_r03NN4JLbbK7N55c,4949
+polydb/audit/__init__.py,sha256=Z7-y5djq3glQ2Yun6nj-13Efpj3oGz9Qc0veS2g06Y4,245
+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=oa3MT7Z6E5zsF6mDeqjaMfefScKXJgne79LkB7dN8ZA,11557
+polydb/base/ObjectStorageAdapter.py,sha256=mNdJnhoB3VqSCQvmcoel5PohrVQw7Nrajdd5suGBOvQ,2242
+polydb/base/QueueAdapter.py,sha256=jFgyG-SUK4nhRNxm2NbzUbwnA9b_5iAC-ikLSUpXRwk,799
+polydb/base/SharedFilesAdapter.py,sha256=kXbJmtn_cwEyAZ-1AvFrmesCLSwu43ycTV3S4BmwrO4,853
+polydb/base/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+altcodepro_polydb_python-2.3.11.dist-info/METADATA,sha256=CAYda7inNH2AkpAJMK0f12Td5t8TA9W9x8SD6ffYpck,12303
+altcodepro_polydb_python-2.3.11.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+altcodepro_polydb_python-2.3.11.dist-info/top_level.txt,sha256=WgLFWJoYjUhwvyPxJFl6jYLrVFuBJDX3OABf4ocwk_E,7
+altcodepro_polydb_python-2.3.11.dist-info/RECORD,,

polydb/PolyDB.py

@@ -23,7 +23,6 @@ from .types import JsonDict, Lookup
 from .utils import setup_logger
 from .validation import ModelValidator, SchemaValidator
 
-
 ModelRef = Union[Type, str]
 
 
@@ -336,6 +335,7 @@ class PolyDB:
         metadata: Optional[Dict[str, Any]] = None,
         storage_name: str = "default",
         optimize: bool = True,
+        container_name: Optional[str] = None,
     ) -> str:
         storage = self.get_object_storage(storage_name)
         return storage.put(
@@ -345,6 +345,7 @@ class PolyDB:
             optimize=optimize,
             media_type=media_type,
             metadata=metadata or {},
+            container_name=container_name,
         )
 
     def get_blob(

polydb/adapters/AzureBlobStorageAdapter.py

@@ -2,11 +2,8 @@
 
 import os
 import threading
-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 typing import Any, Dict, List, Optional
 from ..base.ObjectStorageAdapter import ObjectStorageAdapter
 from ..errors import ConnectionError, StorageError
 from ..retry import retry
@@ -16,12 +13,10 @@ class AzureBlobStorageAdapter(ObjectStorageAdapter):
     """
     Production-grade Azure Blob Storage adapter.
 
-    Features
-    - Thread-safe client initialization
+    - One BlobServiceClient, many containers (resolved + cached per call)
     - Container auto-creation
-    - Retry support
-    - Structured logging
-    - Connection reuse
+    - 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 = ""):
@@ -33,42 +28,78 @@ class AzureBlobStorageAdapter(ObjectStorageAdapter):
         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._client = None
+        self._containers = {}
         self._lock = threading.Lock()
 
         self._initialize_client()
 
+    # ------------------------------------------------------------------
+    # CLIENT / CONTAINER RESOLUTION
+    # ------------------------------------------------------------------
     def _initialize_client(self) -> None:
-        """Initialize Azure Blob client and container"""
+        """Initialize the shared Azure Blob service client."""
+        from azure.storage.blob import BlobServiceClient
+
         try:
             with self._lock:
-                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)
+                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}")
 
-                self._container = self._client.get_container_client(self.container_name)
+    def _get_container(self, container_name: Optional[str] = None):
+        """Resolve (and cache) a ContainerClient, auto-creating the container."""
+        from azure.core.exceptions import ResourceExistsError
 
-                try:
-                    self._container.create_container()
-                    self.logger.info(f"Created container: {self.container_name}")
-                except ResourceExistsError:
-                    pass
+        if self._client is None:
+            raise ConnectionError("Azure Blob Storage client is not initialized")
 
-                self.logger.info(
-                    f"Azure Blob Storage initialized (container={self.container_name})"
-                )
+        name = container_name or self.container_name
 
-        except Exception as e:
-            raise ConnectionError(f"Failed to initialize Azure Blob Storage: {e}")
+        cached = self._containers.get(name)
+        if cached is not None:
+            return cached
 
-    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
+        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(
@@ -78,105 +109,76 @@ class AzureBlobStorageAdapter(ObjectStorageAdapter):
         fileName: str = "",
         media_type: Optional[str] = None,
         metadata: Dict[str, Any] | None = None,
+        container_name: Optional[str] = None,
     ) -> str:
-        """Upload blob with filename, media type, and metadata"""
-        try:
-            container = self._require_container()
+        """Upload blob. Stored at `key` so get/delete can find it by the same key."""
+        from azure.storage.blob import ContentSettings
 
-            # --------------------------------------------------
-            # Resolve filename
-            # --------------------------------------------------
-            filename = fileName or os.path.basename(key)
+        try:
+            container = self._get_container(container_name)
 
-            # --------------------------------------------------
-            # Ensure extension from media_type if missing
-            # --------------------------------------------------
+            # 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
 
-            # --------------------------------------------------
-            # 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 = 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,
-                },
+                metadata={**(metadata or {}), "filename": filename},
             )
 
-            self.logger.debug(f"Uploaded blob key={blob_key}, type={media_type}")
-
+            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) -> bytes | None:
-        """Download blob"""
-        try:
-            container = self._require_container()
-
-            blob_client = container.get_blob_client(key)
-
-            downloader = blob_client.download_blob()
-            data = downloader.readall()
+    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) -> bool:
-        """Delete blob"""
-        try:
-            container = self._require_container()
-
-            blob_client = container.get_blob_client(key)
-            blob_client.delete_blob(delete_snapshots="include")
+    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 = "") -> List[str]:
-        """List blobs"""
+    def list(self, prefix: str = "", container_name: Optional[str] = None) -> List[str]:
         try:
-            container = self._require_container()
-
-            blobs = container.list_blobs(name_starts_with=prefix)
-            results = [blob.name for blob in blobs]
-
+            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}")

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