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

polydb/adapters/BlockchainBlobAdapter.py

@@ -0,0 +1,111 @@
+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
+from ..errors import StorageError
+
+
+class BlockchainBlobAdapter(ObjectStorageAdapter):
+    """
+    Blob storage backed by IPFS.
+
+    - key is ignored for storage (IPFS is content-addressed)
+    - returns CID (acts as key)
+    - metadata is not natively supported → ignored or embedded externally
+    """
+
+    def __init__(self, ipfs_url: Optional[str] = None):
+        super().__init__()
+
+        load_dotenv()
+
+        self.ipfs_url = ipfs_url or os.getenv("IPFS_API_URL", "/dns/localhost/tcp/5001/http")
+
+        try:
+            import ipfshttpclient.client
+
+            ipfshttpclient.client.assert_version = lambda *args, **kwargs: None
+
+            self.client = ipfshttpclient.connect(self.ipfs_url, session=True)
+            self.logger.info(f"Connected to IPFS: {self.ipfs_url}")
+
+        except Exception as e:
+            raise StorageError(f"Failed to connect to IPFS: {e}")
+
+    # --------------------------------------------------
+    # PUT
+    # --------------------------------------------------
+    def _put_raw(
+        self,
+        key: str,
+        data: bytes,
+        fileName: str = "",
+        media_type: Optional[str] = None,
+        metadata: Dict[str, Any] | None = None,
+    ) -> str:
+        """Upload data to IPFS and return CID"""
+        try:
+            res = self.client.add_bytes(data)  # returns CID
+            cid = res
+
+            self.logger.debug(f"IPFS upload success cid={cid}")
+
+            return cid
+
+        except Exception as e:
+            raise StorageError(f"IPFS put failed: {e}")
+
+    # --------------------------------------------------
+    # GET
+    # --------------------------------------------------
+    def get(self, key: str) -> bytes:
+        """Fetch blob from IPFS using CID"""
+        try:
+            data = self.client.cat(key)
+            self.logger.debug(f"IPFS get success cid={key}")
+            return data
+
+        except Exception as e:
+            raise StorageError(f"IPFS get failed: {e}")
+
+    # --------------------------------------------------
+    # DELETE
+    # --------------------------------------------------
+    def delete(self, key: str) -> bool:
+        """
+        IPFS does not support true delete.
+        We can unpin to allow GC.
+        """
+        try:
+            self.client.pin.rm(key)
+            self.logger.debug(f"IPFS unpinned cid={key}")
+            return True
+
+        except Exception:
+            return False
+
+    # --------------------------------------------------
+    # LIST
+    # --------------------------------------------------
+    def list(self, prefix: str = "") -> List[str]:
+        """
+        IPFS has no native listing by prefix.
+        Return pinned CIDs as approximation.
+        """
+        try:
+            pins = self.client.pin.ls(type="all")
+            cids = list(pins.get("Keys", {}).keys())
+
+            if prefix:
+                cids = [cid for cid in cids if cid.startswith(prefix)]
+
+            self.logger.debug(f"IPFS list returned {len(cids)} items")
+            return cids
+
+        except Exception as e:
+            raise StorageError(f"IPFS list failed: {e}")

polydb/adapters/BlockchainKVAdapter.py

@@ -0,0 +1,152 @@
+from __future__ import annotations
+
+import json
+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__)
+
+SUPPORTED_CHAINS = {
+    "ethereum",
+    "polygon",
+    "avalanche",
+    "bnb",
+    "arbitrum",
+}
+
+
+class BlockchainKVAdapter:
+    """
+    Generic blockchain key-value adapter.
+
+    Uses a smart contract to store JSON documents keyed by ID.
+
+    Supports EVM-compatible chains:
+        - Ethereum
+        - Polygon
+        - Avalanche
+        - BNB Chain
+        - 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,
+    ):
+        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_CONTRACT")
+
+        if not self.rpc_url:
+            raise RuntimeError("BLOCKCHAIN_RPC_URL not configured")
+
+        if not self.private_key:
+            raise RuntimeError("BLOCKCHAIN_PRIVATE_KEY not configured")
+
+        if not self.contract_address:
+            raise RuntimeError("BLOCKCHAIN_CONTRACT not configured")
+
+        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)
+
+        if contract_abi is None:
+            contract_abi = self._default_abi()
+
+        self.contract = self.w3.eth.contract(
+            address=Web3.to_checksum_address(self.contract_address),
+            abi=contract_abi,
+        )
+
+    def _default_abi(self):
+        return [
+            {
+                "inputs": [
+                    {"internalType": "string", "name": "key", "type": "string"},
+                    {"internalType": "string", "name": "value", "type": "string"},
+                ],
+                "name": "put",
+                "outputs": [],
+                "stateMutability": "nonpayable",
+                "type": "function",
+            },
+            {
+                "inputs": [{"internalType": "string", "name": "key", "type": "string"}],
+                "name": "get",
+                "outputs": [{"internalType": "string", "name": "", "type": "string"}],
+                "stateMutability": "view",
+                "type": "function",
+            },
+            {
+                "inputs": [{"internalType": "string", "name": "key", "type": "string"}],
+                "name": "deleteKey",
+                "outputs": [],
+                "stateMutability": "nonpayable",
+                "type": "function",
+            },
+        ]
+
+    def _send_tx(self, fn):
+        nonce = self.w3.eth.get_transaction_count(self.account.address)
+
+        tx = fn.build_transaction(
+            {
+                "from": self.account.address,
+                "nonce": nonce,
+                "gas": 500000,
+                "gasPrice": self.w3.eth.gas_price,
+            }
+        )
+
+        signed = self.account.sign_transaction(tx)
+        tx_hash = self.w3.eth.send_raw_transaction(signed.raw_transaction)
+
+        receipt = self.w3.eth.wait_for_transaction_receipt(tx_hash)
+        return receipt
+
+    def put(self, model, data: Dict[str, Any]) -> Dict[str, Any]:
+        key = str(data["id"])
+        payload = json.dumps(data)
+
+        fn = self.contract.functions.put(key, payload)
+        self._send_tx(fn)
+
+        return data
+
+    def get(self, model, key: str) -> Optional[Dict[str, Any]]:
+        result = self.contract.functions.get(str(key)).call()
+
+        if not result:
+            return None
+
+        return json.loads(result)
+
+    def delete(self, model, key: str):
+        fn = self.contract.functions.deleteKey(str(key))
+        self._send_tx(fn)
+
+        return {"id": key}
+
+    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

@@ -0,0 +1,116 @@
+from __future__ import annotations
+
+import json
+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
+
+logger = logging.getLogger(__name__)
+
+
+class BlockchainQueueAdapter:
+    """
+    Queue implementation using blockchain events.
+
+    Messages are emitted via smart contract events and read via event filters.
+    """
+
+    def __init__(
+        self,
+        rpc_url: Optional[str] = None,
+        private_key: Optional[str] = None,
+        contract_address: Optional[str] = None,
+        contract_abi: Optional[list] = None,
+    ):
+        load_dotenv()
+
+        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_QUEUE_CONTRACT")
+
+        if not self.rpc_url:
+            raise RuntimeError("BLOCKCHAIN_RPC_URL not configured")
+
+        self.w3 = Web3(Web3.HTTPProvider(self.rpc_url))
+        self.w3.middleware_onion.inject(ExtraDataToPOAMiddleware, layer=0)
+
+        self.account = self.w3.eth.account.from_key(self.private_key)
+
+        if contract_abi is None:
+            contract_abi = self._default_abi()
+        if self.contract_address is not None:
+            self.contract = self.w3.eth.contract(
+                address=Web3.to_checksum_address(self.contract_address),
+                abi=contract_abi,
+            )
+
+    def _default_abi(self):
+        return [
+            {
+                "anonymous": False,
+                "inputs": [
+                    {"indexed": False, "name": "queue", "type": "string"},
+                    {"indexed": False, "name": "data", "type": "string"},
+                ],
+                "name": "MessagePublished",
+                "type": "event",
+            },
+            {
+                "inputs": [
+                    {"internalType": "string", "name": "queue", "type": "string"},
+                    {"internalType": "string", "name": "data", "type": "string"},
+                ],
+                "name": "publish",
+                "outputs": [],
+                "stateMutability": "nonpayable",
+                "type": "function",
+            },
+        ]
+
+    def _send_tx(self, fn):
+        nonce = self.w3.eth.get_transaction_count(self.account.address)
+
+        tx = fn.build_transaction(
+            {
+                "from": self.account.address,
+                "nonce": nonce,
+                "gas": 300000,
+                "gasPrice": self.w3.eth.gas_price,
+            }
+        )
+
+        signed = self.account.sign_transaction(tx)
+        tx_hash = self.w3.eth.send_raw_transaction(signed.raw_transaction)
+
+        return tx_hash.hex()
+
+    def send(self, message: Dict[str, Any], queue_name: str = "default"):
+        payload = json.dumps(message)
+        fn = self.contract.functions.publish(queue_name, payload)
+        tx_hash = self._send_tx(fn)
+
+        return {"tx": tx_hash}
+
+    def receive(self, queue_name: str = "default", from_block="latest") -> List[Dict]:
+        event_filter = self.contract.events.MessagePublished.create_filter(fromBlock=from_block)
+
+        events = event_filter.get_all_entries()
+
+        messages = []
+
+        for event in events:
+            if event.args.queue == queue_name:
+                messages.append(json.loads(event.args.data))
+
+        return messages
+
+    def delete(self, message_id):
+        """
+        Blockchain queues cannot delete events.
+        This method exists for interface compatibility.
+        """
+        return {"deleted": False}