hive-nectar 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

nectar/comment.py

@@ -43,7 +43,7 @@ class Comment(BlockchainObject):
     >>> from nectar.comment import Comment
     >>> from nectar.account import Account
     >>> # Create a Hive blockchain instance
-    >>> from nectar.blockchain import Blockchain as Hive
+    >>> from nectar import Hive
     >>> hv = Hive()
     >>> acc = Account("gtg", blockchain_instance=hv)
     >>> authorperm = acc.get_blog(limit=1)[0]["authorperm"]
@@ -467,9 +467,9 @@ class Comment(BlockchainObject):
             Amount: Estimated HBD payout required to offset the early-vote curation penalty.
         """
         self.refresh()
-        if self.blockchain.hardfork() >= 21:
+        if self.blockchain.hardfork >= 21:
             reverse_auction_window_seconds = HIVE_REVERSE_AUCTION_WINDOW_SECONDS_HF21
-        elif self.blockchain.hardfork() >= 20:
+        elif self.blockchain.hardfork >= 20:
             reverse_auction_window_seconds = HIVE_REVERSE_AUCTION_WINDOW_SECONDS_HF20
         else:
             reverse_auction_window_seconds = HIVE_REVERSE_AUCTION_WINDOW_SECONDS_HF6
@@ -526,9 +526,9 @@ class Comment(BlockchainObject):
             elapsed_seconds = (vote_time - self["created"]).total_seconds()
         else:
             raise ValueError("vote_time must be a string or a datetime")
-        if self.blockchain.hardfork() >= 21:
+        if self.blockchain.hardfork >= 21:
             reward = elapsed_seconds / HIVE_REVERSE_AUCTION_WINDOW_SECONDS_HF21
-        elif self.blockchain.hardfork() >= 20:
+        elif self.blockchain.hardfork >= 20:
             reward = elapsed_seconds / HIVE_REVERSE_AUCTION_WINDOW_SECONDS_HF20
         else:
             reward = elapsed_seconds / HIVE_REVERSE_AUCTION_WINDOW_SECONDS_HF6
@@ -675,7 +675,7 @@ class Comment(BlockchainObject):
         curation_tokens = self.reward * author_reward_factor
         author_tokens = self.reward - curation_tokens
         curation_rewards = self.get_curation_rewards()
-        if self.blockchain.hardfork() >= 20 and median_hist is not None:
+        if self.blockchain.hardfork >= 20 and median_hist is not None:
             author_tokens += median_price * curation_rewards["unclaimed_rewards"]
         benefactor_tokens = author_tokens * beneficiaries_pct / HIVE_100_PERCENT
         author_tokens -= benefactor_tokens
@@ -1209,9 +1209,10 @@ class RankedPosts(list):
         if not self.blockchain.is_connected():
             return None
         comments = []
-        api_limit = limit
-        if api_limit > 100:
-            api_limit = 100
+        # Bridge API enforces a maximum page size (typically 20). Cap
+        # per-request size accordingly and page until `limit` is reached.
+        # Previously capped to 100 which can trigger Invalid parameters.
+        api_limit = min(limit, 20)
         last_n = -1
         while len(comments) < limit and last_n != len(comments):
             last_n = len(comments)
@@ -1248,8 +1249,9 @@ class RankedPosts(list):
                 if len(comments) > 0:
                     start_author = comments[-1]["author"]
                     start_permlink = comments[-1]["permlink"]
-                if limit - len(comments) < 100:
-                    api_limit = limit - len(comments) + 1
+                # Recompute per-request limit, capped to bridge max (20)
+                remaining = limit - len(comments)
+                api_limit = min(20, remaining + 1) if remaining < 20 else 20
             except Exception as e:
                 # If we get an error but have some posts, return what we have
                 if len(comments) > 0:
@@ -1312,9 +1314,9 @@ class AccountPosts(list):
         if not self.blockchain.is_connected():
             return None
         comments = []
-        api_limit = limit
-        if api_limit > 100:
-            api_limit = 100
+        # Bridge API typically restricts page size to 20; cap per-request size
+        # and page as needed until overall `limit` is satisfied.
+        api_limit = min(limit, 20)
         last_n = -1
         while len(comments) < limit and last_n != len(comments):
             last_n = len(comments)
@@ -1351,8 +1353,9 @@ class AccountPosts(list):
                 if len(comments) > 0:
                     start_author = comments[-1]["author"]
                     start_permlink = comments[-1]["permlink"]
-                if limit - len(comments) < 100:
-                    api_limit = limit - len(comments) + 1
+                # Recompute per-request limit for next page, still capped at 20
+                remaining = limit - len(comments)
+                api_limit = min(20, remaining + 1) if remaining < 20 else 20
             except Exception as e:
                 # If we get an error but have some posts, return what we have
                 if len(comments) > 0:

nectar/haf.py

@@ -0,0 +1,380 @@
+# -*- coding: utf-8 -*-
+import json
+import logging
+from typing import Any, Dict, Optional
+
+import requests
+
+from nectar.instance import shared_blockchain_instance
+
+log = logging.getLogger(__name__)
+
+
+class HAF(object):
+    """Hive Account Feed (HAF) API client for accessing Hive blockchain endpoints.
+
+    This class provides access to various Hive API endpoints that are not part of the
+    standard RPC blockchain calls. It supports multiple API providers and handles
+    reputation queries and other HAF-related data.
+
+    :param str api: Base API URL to use for requests. Supported endpoints include:
+        - 'https://api.hive.blog' (default)
+        - 'https://api.syncad.com'
+    :param blockchain_instance: Blockchain instance for compatibility with the nectar ecosystem
+
+    .. code-block:: python
+
+        >>> from nectar.haf import HAF
+        >>> haf = HAF()  # doctest: +SKIP
+        >>> reputation = haf.reputation("thecrazygm")  # doctest: +SKIP
+        >>> print(reputation)  # doctest: +SKIP
+
+    """
+
+    DEFAULT_APIS = ["https://api.hive.blog", "https://api.syncad.com"]
+
+    def __init__(
+        self, api: Optional[str] = None, blockchain_instance=None, timeout: Optional[float] = None
+    ):
+        """
+        Initialize the HAF client.
+
+        Parameters:
+            api (str, optional): Base API URL. If None, uses the first available default API.
+            blockchain_instance: Blockchain instance for ecosystem compatibility.
+            timeout (float, optional): Timeout for requests in seconds.
+        """
+        self.api = api or self.DEFAULT_APIS[0]
+        self.blockchain = blockchain_instance or shared_blockchain_instance()
+        self._timeout = float(timeout) if timeout else 30.0
+
+        # Validate API URL
+        if not self.api.startswith(("http://", "https://")):
+            raise ValueError(f"Invalid API URL: {self.api}. Must start with http:// or https://")
+
+        # Remove trailing slash if present
+        self.api = self.api.rstrip("/")
+
+        log.debug(f"Initialized HAF client with API: {self.api}")
+
+    def _make_request(self, endpoint: str, method: str = "GET", **kwargs) -> Any:
+        """
+        Make an HTTP request to the HAF API.
+
+        Parameters:
+            endpoint (str): API endpoint path (without leading slash)
+            method (str): HTTP method (default: 'GET')
+            **kwargs: Additional arguments passed to requests
+
+        Returns:
+            dict: JSON response from the API
+
+        Raises:
+            requests.RequestException: If the request fails
+            ValueError: If the response is not valid JSON
+        """
+        url = f"{self.api}/{endpoint}"
+
+        # Set default headers
+        headers = kwargs.pop("headers", {})
+        headers.setdefault("accept", "application/json")
+        headers.setdefault("User-Agent", "hive-nectar/0.1.3")
+
+        log.debug(f"Making {method} request to: {url}")
+
+        try:
+            timeout = kwargs.pop("timeout", self._timeout)
+            response = requests.request(method, url, headers=headers, timeout=timeout, **kwargs)
+            response.raise_for_status()
+
+            return response.json()
+
+        except requests.RequestException as e:
+            log.error(f"Request failed for {url}: {e}")
+            raise
+        except json.JSONDecodeError as e:
+            log.error(f"Invalid JSON response from {url}: {e}")
+            raise ValueError(f"Invalid JSON response from API: {e}")
+
+    def reputation(self, account: str) -> Optional[Dict[str, Any]]:
+        """
+        Get reputation information for a Hive account.
+
+        This method queries the reputation API endpoint to retrieve the account's
+        reputation score and related metadata.
+
+        Parameters:
+            account (str): Hive account name
+
+        Returns:
+            dict or None: Reputation data containing account information and reputation score,
+                         or None if the request fails or account is not found
+
+        Example:
+            >>> haf = HAF()  # doctest: +SKIP
+            >>> rep = haf.reputation("thecrazygm")  # doctest: +SKIP
+            >>> print(rep)  # doctest: +SKIP
+            {'account': 'thecrazygm', 'reputation': '71', ...}
+
+        """
+        if not account or not isinstance(account, str):
+            raise ValueError("Account name must be a non-empty string")
+
+        try:
+            endpoint = f"reputation-api/accounts/{account}/reputation"
+            response = self._make_request(endpoint)
+
+            log.debug(f"Retrieved reputation for account: {account}")
+            return response
+
+        except requests.RequestException as e:
+            log.warning(f"Failed to retrieve reputation for account {account}: {e}")
+            return None
+        except Exception as e:
+            log.error(f"Unexpected error retrieving reputation for {account}: {e}")
+            return None
+
+    def get_available_apis(self) -> list[str]:
+        """
+        Get the list of available API endpoints.
+
+        Returns:
+            list: List of supported API URLs
+        """
+        return self.DEFAULT_APIS.copy()
+
+    def set_api(self, api: str) -> None:
+        """
+        Change the API endpoint.
+
+        Parameters:
+            api (str): New API URL to use
+
+        Raises:
+            ValueError: If the API URL is invalid
+        """
+        if api not in self.DEFAULT_APIS:
+            log.warning(f"Using non-default API: {api}")
+
+        # Validate URL
+        if not api.startswith(("http://", "https://")):
+            raise ValueError(f"Invalid API URL: {api}. Must start with http:// or https://")
+
+        self.api = api.rstrip("/")
+        log.info(f"Switched to API: {self.api}")
+
+    def get_current_api(self) -> str:
+        """
+        Get the currently active API endpoint.
+
+        Returns:
+            str: Current API URL
+        """
+        return self.api
+
+    def get_account_balances(self, account: str) -> Optional[Dict[str, Any]]:
+        """
+        Get account balances from the balance API.
+
+        This method retrieves comprehensive balance information including HBD, HIVE,
+        vesting shares, rewards, and other balance-related data for an account.
+
+        Parameters:
+            account (str): Hive account name
+
+        Returns:
+            dict or None: Account balance data or None if request fails
+
+        Example:
+            >>> haf = HAF()  # doctest: +SKIP
+            >>> balances = haf.get_account_balances("thecrazygm")  # doctest: +SKIP
+            >>> print(balances['hive_balance'])  # doctest: +SKIP
+        """
+        if not account or not isinstance(account, str):
+            raise ValueError("Account name must be a non-empty string")
+
+        try:
+            endpoint = f"balance-api/accounts/{account}/balances"
+            response = self._make_request(endpoint)
+
+            log.debug(f"Retrieved balances for account: {account}")
+            return response
+
+        except requests.RequestException as e:
+            log.warning(f"Failed to retrieve balances for account {account}: {e}")
+            return None
+        except Exception as e:
+            log.error(f"Unexpected error retrieving balances for {account}: {e}")
+            return None
+
+    def get_account_delegations(self, account: str) -> Optional[Dict[str, Any]]:
+        """
+        Get account delegations from the balance API.
+
+        This method retrieves both incoming and outgoing delegations for an account.
+
+        Parameters:
+            account (str): Hive account name
+
+        Returns:
+            dict or None: Delegation data containing incoming and outgoing delegations
+
+        Example:
+            >>> haf = HAF()  # doctest: +SKIP
+            >>> delegations = haf.get_account_delegations("thecrazygm")  # doctest: +SKIP
+            >>> print(delegations['incoming_delegations'])  # doctest: +SKIP
+        """
+        if not account or not isinstance(account, str):
+            raise ValueError("Account name must be a non-empty string")
+
+        try:
+            endpoint = f"balance-api/accounts/{account}/delegations"
+            response = self._make_request(endpoint)
+
+            log.debug(f"Retrieved delegations for account: {account}")
+            return response
+
+        except requests.RequestException as e:
+            log.warning(f"Failed to retrieve delegations for account {account}: {e}")
+            return None
+        except Exception as e:
+            log.error(f"Unexpected error retrieving delegations for {account}: {e}")
+            return None
+
+    def get_account_recurrent_transfers(self, account: str) -> Optional[Dict[str, Any]]:
+        """
+        Get account recurrent transfers from the balance API.
+
+        This method retrieves both incoming and outgoing recurrent transfers for an account.
+
+        Parameters:
+            account (str): Hive account name
+
+        Returns:
+            dict or None: Recurrent transfer data containing incoming and outgoing transfers
+
+        Example:
+            >>> haf = HAF()  # doctest: +SKIP
+            >>> transfers = haf.get_account_recurrent_transfers("thecrazygm")  # doctest: +SKIP
+            >>> print(transfers['outgoing_recurrent_transfers'])  # doctest: +SKIP
+        """
+        if not account or not isinstance(account, str):
+            raise ValueError("Account name must be a non-empty string")
+
+        try:
+            endpoint = f"balance-api/accounts/{account}/recurrent-transfers"
+            response = self._make_request(endpoint)
+
+            log.debug(f"Retrieved recurrent transfers for account: {account}")
+            return response
+
+        except requests.RequestException as e:
+            log.warning(f"Failed to retrieve recurrent transfers for account {account}: {e}")
+            return None
+        except Exception as e:
+            log.error(f"Unexpected error retrieving recurrent transfers for {account}: {e}")
+            return None
+
+    def get_reputation_version(self) -> Optional[str]:
+        """
+        Get the reputation tracker's version from the reputation API.
+
+        Returns:
+            str or None: Version string or None if request fails
+
+        Example:
+            >>> haf = HAF()  # doctest: +SKIP
+            >>> version = haf.get_reputation_version()  # doctest: +SKIP
+            >>> print(version)  # doctest: +SKIP
+        """
+        try:
+            endpoint = "reputation-api/version"
+            response = self._make_request(endpoint)
+
+            log.debug("Retrieved reputation tracker version")
+            return response
+
+        except requests.RequestException as e:
+            log.warning(f"Failed to retrieve reputation version: {e}")
+            return None
+        except Exception as e:
+            log.error(f"Unexpected error retrieving reputation version: {e}")
+            return None
+
+    def get_reputation_last_synced_block(self) -> Optional[int]:
+        """
+        Get the last block number synced by the reputation tracker.
+
+        Returns:
+            int or None: Last synced block number or None if request fails
+
+        Example:
+            >>> haf = HAF()  # doctest: +SKIP
+            >>> block = haf.get_reputation_last_synced_block()  # doctest: +SKIP
+            >>> print(block)  # doctest: +SKIP
+        """
+        try:
+            endpoint = "reputation-api/last-synced-block"
+            response = self._make_request(endpoint)
+
+            log.debug("Retrieved last synced block for reputation tracker")
+            return response
+
+        except requests.RequestException as e:
+            log.warning(f"Failed to retrieve last synced block: {e}")
+            return None
+        except Exception as e:
+            log.error(f"Unexpected error retrieving last synced block: {e}")
+            return None
+
+    def get_balance_version(self) -> Optional[str]:
+        """
+        Get the balance tracker's version from the balance API.
+
+        Returns:
+            str or None: Version string or None if request fails
+
+        Example:
+            >>> haf = HAF()  # doctest: +SKIP
+            >>> version = haf.get_balance_version()  # doctest: +SKIP
+            >>> print(version)  # doctest: +SKIP
+        """
+        try:
+            endpoint = "balance-api/version"
+            response = self._make_request(endpoint)
+
+            log.debug("Retrieved balance tracker version")
+            return response
+
+        except requests.RequestException as e:
+            log.warning(f"Failed to retrieve balance version: {e}")
+            return None
+        except Exception as e:
+            log.error(f"Unexpected error retrieving balance version: {e}")
+            return None
+
+    def get_balance_last_synced_block(self) -> Optional[int]:
+        """
+        Get the last block number synced by the balance tracker.
+
+        Returns:
+            int or None: Last synced block number or None if request fails
+
+        Example:
+            >>> haf = HAF()  # doctest: +SKIP
+            >>> block = haf.get_balance_last_synced_block()  # doctest: +SKIP
+            >>> print(block)  # doctest: +SKIP
+        """
+        try:
+            endpoint = "balance-api/last-synced-block"
+            response = self._make_request(endpoint)
+
+            log.debug("Retrieved last synced block for balance tracker")
+            return response
+
+        except requests.RequestException as e:
+            log.warning(f"Failed to retrieve last synced block: {e}")
+            return None
+        except Exception as e:
+            log.error(f"Unexpected error retrieving last synced block: {e}")
+            return None

nectar/hivesigner.py

@@ -374,6 +374,15 @@ class HiveSigner(object):
 
         return r.json()
 
+    def create_hot_sign_url(self, operation, params, redirect_uri=None):
+        url = urljoin(self.hs_oauth_base_url, "sign/" + operation)
+        if redirect_uri:
+            params["redirect_uri"] = redirect_uri
+        if PY2:
+            return url + "?" + urlencode(params).replace("%2C", ",")
+        else:
+            return url + "?" + urlencode(params, safe=",")
+
     def url_from_tx(self, tx, redirect_uri=None):
         """
         Generate HiveSigner hot-sign URLs for each operation in a transaction.

nectar/market.py

@@ -330,9 +330,8 @@ class Market(dict):
         :param int limit: Defines how many trades are fetched at each intervall point
         :param bool raw_data: when True, the raw data are returned
         """
-        utc = timezone.utc
         if not stop:
-            stop = utc.localize(datetime.now())
+            stop = datetime.now(timezone.utc)
         if not start:
             start = stop - timedelta(hours=1)
         start = addTzInfo(start)
@@ -370,9 +369,8 @@ class Market(dict):
         """
         # FIXME, this call should also return whether it was a buy or
         # sell
-        utc = timezone.utc
         if not stop:
-            stop = utc.localize(datetime.now())
+            stop = datetime.now(timezone.utc)
         if not start:
             start = stop - timedelta(hours=24)
         start = addTzInfo(start)

nectar/memo.py

@@ -262,7 +262,7 @@ class Memo(object):
         )
         enc = unhexlify(base58decode(enc[1:]))
         shared_secret = BtsMemo.get_shared_secret(priv, pub)
-        aes, check = BtsMemo.init_aes(shared_secret, nonce)
+        aes, check = BtsMemo.init_aes2(shared_secret, nonce)
         with open(outfile, "wb") as fout:
             fout.write(struct.pack("<Q", len(enc)))
             fout.write(enc)
@@ -449,7 +449,7 @@ class Memo(object):
         nectar_version = BtsMemo.decode_memo(priv, memo)
         shared_secret = BtsMemo.get_shared_secret(priv, pubkey)
         # Init encryption
-        aes, checksum = BtsMemo.init_aes(shared_secret, nonce)
+        aes, checksum = BtsMemo.init_aes2(shared_secret, nonce)
         with open(infile, "rb") as fin:
             memo_size = struct.unpack("<Q", fin.read(struct.calcsize("<Q")))[0]
             memo = fin.read(memo_size)

nectar/nodelist.py

@@ -130,22 +130,6 @@ class NodeList(list):
                 "hive": True,
                 "score": 40,
             },
-            {
-                "url": "https://hive-api.dlux.io",
-                "version": "1.27.8",
-                "type": "appbase",
-                "owner": "dlux",
-                "hive": True,
-                "score": 30,
-            },
-            {
-                "url": "https://api.hive.blue",
-                "version": "1.27.5",
-                "type": "appbase",
-                "owner": "hive.blue",
-                "hive": True,
-                "score": 30,
-            },
             {
                 "url": "https://hiveapi.actifit.io",
                 "version": "1.27.8",
@@ -162,14 +146,6 @@ class NodeList(list):
                 "hive": True,
                 "score": 20,
             },
-            {
-                "url": "https://hive-test-beeabode.roelandp.nl",
-                "version": "0.23.0",
-                "type": "testnet",
-                "owner": "roelandp",
-                "hive": True,
-                "score": 5,
-            },
         ]
         super(NodeList, self).__init__(nodes)
 

nectar/utils.py

@@ -318,44 +318,67 @@ def findall_patch_hunks(body=None):
 
 
 def derive_beneficiaries(beneficiaries):
-    beneficiaries_list = []
-    beneficiaries_accounts = []
-    beneficiaries_sum = 0
-    if not isinstance(beneficiaries, list):
-        beneficiaries = beneficiaries.split(",")
-
-    for w in beneficiaries:
-        account_name = w.strip().split(":")[0]
-        if account_name[0] == "@":
-            account_name = account_name[1:]
-        if account_name in beneficiaries_accounts:
+    """
+    Parse beneficiaries and return a normalized, merged list of unique accounts with weights in basis points.
+
+    Accepts a comma-separated string or list with items like "account:10", "@account:10%", or "account" (unknown
+    percentage). Duplicate accounts are merged by summing their explicit percentages and any share of the remaining
+    percentage allocated to unknown entries. Unknown entries are distributed equally across all unknown slots.
+
+    Returns a list of dicts sorted by account name: [{"account": str, "weight": int_basis_points}]
+    where weight is expressed in basis points (e.g., 1000 == 10%).
+    """
+    # Normalize input to list of entries
+    entries = beneficiaries if isinstance(beneficiaries, list) else beneficiaries.split(",")
+
+    # Collect known percentages and unknown slots per account
+    accounts = {}
+    total_known_bp = 0  # basis points (1% == 100)
+    total_unknown_slots = 0
+
+    for raw in entries:
+        token = raw.strip()
+        if not token:
             continue
-        if w.find(":") == -1:
-            percentage = -1
-        else:
-            percentage = w.strip().split(":")[1]
-            if "%" in percentage:
-                percentage = percentage.strip().split("%")[0].strip()
-            percentage = float(percentage)
-            beneficiaries_sum += percentage
-        beneficiaries_list.append({"account": account_name, "weight": int(percentage * 100)})
-        beneficiaries_accounts.append(account_name)
-
-    missing = 0
-    for bene in beneficiaries_list:
-        if bene["weight"] < 0:
-            missing += 1
-    index = 0
-    for bene in beneficiaries_list:
-        if bene["weight"] < 0:
-            beneficiaries_list[index]["weight"] = int(
-                (int(100 * 100) - int(beneficiaries_sum * 100)) / missing
-            )
-        index += 1
-    sorted_beneficiaries = sorted(
-        beneficiaries_list, key=lambda beneficiaries_list: beneficiaries_list["account"]
-    )
-    return sorted_beneficiaries
+        name_part = token.split(":")[0].strip()
+        account = name_part[1:] if name_part.startswith("@") else name_part
+        if account not in accounts:
+            accounts[account] = {"known_bp": 0, "unknown_slots": 0}
+
+        if ":" not in token:
+            # Unknown slot for this account
+            accounts[account]["unknown_slots"] += 1
+            total_unknown_slots += 1
+            continue
+
+        # Parse percentage
+        perc_str = token.split(":", 1)[1].strip()
+        if perc_str.endswith("%"):
+            perc_str = perc_str[:-1].strip()
+        try:
+            perc = float(perc_str)
+        except Exception:
+            # Treat unparsable as unknown slot
+            accounts[account]["unknown_slots"] += 1
+            total_unknown_slots += 1
+            continue
+        bp = int(perc * 100)
+        accounts[account]["known_bp"] += bp
+        total_known_bp += bp
+
+    # Distribute remaining to unknown slots equally (in bp)
+    remaining_bp = max(0, 10000 - total_known_bp)
+    if total_unknown_slots > 0 and remaining_bp > 0:
+        for account, data in accounts.items():
+            slots = data["unknown_slots"]
+            if slots > 0:
+                share_bp = int((remaining_bp * slots) / total_unknown_slots)
+                data["known_bp"] += share_bp
+
+    # Build final list (unique accounts) and sort deterministically
+    result = [{"account": acc, "weight": data["known_bp"]} for acc, data in accounts.items()]
+    result.sort(key=lambda x: x["account"])
+    return result
 
 
 def derive_tags(tags):

nectar/version.py

@@ -1,3 +1,3 @@
 """THIS FILE IS GENERATED FROM nectar PYPROJECT.TOML."""
 
-version = "0.1.1"
+version = "0.1.3"