hive-nectar 0.2.9__py3-none-any.whl

nectar/imageuploader.py

@@ -0,0 +1,114 @@
+import io
+from binascii import hexlify
+from typing import Any, Dict, Optional, Union
+
+import httpx
+from httpx import ConnectError, HTTPStatusError, RequestError, TimeoutException
+
+from nectar.account import Account
+from nectar.exceptions import MissingKeyError
+from nectargraphenebase.ecdsasig import sign_message
+
+from .instance import shared_blockchain_instance
+
+
+class ImageUploader:
+    def __init__(
+        self,
+        base_url: str = "https://images.hive.blog",
+        challenge: str = "ImageSigningChallenge",
+        blockchain_instance: Optional[Any] = None,
+    ) -> None:
+        """
+        Initialize the ImageUploader.
+
+        Parameters:
+            base_url (str): Base URL of the image upload service (default: "https://images.hive.blog").
+            challenge (str): ASCII string prepended to the image bytes when constructing the signing message; ensures signatures are bound to this uploader's purpose.
+
+        Notes:
+            blockchain_instance is an optional blockchain client; if not provided a shared instance is used.
+        """
+        self.challenge = challenge
+        self.base_url = base_url
+        self.blockchain = blockchain_instance or shared_blockchain_instance()
+
+    def upload(
+        self,
+        image: Union[str, bytes, io.BytesIO],
+        account: Union[str, Account],
+        image_name: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Upload an image to the configured image service, signing the upload with the account's posting key.
+
+        The function accepts a filesystem path (str), raw bytes, or an io.BytesIO for the image. It locates the account's posting private key from the blockchain wallet, signs the image data together with the uploader's challenge string, and POSTs the image under the key `image_name` (defaults to "image") to: <base_url>/<account_name>/<signature_hex>.
+
+        Parameters:
+            image (str | bytes | io.BytesIO): Path to an image file, raw image bytes, or an in-memory bytes buffer.
+            account (str | Account): Account identifier (must have posting permission); used to select the signing key.
+            image_name (str, optional): Form field name for the uploaded image (defaults to "image").
+
+        Returns:
+            dict: Parsed JSON response from the image service.
+
+        Raises:
+            AssertionError: If the account's posting permission (and therefore a posting key) cannot be accessed.
+        """
+        account = Account(account, blockchain_instance=self.blockchain)
+        if "posting" not in account:
+            account.refresh()
+        if "posting" not in account:
+            raise AssertionError("Could not access posting permission")
+        posting_wif = None
+        for authority in account["posting"]["key_auths"]:
+            try:
+                posting_wif = self.blockchain.wallet.getPrivateKeyForPublicKey(authority[0])
+                break
+            except MissingKeyError:
+                continue
+        if not posting_wif:
+            raise AssertionError("No local private posting key available to sign the image.")
+
+        if isinstance(image, str):
+            with open(image, "rb") as f:
+                image_data = f.read()
+        elif isinstance(image, io.BytesIO):
+            image_data = image.read()
+        else:
+            image_data = image
+
+        message = bytes(self.challenge, "ascii") + image_data
+        signature = sign_message(message, posting_wif)
+        signature_in_hex = hexlify(signature).decode("ascii")
+
+        # Prepare files for httpx
+        # We want to send the file with the field name "image" (expected by images.hive.blog)
+        # and the filename specified by image_name.
+        # If image_name is not provided, we default to "image".
+        filename = image_name or "image"
+        # files = {'field_name': ('filename', file_data)}
+        files = {"image": (filename, image_data)}
+        url = "{}/{}/{}".format(self.base_url, account["name"], signature_in_hex)
+
+        retries = 3
+        timeout = 60
+
+        with httpx.Client(timeout=timeout) as client:
+            for i in range(retries + 1):
+                try:
+                    r = client.post(url, files=files)
+                    r.raise_for_status()
+                    return r.json()
+                except (
+                    ConnectError,
+                    RequestError,
+                    TimeoutException,
+                    HTTPStatusError,
+                ) as e:
+                    if i < retries:
+                        continue
+                    raise AssertionError(f"Upload failed after {retries} retries: {str(e)}") from e
+
+        # Should be unreachable if loop works correctly
+        raise AssertionError("Upload failed")

nectar/instance.py

@@ -0,0 +1,113 @@
+from typing import Any, Dict
+
+# Track shared httpx client alongside the shared Hive instance so callers that
+# construct Hive directly (e.g., Hive(keys=[...])) still reuse the same pool.
+_shared_transport: Dict[str, Any] = {}
+
+
+class SharedInstance:
+    """Singleton for the shared Blockchain Instance (Hive-only)."""
+
+    instance = None
+    config = {}
+
+
+def shared_blockchain_instance() -> Any:
+    """Initialize and return the shared Hive instance.
+
+    Hive-only: this always returns a `nectar.Hive` instance, regardless of any
+    legacy configuration that may have referenced other chains.
+    """
+    if not SharedInstance.instance:
+        clear_cache()
+        SharedInstance.instance = _build_hive(**SharedInstance.config)
+    return SharedInstance.instance
+
+
+def set_shared_blockchain_instance(blockchain_instance: Any) -> None:
+    """
+    Override the shared Hive instance used by the module and clear related caches.
+
+    This sets SharedInstance.instance to the provided blockchain instance and calls clear_cache()
+    to invalidate any cached blockchain objects so consumers observe the new instance immediately.
+    """
+    clear_cache()
+    SharedInstance.instance = blockchain_instance
+    if hasattr(blockchain_instance, "rpc") and getattr(blockchain_instance, "rpc", None):
+        _shared_transport["rpc"] = blockchain_instance.rpc
+
+
+def shared_hive_instance() -> Any:
+    """Initialize (if needed) and return the shared Hive instance."""
+    return shared_blockchain_instance()
+
+
+def set_shared_hive_instance(hive_instance: Any) -> None:
+    """
+    Override the global shared Hive instance used by the module.
+
+    Replaces the current SharedInstance.instance with the provided hive_instance and clears related caches so subsequent calls return the new instance.
+
+    Parameters:
+        hive_instance: The nectar.Hive instance to set as the shared global instance.
+    """
+    set_shared_blockchain_instance(hive_instance)
+
+
+def clear_cache() -> None:
+    """
+    Clear cached blockchain object state.
+
+    Performs a lazy import of BlockchainObject and calls its clear_cache() method to purge any in-memory caches of blockchain objects (used when the shared Hive instance or configuration changes).
+    """
+    from .blockchainobject import BlockchainObject
+
+    BlockchainObject.clear_cache()
+
+
+def set_shared_config(config: Dict[str, Any]) -> None:
+    """
+    Set configuration for the shared Hive instance without creating the instance.
+
+    Updates the global SharedInstance.config with the provided mapping. If a shared instance already exists, clears internal caches and resets the shared instance to None so the new configuration will take effect on next access.
+
+    Parameters:
+        config (dict): Configuration options to merge into the shared instance configuration.
+
+    Raises:
+        AssertionError: If `config` is not a dict.
+    """
+    if not isinstance(config, dict):
+        raise AssertionError()
+    SharedInstance.config.update(config)
+    # if one is already set, delete
+    if SharedInstance.instance:
+        clear_cache()
+        SharedInstance.instance = None
+
+
+def _build_hive(**config: Any) -> Any:
+    """Internal helper to build a Hive instance while reusing shared transports."""
+    from .hive import Hive
+
+    hive = Hive(**config)
+    stored_rpc = _shared_transport.get("rpc")
+    configured_nodes = config.get("node", [])
+    if isinstance(configured_nodes, str):
+        configured_nodes = [configured_nodes]
+
+    def _rpc_matches_config(rpc_obj: Any) -> bool:
+        if not configured_nodes or rpc_obj is None:
+            return True
+        return getattr(rpc_obj, "url", None) in configured_nodes
+
+    if stored_rpc and getattr(stored_rpc, "url", None) and _rpc_matches_config(stored_rpc):
+        hive.rpc = stored_rpc
+    else:
+        rpc_obj = getattr(hive, "rpc", None)
+        if rpc_obj is not None:
+            current_url = getattr(rpc_obj, "url", None)
+            if not current_url and hasattr(rpc_obj, "rpcconnect"):
+                rpc_obj.rpcconnect()
+        _shared_transport["rpc"] = getattr(hive, "rpc", None)
+    return hive