altcodepro-polydb-python 2.3.8__py3-none-any.whl → 2.3.10__py3-none-any.whl

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:

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

polydb/adapters/BlockchainFileAdapter.py

@@ -0,0 +1,217 @@
+# src/polydb/adapters/BlockchainFileAdapter.py
+
+from __future__ import annotations
+
+import os
+from typing import List, Optional
+
+from dotenv import load_dotenv
+
+from ..base.SharedFilesAdapter import SharedFilesAdapter
+from ..errors import StorageError, ConnectionError
+
+SUPPORTED_CHAINS = {"ethereum", "polygon", "avalanche", "bnb", "arbitrum"}
+
+
+class BlockchainFileAdapter(SharedFilesAdapter):
+    """
+    Blockchain-backed shared file storage.
+
+    Strategy:
+      - file BYTES are stored on IPFS (content-addressed -> CID)
+      - the PATH -> CID mapping is kept in an on-chain registry contract
+      - per-call `share_name` namespaces the path on-chain
+
+    Fully supported: write / read / delete.
+    Partially supported: list (on-chain listFiles(prefix), with an event-replay
+    fallback — true cheap enumeration needs an off-chain indexer like TheGraph).
+
+    EVM chains: ethereum, polygon, avalanche, bnb, arbitrum.
+    """
+
+    def __init__(
+        self,
+        chain: Optional[str] = None,
+        rpc_url: Optional[str] = None,
+        private_key: Optional[str] = None,
+        contract_address: Optional[str] = None,
+        contract_abi: Optional[list] = None,
+        ipfs_url: Optional[str] = None,
+    ):
+        super().__init__()
+        load_dotenv()
+
+        self.chain = (chain or os.getenv("BLOCKCHAIN_CHAIN", "ethereum")).lower()
+        if self.chain not in SUPPORTED_CHAINS:
+            raise ValueError(f"Unsupported blockchain: {self.chain}")
+
+        self.rpc_url = rpc_url or os.getenv("BLOCKCHAIN_RPC_URL")
+        self.private_key = private_key or os.getenv("BLOCKCHAIN_PRIVATE_KEY")
+        self.contract_address = (
+            contract_address
+            or os.getenv("BLOCKCHAIN_FILE_CONTRACT")
+            or os.getenv("BLOCKCHAIN_CONTRACT")
+        )
+        self.ipfs_url = (ipfs_url or os.getenv("IPFS_API_URL", "http://localhost:5001")).rstrip("/")
+
+        if not self.rpc_url:
+            raise ConnectionError("BLOCKCHAIN_RPC_URL not configured")
+        if not self.private_key:
+            raise ConnectionError("BLOCKCHAIN_PRIVATE_KEY not configured")
+        if not self.contract_address:
+            raise ConnectionError("BLOCKCHAIN_FILE_CONTRACT not configured")
+
+        from web3 import Web3
+        from web3.middleware import ExtraDataToPOAMiddleware
+
+        self.w3 = Web3(Web3.HTTPProvider(self.rpc_url))
+        if self.chain in {"polygon", "avalanche", "bnb"}:
+            self.w3.middleware_onion.inject(ExtraDataToPOAMiddleware, layer=0)
+
+        self.account = self.w3.eth.account.from_key(self.private_key)
+        self.contract = self.w3.eth.contract(
+            address=Web3.to_checksum_address(self.contract_address),
+            abi=contract_abi or self._default_abi(),
+        )
+        self.logger.info(
+            f"Blockchain file adapter ready (chain={self.chain}, ipfs={self.ipfs_url})"
+        )
+
+    # ------------------------------------------------------------------
+    # Contract ABI + tx helpers
+    # ------------------------------------------------------------------
+    def _default_abi(self):
+        return [
+            {
+                "inputs": [{"name": "path", "type": "string"}, {"name": "cid", "type": "string"}],
+                "name": "putFile",
+                "outputs": [],
+                "stateMutability": "nonpayable",
+                "type": "function",
+            },
+            {
+                "inputs": [{"name": "path", "type": "string"}],
+                "name": "getFile",
+                "outputs": [{"name": "", "type": "string"}],
+                "stateMutability": "view",
+                "type": "function",
+            },
+            {
+                "inputs": [{"name": "path", "type": "string"}],
+                "name": "deleteFile",
+                "outputs": [],
+                "stateMutability": "nonpayable",
+                "type": "function",
+            },
+            {
+                "inputs": [{"name": "prefix", "type": "string"}],
+                "name": "listFiles",
+                "outputs": [{"name": "", "type": "string[]"}],
+                "stateMutability": "view",
+                "type": "function",
+            },
+            {
+                "anonymous": False,
+                "inputs": [
+                    {"indexed": False, "name": "path", "type": "string"},
+                    {"indexed": False, "name": "cid", "type": "string"},
+                ],
+                "name": "FileStored",
+                "type": "event",
+            },
+        ]
+
+    def _send_tx(self, fn):
+        nonce = self.w3.eth.get_transaction_count(self.account.address)
+        try:
+            gas = int(fn.estimate_gas({"from": self.account.address}) * 1.2)
+        except Exception:
+            gas = 500000
+        tx = fn.build_transaction(
+            {
+                "from": self.account.address,
+                "nonce": nonce,
+                "gas": gas,
+                "gasPrice": self.w3.eth.gas_price,
+            }
+        )
+        signed = self.account.sign_transaction(tx)
+        tx_hash = self.w3.eth.send_raw_transaction(signed.raw_transaction)
+        return self.w3.eth.wait_for_transaction_receipt(tx_hash)
+
+    @staticmethod
+    def _key(path: str, share_name: Optional[str] = None) -> str:
+        path = (path or "").lstrip("/")
+        if share_name:
+            return f"{share_name.strip('/')}/{path}".rstrip("/")
+        return path
+
+    # ------------------------------------------------------------------
+    # IPFS bytes layer
+    # ------------------------------------------------------------------
+    def _ipfs_add(self, data: bytes) -> str:
+        import requests
+
+        resp = requests.post(f"{self.ipfs_url}/api/v0/add", files={"file": data}, timeout=60)
+        resp.raise_for_status()
+        return resp.json()["Hash"]
+
+    def _ipfs_cat(self, cid: str) -> bytes:
+        import requests
+
+        resp = requests.post(f"{self.ipfs_url}/api/v0/cat", params={"arg": cid}, timeout=60)
+        resp.raise_for_status()
+        return resp.content
+
+    # ------------------------------------------------------------------
+    # SharedFilesAdapter interface
+    # ------------------------------------------------------------------
+    def write(self, path: str, data: bytes, share_name: Optional[str] = None) -> bool:
+        try:
+            cid = self._ipfs_add(data)
+            self._send_tx(self.contract.functions.putFile(self._key(path, share_name), cid))
+            self.logger.debug(f"Blockchain file stored path={path} cid={cid}")
+            return True
+        except Exception as e:
+            raise StorageError(f"Blockchain file write failed: {str(e)}")
+
+    def read(self, path: str, share_name: Optional[str] = None) -> bytes | None:
+        try:
+            cid = self.contract.functions.getFile(self._key(path, share_name)).call()
+            if not cid:
+                return None
+            return self._ipfs_cat(cid)
+        except Exception as e:
+            raise StorageError(f"Blockchain file read failed: {str(e)}")
+
+    def delete(self, path: str, share_name: Optional[str] = None) -> bool:
+        try:
+            key = self._key(path, share_name)
+            if not self.contract.functions.getFile(key).call():
+                return False  # nothing mapped
+            self._send_tx(self.contract.functions.deleteFile(key))
+            return True
+        except Exception as e:
+            raise StorageError(f"Blockchain file delete failed: {str(e)}")
+
+    def list(self, directory: str = "", share_name: Optional[str] = None) -> List[str]:
+        prefix = self._key(directory, share_name)
+
+        # 1) native on-chain enumeration if the contract supports it
+        try:
+            keys = self.contract.functions.listFiles(prefix).call()
+            return list(keys)
+        except Exception:
+            pass
+
+        # 2) fallback: replay FileStored events and reconstruct live keys
+        try:
+            evt = self.contract.events.FileStored.create_filter(fromBlock=0)
+            keys = {}
+            for e in evt.get_all_entries():
+                p = e["args"]["path"]
+                if p.startswith(prefix):
+                    keys[p] = e["args"]["cid"]
+            return list(keys.keys())
+        except Exception as e:
+            raise StorageError(f"Blockchain file list failed: {str(e)}")

polydb/adapters/BlockchainKVAdapter.py

@@ -5,8 +5,7 @@ import logging
 import os
 from typing import Any, Dict, Optional
 
-from web3 import Web3
-from web3.middleware import ExtraDataToPOAMiddleware
+
 from dotenv import load_dotenv
 
 logger = logging.getLogger(__name__)
@@ -61,6 +60,8 @@ class BlockchainKVAdapter:
 
         if not self.contract_address:
             raise RuntimeError("BLOCKCHAIN_CONTRACT not configured")
+        from web3 import Web3
+        from web3.middleware import ExtraDataToPOAMiddleware
 
         self.w3 = Web3(Web3.HTTPProvider(self.rpc_url))
 
@@ -149,4 +150,4 @@ class BlockchainKVAdapter:
     def query(self, model, query: Dict[str, Any], limit: Optional[int] = None):
         raise NotImplementedError(
             "Blockchain query requires an off-chain indexer (TheGraph / Elastic)"
-        )
+        )

polydb/adapters/BlockchainQueueAdapter.py

@@ -5,8 +5,7 @@ import logging
 import os
 from typing import Any, Dict, List, Optional
 
-from web3 import Web3
-from web3.middleware import ExtraDataToPOAMiddleware
+
 from dotenv import load_dotenv
 
 from ..errors import QueueError
@@ -36,6 +35,8 @@ class BlockchainQueueAdapter:
 
         if not self.rpc_url:
             raise RuntimeError("BLOCKCHAIN_RPC_URL not configured")
+        from web3 import Web3
+        from web3.middleware import ExtraDataToPOAMiddleware
 
         self.w3 = Web3(Web3.HTTPProvider(self.rpc_url))
         self.w3.middleware_onion.inject(ExtraDataToPOAMiddleware, layer=0)

polydb/adapters/DynamoDBAdapter.py

@@ -9,9 +9,7 @@ import threading
 from polydb.errors import DatabaseError
 from typing import Any, Dict, List, Optional, Tuple
 
-from boto3.dynamodb.conditions import Attr, Key
-from botocore.exceptions import ClientError
-from boto3.session import Session
+
 from ..base.NoSQLKVAdapter import NoSQLKVAdapter
 from ..errors import ConnectionError, NoSQLError
 from ..json_safe import json_safe
@@ -78,6 +76,9 @@ class DynamoDBAdapter(NoSQLKVAdapter):
     # ---------------------------------------------------------------------
 
     def _initialize_clients(self) -> None:
+
+        from boto3.session import Session
+
         try:
             with self._lock:
                 if self._dynamodb and self._s3:
@@ -120,6 +121,9 @@ class DynamoDBAdapter(NoSQLKVAdapter):
         Ensure PK/SK table exists. Safe in prod (no-op if exists).
         Required for LocalStack integration tests.
         """
+        from boto3.dynamodb.conditions import Attr, Key
+        from botocore.exceptions import ClientError
+
         if not self._dynamodb:
             return
 
@@ -307,6 +311,9 @@ class DynamoDBAdapter(NoSQLKVAdapter):
         Prefer Query when PK can be derived. Otherwise Scan.
         Supports filters like {"id": "..."} and arbitrary Attr equality.
         """
+        from boto3.dynamodb.conditions import Attr, Key
+        from botocore.exceptions import ClientError
+
         try:
             table = self._get_table(model)
             filters = filters or {}
@@ -412,6 +419,8 @@ class DynamoDBAdapter(NoSQLKVAdapter):
         results until page_size items are returned
         - continuation_token = base64(json(LastEvaluatedKey))
         """
+        from boto3.dynamodb.conditions import Attr, Key
+
         try:
             table = self._get_table(model)
             query = query or {}

polydb/adapters/EFSAdapter.py

@@ -1,51 +1,77 @@
 # src/polydb/adapters/EFSAdapter.py
 
-from polydb.base.SharedFilesAdapter import SharedFilesAdapter
-from polydb.errors import StorageError
 import os
-from typing import List
+from typing import List, Optional
+
+from ..base.SharedFilesAdapter import SharedFilesAdapter
+from ..errors import StorageError, ConnectionError
 
 
 class EFSAdapter(SharedFilesAdapter):
-    """AWS EFS (mounted filesystem)"""
+    """
+    AWS EFS — managed NFS mounted onto the host at a path (e.g. /mnt/efs).
+    Once mounted it's an ordinary POSIX directory, so ops are plain os/open calls.
+
+    - per-call `share_name` selects a sub-root directory under the mount point
+    - paths are confined to the resolved root (no traversal escapes)
+    """
 
-    def __init__(self, mount_point: str):
+    def __init__(self, mount_point: str = ""):
         super().__init__()
         self.mount_point = mount_point or os.getenv("EFS_MOUNT_POINT", "/mnt/efs")
+        if not self.mount_point:
+            raise ConnectionError("EFS mount_point is required")
+
+    def _resolve(self, path: str, share_name: Optional[str] = None) -> str:
+        base = os.path.join(self.mount_point, share_name) if share_name else self.mount_point
+        base_abs = os.path.abspath(base)
+        rel = (path or "").lstrip("/\\")
+        full_abs = os.path.abspath(os.path.join(base_abs, rel))
+        if full_abs != base_abs and not full_abs.startswith(base_abs + os.sep):
+            raise StorageError(f"Path escapes storage root: {path}")
+        return full_abs
 
-    def write(self, path: str, data: bytes) -> bool:
-        """Write file"""
+    def write(self, path: str, data: bytes, share_name: Optional[str] = None) -> bool:
         try:
-            full_path = os.path.join(self.mount_point, path)
+            full_path = self._resolve(path, share_name)
             os.makedirs(os.path.dirname(full_path), exist_ok=True)
             with open(full_path, "wb") as f:
                 f.write(data)
             return True
+        except StorageError:
+            raise
         except Exception as e:
             raise StorageError(f"EFS write failed: {str(e)}")
 
-    def read(self, path: str) -> bytes:
-        """Read file"""
+    def read(self, path: str, share_name: Optional[str] = None) -> bytes | None:
         try:
-            full_path = os.path.join(self.mount_point, path)
-            with open(full_path, "rb") as f:
+            with open(self._resolve(path, share_name), "rb") as f:
                 return f.read()
+        except FileNotFoundError:
+            return None
+        except StorageError:
+            raise
         except Exception as e:
             raise StorageError(f"EFS read failed: {str(e)}")
 
-    def delete(self, path: str) -> bool:
-        """Delete file"""
+    def delete(self, path: str, share_name: Optional[str] = None) -> bool:
         try:
-            full_path = os.path.join(self.mount_point, path)
-            os.remove(full_path)
+            os.remove(self._resolve(path, share_name))
             return True
+        except FileNotFoundError:
+            return False
+        except StorageError:
+            raise
         except Exception as e:
             raise StorageError(f"EFS delete failed: {str(e)}")
 
-    def list(self, directory: str = "/") -> List[str]:
-        """List files in directory"""
+    def list(self, directory: str = "", share_name: Optional[str] = None) -> List[str]:
         try:
-            full_path = os.path.join(self.mount_point, directory)
+            full_path = self._resolve(directory, share_name)
+            if not os.path.isdir(full_path):
+                return []
             return os.listdir(full_path)
+        except StorageError:
+            raise
         except Exception as e:
             raise StorageError(f"EFS list failed: {str(e)}")

polydb/adapters/FirestoreAdapter.py

@@ -6,12 +6,7 @@ import json
 import os
 import threading
 from sqlite3 import DatabaseError
-from typing import Any, Dict, List, Optional, Tuple
-
-from google.cloud import firestore
-from google.cloud import storage
-from google.cloud.firestore import Client
-from google.cloud.firestore_v1.base_query import FieldFilter
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple
 
 from ..base.NoSQLKVAdapter import NoSQLKVAdapter
 from ..errors import ConnectionError, NoSQLError
@@ -20,6 +15,10 @@ from ..models import PartitionConfig
 from ..retry import retry
 from ..types import JsonDict
 
+if TYPE_CHECKING:  # type-checker only — not imported at runtime
+    from google.cloud import storage
+    from google.cloud.firestore import Client
+
 
 class FirestoreAdapter(NoSQLKVAdapter):
     """
@@ -31,6 +30,10 @@ class FirestoreAdapter(NoSQLKVAdapter):
     - delete() returns {"id": <pk>} and raises DatabaseError on missing
     - query_page() returns (rows, token) with stable pagination
     - Emulator support via FIRESTORE_EMULATOR_HOST
+
+    NOTE: google-cloud-firestore / google-cloud-storage are imported lazily
+    inside the methods that use them, so installing them is only required when
+    this adapter is actually used.
     """
 
     FIRESTORE_MAX_SIZE = 1024 * 1024  # 1MB doc limit (practical)
@@ -66,6 +69,8 @@ class FirestoreAdapter(NoSQLKVAdapter):
     # ---------------------------------------------------------------------
 
     def _initialize_clients(self) -> None:
+        from google.cloud import firestore, storage  # lazy: GCP only
+
         try:
             with self._lock:
                 if self._client:
@@ -242,6 +247,8 @@ class FirestoreAdapter(NoSQLKVAdapter):
         Note: Firestore requires indexes for some compound queries in real GCP.
         Emulator usually allows most.
         """
+        from google.cloud.firestore_v1.base_query import FieldFilter  # lazy: GCP only
+
         try:
             collection = self._get_collection(model)
             query = collection
@@ -312,9 +319,7 @@ class FirestoreAdapter(NoSQLKVAdapter):
             raise NoSQLError(f"Firestore delete failed: {e}")
 
     # ---------------------------------------------------------------------
-    # Pagination helper used by NoSQLKVAdapter.query_page (if it calls _query_page_raw)
-    # If your base calls only _query_raw, you can still add a public query_page method
-    # in NoSQLKVAdapter; but since your tests call gcp_nosql.query_page(...) we provide it.
+    # Pagination
     # ---------------------------------------------------------------------
 
     def query_page(
@@ -327,11 +332,8 @@ class FirestoreAdapter(NoSQLKVAdapter):
     ) -> Tuple[List[JsonDict], Optional[str]]:
         """
         Returns (rows, next_token). Token is last document id from the page.
-
-        Works with your tests:
-          page1, tok = gcp_nosql.query_page(GcpItem, {"tenant_id": tag}, 3)
-          page2, _   = gcp_nosql.query_page(GcpItem, {"tenant_id": tag}, 3, tok)
         """
+        from google.cloud.firestore_v1.base_query import FieldFilter  # lazy: GCP only
 
         try:
             collection = self._get_collection(model)

polydb/adapters/GCPFilestoreAdapter.py

@@ -0,0 +1,77 @@
+# src/polydb/adapters/GCPFilestoreAdapter.py
+
+import os
+from typing import List, Optional
+
+from ..base.SharedFilesAdapter import SharedFilesAdapter
+from ..errors import StorageError, ConnectionError
+
+
+class FilestoreAdapter(SharedFilesAdapter):
+    """
+    GCP Filestore — managed NFS mounted onto the host at a path (e.g. /mnt/filestore).
+    Like EFS, it's a POSIX directory once mounted, so ops are plain os/open calls.
+
+    - per-call `share_name` selects a sub-root directory under the mount point
+    - paths are confined to the resolved root (no traversal escapes)
+    """
+
+    def __init__(self, mount_point: str = ""):
+        super().__init__()
+        self.mount_point = mount_point or os.getenv("FILESTORE_MOUNT_POINT", "/mnt/filestore")
+        if not self.mount_point:
+            raise ConnectionError("Filestore mount_point is required")
+
+    def _resolve(self, path: str, share_name: Optional[str] = None) -> str:
+        base = os.path.join(self.mount_point, share_name) if share_name else self.mount_point
+        base_abs = os.path.abspath(base)
+        rel = (path or "").lstrip("/\\")
+        full_abs = os.path.abspath(os.path.join(base_abs, rel))
+        if full_abs != base_abs and not full_abs.startswith(base_abs + os.sep):
+            raise StorageError(f"Path escapes storage root: {path}")
+        return full_abs
+
+    def write(self, path: str, data: bytes, share_name: Optional[str] = None) -> bool:
+        try:
+            full_path = self._resolve(path, share_name)
+            os.makedirs(os.path.dirname(full_path), exist_ok=True)
+            with open(full_path, "wb") as f:
+                f.write(data)
+            return True
+        except StorageError:
+            raise
+        except Exception as e:
+            raise StorageError(f"Filestore write failed: {str(e)}")
+
+    def read(self, path: str, share_name: Optional[str] = None) -> bytes | None:
+        try:
+            with open(self._resolve(path, share_name), "rb") as f:
+                return f.read()
+        except FileNotFoundError:
+            return None
+        except StorageError:
+            raise
+        except Exception as e:
+            raise StorageError(f"Filestore read failed: {str(e)}")
+
+    def delete(self, path: str, share_name: Optional[str] = None) -> bool:
+        try:
+            os.remove(self._resolve(path, share_name))
+            return True
+        except FileNotFoundError:
+            return False
+        except StorageError:
+            raise
+        except Exception as e:
+            raise StorageError(f"Filestore delete failed: {str(e)}")
+
+    def list(self, directory: str = "", share_name: Optional[str] = None) -> List[str]:
+        try:
+            full_path = self._resolve(directory, share_name)
+            if not os.path.isdir(full_path):
+                return []
+            return os.listdir(full_path)
+        except StorageError:
+            raise
+        except Exception as e:
+            raise StorageError(f"Filestore list failed: {str(e)}")

polydb/adapters/GCPPubSubAdapter.py

@@ -3,7 +3,6 @@ import json
 import threading
 from typing import Any, Dict, List, Optional, Tuple, Union
 
-from google.cloud import pubsub_v1
 from google.api_core.exceptions import AlreadyExists, NotFound
 
 from ..base.QueueAdapter import QueueAdapter
@@ -11,7 +10,6 @@ from ..errors import ConnectionError, QueueError
 from ..retry import retry
 from ..json_safe import json_safe
 
-
 JsonLike = Union[Dict[str, Any], List[Any], str, int, float, bool, None]
 
 
@@ -40,13 +38,15 @@ class GCPPubSubAdapter(QueueAdapter):
             "PUBSUB_SUBSCRIPTION", "polydb-sub"
         )
 
-        self._publisher: Optional[pubsub_v1.PublisherClient] = None
-        self._subscriber: Optional[pubsub_v1.SubscriberClient] = None
+        self._publisher = None
+        self._subscriber = None
         self._lock = threading.Lock()
 
         self._initialize_clients()
 
     def _initialize_clients(self) -> None:
+        from google.cloud import pubsub_v1
+
         try:
             with self._lock:
                 if self._publisher and self._subscriber: