hive-nectar 0.0.6__py3-none-any.whl → 0.0.9__py3-none-any.whl

nectar/conveyor.py

@@ -10,7 +10,6 @@ from datetime import datetime, timezone
 import requests
 
 from nectargraphenebase.ecdsasig import sign_message
-from nectargraphenebase.py23 import py23_bytes
 
 from .account import Account
 from .instance import shared_blockchain_instance
@@ -64,7 +63,7 @@ class Conveyor(object):
         self.id = 0
         self.ENCODING = "utf-8"
         self.TIMEFORMAT = "%Y-%m-%dT%H:%M:%S.%f"
-        self.K = hashlib.sha256(py23_bytes("steem_jsonrpc_auth", self.ENCODING)).digest()
+        self.K = hashlib.sha256(bytes("steem_jsonrpc_auth", self.ENCODING)).digest()
 
     def prehash_message(self, timestamp, account, method, params, nonce):
         """Prepare a hash for the Conveyor API request with SHA256 according
@@ -78,7 +77,7 @@ class Conveyor(object):
         :param bytes nonce: random 8 bytes
 
         """
-        first = hashlib.sha256(py23_bytes(timestamp + account + method + params, self.ENCODING))
+        first = hashlib.sha256(bytes(timestamp + account + method + params, self.ENCODING))
         return self.K + first.digest() + nonce
 
     def _request(self, account, method, params, key):
@@ -91,7 +90,7 @@ class Conveyor(object):
         :param str key: Steem posting key for signing
 
         """
-        params_bytes = py23_bytes(json.dumps(params), self.ENCODING)
+        params_bytes = bytes(json.dumps(params), self.ENCODING)
         params_enc = base64.b64encode(params_bytes).decode(self.ENCODING)
         timestamp = datetime.now(timezone.utc).strftime(self.TIMEFORMAT)[:-3] + "Z"
         nonce_int = random.getrandbits(64)

nectar/exceptions.py

@@ -1,7 +1,13 @@
 # -*- coding: utf-8 -*-
 
 
-class WalletExists(Exception):
+class NectarException(Exception):
+    """Base exception for all Nectar-related errors"""
+
+    pass
+
+
+class WalletExists(NectarException):
     """A wallet has already been created and requires a password to be
     unlocked by means of :func:`nectar.wallet.Wallet.unlock`.
     """
@@ -9,85 +15,85 @@ class WalletExists(Exception):
     pass
 
 
-class RPCConnectionRequired(Exception):
+class RPCConnectionRequired(NectarException):
     """An RPC connection is required"""
 
     pass
 
 
-class InvalidMemoKeyException(Exception):
+class InvalidMemoKeyException(NectarException):
     """Memo key in message is invalid"""
 
     pass
 
 
-class WrongMemoKey(Exception):
+class WrongMemoKey(NectarException):
     """The memo provided is not equal the one on the blockchain"""
 
     pass
 
 
-class OfflineHasNoRPCException(Exception):
+class OfflineHasNoRPCException(NectarException):
     """When in offline mode, we don't have RPC"""
 
     pass
 
 
-class AccountExistsException(Exception):
+class AccountExistsException(NectarException):
     """The requested account already exists"""
 
     pass
 
 
-class AccountDoesNotExistsException(Exception):
+class AccountDoesNotExistsException(NectarException):
     """The account does not exist"""
 
     pass
 
 
-class AssetDoesNotExistsException(Exception):
+class AssetDoesNotExistsException(NectarException):
     """The asset does not exist"""
 
     pass
 
 
-class InvalidAssetException(Exception):
+class InvalidAssetException(NectarException):
     """An invalid asset has been provided"""
 
     pass
 
 
-class InsufficientAuthorityError(Exception):
+class InsufficientAuthorityError(NectarException):
     """The transaction requires signature of a higher authority"""
 
     pass
 
 
-class VotingInvalidOnArchivedPost(Exception):
+class VotingInvalidOnArchivedPost(NectarException):
     """The transaction requires signature of a higher authority"""
 
     pass
 
 
-class MissingKeyError(Exception):
+class MissingKeyError(NectarException):
     """A required key couldn't be found in the wallet"""
 
     pass
 
 
-class InvalidWifError(Exception):
+class InvalidWifError(NectarException):
     """The provided private Key has an invalid format"""
 
     pass
 
 
-class BlockDoesNotExistsException(Exception):
+class BlockDoesNotExistsException(NectarException):
     """The block does not exist"""
 
     pass
 
 
-class NoWalletException(Exception):
+class NoWalletException(NectarException):
     """No Wallet could be found, please use :func:`nectar.wallet.Wallet.create` to
     create a new wallet
     """
@@ -95,55 +101,55 @@ class NoWalletException(Exception):
     pass
 
 
-class WitnessDoesNotExistsException(Exception):
+class WitnessDoesNotExistsException(NectarException):
     """The witness does not exist"""
 
     pass
 
 
-class ContentDoesNotExistsException(Exception):
+class ContentDoesNotExistsException(NectarException):
     """The content does not exist"""
 
     pass
 
 
-class VoteDoesNotExistsException(Exception):
+class VoteDoesNotExistsException(NectarException):
     """The vote does not exist"""
 
     pass
 
 
-class WrongMasterPasswordException(Exception):
+class WrongMasterPasswordException(NectarException):
     """The password provided could not properly unlock the wallet"""
 
     pass
 
 
-class VestingBalanceDoesNotExistsException(Exception):
+class VestingBalanceDoesNotExistsException(NectarException):
     """Vesting Balance does not exist"""
 
     pass
 
 
-class InvalidMessageSignature(Exception):
+class InvalidMessageSignature(NectarException):
     """The message signature does not fit the message"""
 
     pass
 
 
-class NoWriteAccess(Exception):
+class NoWriteAccess(NectarException):
     """Cannot store to sqlite3 database due to missing write access"""
 
     pass
 
 
-class BatchedCallsNotSupported(Exception):
+class BatchedCallsNotSupported(NectarException):
     """Batch calls do not work"""
 
     pass
 
 
-class BlockWaitTimeExceeded(Exception):
+class BlockWaitTimeExceeded(NectarException):
     """Wait time for new block exceeded"""
 
     pass

nectar/hive.py

@@ -6,7 +6,6 @@ from datetime import date, datetime, timezone
 from nectar.blockchaininstance import BlockChainInstance
 from nectar.constants import STEEM_100_PERCENT
 from nectargraphenebase.chains import known_chains
-from nectargraphenebase.py23 import string_types
 
 from .amount import Amount
 from .utils import formatToTimeStamp
@@ -124,7 +123,7 @@ class Hive(BlockChainInstance):
             return known_chains["HIVE"]
         try:
             return self.rpc.get_network(props=config)
-        except:
+        except Exception:
             return known_chains["HIVE"]
 
     def rshares_to_token_backed_dollar(
@@ -362,7 +361,7 @@ class Hive(BlockChainInstance):
         """
         if isinstance(hbd, Amount):
             hbd = Amount(hbd, blockchain_instance=self)
-        elif isinstance(hbd, string_types):
+        elif isinstance(hbd, str):
             hbd = Amount(hbd, blockchain_instance=self)
         else:
             hbd = Amount(hbd, self.hbd_symbol, blockchain_instance=self)
@@ -486,7 +485,7 @@ class Hive(BlockChainInstance):
         """
         if isinstance(hbd, Amount):
             hbd = Amount(hbd, blockchain_instance=self)
-        elif isinstance(hbd, string_types):
+        elif isinstance(hbd, str):
             hbd = Amount(hbd, blockchain_instance=self)
         else:
             hbd = Amount(hbd, self.hbd_symbol, blockchain_instance=self)

nectar/hivesigner.py

@@ -33,7 +33,7 @@ class HiveSigner(object):
         from nectar import Steem
         from nectar.HiveSigner import HiveSigner
         from nectar.comment import Comment
-        hs = HiveSigner(client_id="nectar.app")
+        hs = HiveSigner(client_id="nectarflower")
         steem = Steem(HiveSigner=hs)
         steem.wallet.unlock("supersecret-passphrase")
         post = Comment("author/permlink", blockchain_instance=steem)
@@ -377,7 +377,7 @@ class HiveSigner(object):
                     try:
                         amount = Amount(value, blockchain_instance=self.blockchain)
                         params[key] = str(amount)
-                    except:
+                    except Exception:
                         amount = None
                 elif isinstance(value, bool):
                     if value:

nectar/imageuploader.py

@@ -6,7 +6,6 @@ import requests
 
 from nectar.account import Account
 from nectargraphenebase.ecdsasig import sign_message
-from nectargraphenebase.py23 import py23_bytes, string_types
 
 from .instance import shared_blockchain_instance
 
@@ -55,14 +54,14 @@ class ImageUploader(object):
         for authority in account["posting"]["key_auths"]:
             posting_wif = self.steem.wallet.getPrivateKeyForPublicKey(authority[0])
 
-        if isinstance(image, string_types):
+        if isinstance(image, str):
             image_data = open(image, "rb").read()
         elif isinstance(image, io.BytesIO):
             image_data = image.read()
         else:
             image_data = image
 
-        message = py23_bytes(self.challenge, "ascii") + image_data
+        message = bytes(self.challenge, "ascii") + image_data
         signature = sign_message(message, posting_wif)
         signature_in_hex = hexlify(signature).decode("ascii")
 

nectar/nodelist.py

@@ -243,7 +243,12 @@ class NodeList(list):
             cnt += 1
             try:
                 account = Account("nectarflower", blockchain_instance=steem)
-                metadata = json.loads(account["posting_json_metadata"])
+                # Metadata is stored in the account's json_metadata field (not posting_json_metadata)
+                raw_meta = account.get("json_metadata") or ""
+                try:
+                    metadata = json.loads(raw_meta) if raw_meta else None
+                except Exception:
+                    metadata = None
             except Exception as e:
                 log.warning(f"Error fetching metadata (attempt {cnt}): {str(e)}")
                 steem.rpc.next()
@@ -257,10 +262,30 @@ class NodeList(list):
         report = metadata.get("report", [])
         failing_nodes = metadata.get("failing_nodes", {})
         parameter = metadata.get("parameter", {})
-        benchmarks = parameter.get("benchmarks", {})
-
-        # Convert benchmarks dict to list of benchmark names
-        benchmark_names = list(benchmarks.keys())
+        benchmarks = parameter.get("benchmarks")
+
+        # Determine benchmark names. If not explicitly provided in metadata parameters, derive them
+        # by inspecting the keys of the report entries and filtering out the non-benchmark fields.
+        if benchmarks and isinstance(benchmarks, dict):
+            benchmark_names: list[str] = list(benchmarks.keys())
+        else:
+            benchmark_names = []
+            # Common non-benchmark keys present in every report entry
+            _skip_keys = {
+                "node",
+                "version",
+                "hive",
+                "weighted_score",
+                "tests_completed",
+            }
+            # Collect benchmark names dynamically from the report section
+            for _entry in report:
+                if isinstance(_entry, dict):
+                    for _k in _entry.keys():
+                        if _k not in _skip_keys and _k not in benchmark_names:
+                            benchmark_names.append(_k)
+            # Sort for deterministic ordering
+            benchmark_names.sort()
 
         if weights is None:
             weights_dict = {}
@@ -294,6 +319,7 @@ class NodeList(list):
 
         for node in self:
             new_node = node.copy()
+            node_was_updated = False
 
             # Check against report data
             for report_node in report:
@@ -319,17 +345,67 @@ class NodeList(list):
                             weighted_score = score * weights_dict.get(benchmark, 0)
                             scores.append(weighted_score)
 
-                    sum_score = sum(scores)
-                    new_node["score"] = sum_score
+                    # Prefer the pre-computed weighted_score from the metadata if present; fall back to
+                    # the locally calculated score otherwise.
+                    if "weighted_score" in report_node and isinstance(report_node["weighted_score"], (int, float)):
+                        new_node["score"] = report_node["weighted_score"]
+                    else:
+                        sum_score = sum(scores)
+                        new_node["score"] = sum_score
+                    node_was_updated = True
                     break
 
             # Check if node is in failing nodes list
             if node["url"] in failing_nodes:
                 failing_count += 1
                 new_node["score"] = -1
+            elif not node_was_updated:
+                # If node wasn't part of the metadata report, reset its score so it
+                # doesn't overshadow the authoritative ordering
+                new_node["score"] = 0
 
             new_nodes.append(new_node)
 
+        # ------------------------------------------------------------
+        # Ensure that all nodes present in the metadata are included
+        # in the final list, even if they were not part of the default
+        # hard-coded set.
+        # ------------------------------------------------------------
+        existing_urls: set[str] = {n["url"] for n in new_nodes}
+
+        # Add nodes found in the report section
+        for report_node in report:
+            url = report_node.get("node")
+            if not url or url in existing_urls:
+                continue
+            new_entry = {
+                "url": url,
+                "version": report_node.get("version", "0.0.0"),
+                "type": "appbase",
+                "owner": report_node.get("owner", "unknown"),
+                "hive": report_node.get("hive", True),
+                "score": report_node.get("weighted_score", 0),
+            }
+            new_nodes.append(new_entry)
+            existing_urls.add(url)
+
+        # Add nodes listed as failing but missing
+        for url in failing_nodes.keys():
+            if url in existing_urls:
+                continue
+            new_nodes.append(
+                {
+                    "url": url,
+                    "version": "unknown",
+                    "type": "appbase",
+                    "owner": "unknown",
+                    "hive": True,
+                    "score": -1,
+                }
+            )
+            existing_urls.add(url)
+
+        # Re-initialise internal list
         super(NodeList, self).__init__(new_nodes)
 
     def get_nodes(

nectar/price.py

@@ -3,7 +3,6 @@ from decimal import Decimal
 from fractions import Fraction
 
 from nectar.instance import shared_blockchain_instance
-from nectargraphenebase.py23 import integer_types, string_types
 
 from .amount import Amount
 from .asset import Asset
@@ -97,7 +96,7 @@ class Price(dict):
         self.blockchain = blockchain_instance or shared_blockchain_instance()
         if price == "":
             price = None
-        if price is not None and isinstance(price, string_types) and not base and not quote:
+        if price is not None and isinstance(price, str) and not base and not quote:
             price, assets = price.split(" ")
             base_symbol, quote_symbol = assets_from_string(assets)
             base = Asset(base_symbol, blockchain_instance=self.blockchain)
@@ -131,9 +130,7 @@ class Price(dict):
                 amount=frac.numerator, asset=base, blockchain_instance=self.blockchain
             )
 
-        elif (
-            price is not None and isinstance(base, string_types) and isinstance(quote, string_types)
-        ):
+        elif price is not None and isinstance(base, str) and isinstance(quote, str):
             base = Asset(base, blockchain_instance=self.blockchain)
             quote = Asset(quote, blockchain_instance=self.blockchain)
             frac = Fraction(float(price)).limit_denominator(10 ** base["precision"])
@@ -144,12 +141,10 @@ class Price(dict):
                 amount=frac.numerator, asset=base, blockchain_instance=self.blockchain
             )
 
-        elif price is None and isinstance(base, string_types) and isinstance(quote, string_types):
+        elif price is None and isinstance(base, str) and isinstance(quote, str):
             self["quote"] = Amount(quote, blockchain_instance=self.blockchain)
             self["base"] = Amount(base, blockchain_instance=self.blockchain)
-        elif (
-            price is not None and isinstance(price, string_types) and isinstance(base, string_types)
-        ):
+        elif price is not None and isinstance(price, str) and isinstance(base, str):
             self["quote"] = Amount(price, blockchain_instance=self.blockchain)
             self["base"] = Amount(base, blockchain_instance=self.blockchain)
         # len(args) > 1
@@ -163,10 +158,8 @@ class Price(dict):
             self["base"] = base
 
         elif (
-            isinstance(price, float)
-            or isinstance(price, integer_types)
-            or isinstance(price, Decimal)
-        ) and isinstance(base, string_types):
+            isinstance(price, float) or isinstance(price, int) or isinstance(price, Decimal)
+        ) and isinstance(base, str):
             base_symbol, quote_symbol = assets_from_string(base)
             base = Asset(base_symbol, blockchain_instance=self.blockchain)
             quote = Asset(quote_symbol, blockchain_instance=self.blockchain)

nectar/rc.py

@@ -9,7 +9,6 @@ from nectar.constants import (
 from nectarbase import operations
 from nectarbase.objects import Operation
 from nectarbase.signedtransactions import Signed_Transaction
-from nectargraphenebase.py23 import py23_bytes
 
 from .instance import shared_blockchain_instance
 
@@ -38,7 +37,7 @@ class RC(object):
             operations=ops,
         )
         tx = tx.sign([wif], chain=prefix)
-        txWire = hexlify(py23_bytes(tx)).decode("ascii")
+        txWire = hexlify(bytes(tx)).decode("ascii")
         tx_size = len(txWire)
         return tx_size
 

nectar/steem.py

@@ -6,7 +6,6 @@ from datetime import date, datetime, timezone
 from nectar.blockchaininstance import BlockChainInstance
 from nectar.constants import STEEM_100_PERCENT, STEEM_VOTE_REGENERATION_SECONDS
 from nectargraphenebase.chains import known_chains
-from nectargraphenebase.py23 import string_types
 
 from .amount import Amount
 from .utils import formatToTimeStamp
@@ -124,7 +123,7 @@ class Steem(BlockChainInstance):
             return known_chains["STEEM"]
         try:
             return self.rpc.get_network(props=config)
-        except:
+        except Exception:
             return known_chains["STEEM"]
 
     def rshares_to_token_backed_dollar(
@@ -393,7 +392,7 @@ class Steem(BlockChainInstance):
         """
         if isinstance(sbd, Amount):
             sbd = Amount(sbd, blockchain_instance=self)
-        elif isinstance(sbd, string_types):
+        elif isinstance(sbd, str):
             sbd = Amount(sbd, blockchain_instance=self)
         else:
             sbd = Amount(sbd, self.sbd_symbol, blockchain_instance=self)
@@ -517,7 +516,7 @@ class Steem(BlockChainInstance):
         """
         if isinstance(sbd, Amount):
             sbd = Amount(sbd, blockchain_instance=self)
-        elif isinstance(sbd, string_types):
+        elif isinstance(sbd, str):
             sbd = Amount(sbd, blockchain_instance=self)
         else:
             sbd = Amount(sbd, self.sbd_symbol, blockchain_instance=self)

nectar/storage.py

@@ -1,15 +1,14 @@
 # -*- coding: utf-8 -*-
 import logging
 
+from nectarstorage import SqliteConfigurationStore, SqliteEncryptedKeyStore
+
 from .nodelist import NodeList
 
 log = logging.getLogger(__name__)
 log.setLevel(logging.DEBUG)
 log.addHandler(logging.StreamHandler())
-from nectarstorage import (
-    SqliteConfigurationStore,
-    SqliteEncryptedKeyStore,
-)
+
 
 timeformat = "%Y%m%d-%H%M%S"
 

nectar/transactionbuilder.py

@@ -279,7 +279,7 @@ class TransactionBuilder(dict):
             try:
                 PrivateKey(wif, prefix=self.blockchain.prefix)
                 self.wifs.add(wif)
-            except:
+            except Exception:
                 raise InvalidWifError
 
     def clearWifs(self):
@@ -427,7 +427,7 @@ class TransactionBuilder(dict):
             # try:
             #    ledgertx = Ledger_Transaction(**self.json(with_prefix=True))
             #    ledgertx.add_custom_chains(self.blockchain.custom_chains)
-            # except:
+            # except Exception:
             #    raise ValueError("Invalid TransactionBuilder Format")
             # ledgertx.sign(self.path, chain=self.blockchain.chain_params)
             self.ledgertx.sign(self.path, chain=self.blockchain.chain_params)
@@ -438,7 +438,16 @@ class TransactionBuilder(dict):
                 raise MissingKeyError
 
             self.tx.sign(self.wifs, chain=self.blockchain.chain_params)
-            self["signatures"].extend(self.tx.json().get("signatures"))
+            # Defensive: ensure self["signatures"] is a list before extend
+            if isinstance(self["signatures"], str):
+                log.warning(
+                    "self['signatures'] was a string, converting to list to avoid AttributeError."
+                )
+                self["signatures"] = [self["signatures"]]
+            sigs = self.tx.json().get("signatures")
+            if isinstance(sigs, str):
+                sigs = [sigs]
+            self["signatures"].extend(sigs)
             return self.tx
 
     def verify_authority(self):

nectar/version.py

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

nectar/vote.py

@@ -5,7 +5,6 @@ from datetime import date, datetime, timezone
 from prettytable import PrettyTable
 
 from nectarapi.exceptions import InvalidParameters, UnknownKey
-from nectargraphenebase.py23 import integer_types, string_types
 
 from .account import Account
 from .blockchainobject import BlockchainObject
@@ -42,7 +41,7 @@ class Vote(BlockchainObject):
             elif kwargs.get("hive_instance"):
                 blockchain_instance = kwargs["hive_instance"]
         self.blockchain = blockchain_instance or shared_blockchain_instance()
-        if isinstance(voter, string_types) and authorperm is not None:
+        if isinstance(voter, str) and authorperm is not None:
             [author, permlink] = resolve_authorperm(authorperm)
             self["voter"] = voter
             self["author"] = author
@@ -138,20 +137,20 @@ class Vote(BlockchainObject):
             "reputation",
         ]
         for p in parse_int:
-            if p in vote and isinstance(vote.get(p), string_types):
+            if p in vote and isinstance(vote.get(p), str):
                 vote[p] = int(vote.get(p, "0"))
 
-        if "time" in vote and isinstance(vote.get("time"), string_types) and vote.get("time") != "":
+        if "time" in vote and isinstance(vote.get("time"), str) and vote.get("time") != "":
             vote["time"] = formatTimeString(vote.get("time", "1970-01-01T00:00:00"))
         elif (
             "timestamp" in vote
-            and isinstance(vote.get("timestamp"), string_types)
+            and isinstance(vote.get("timestamp"), str)
             and vote.get("timestamp") != ""
         ):
             vote["time"] = formatTimeString(vote.get("timestamp", "1970-01-01T00:00:00"))
         elif (
             "last_update" in vote
-            and isinstance(vote.get("last_update"), string_types)
+            and isinstance(vote.get("last_update"), str)
             and vote.get("last_update") != ""
         ):
             vote["last_update"] = formatTimeString(vote.get("last_update", "1970-01-01T00:00:00"))
@@ -178,7 +177,7 @@ class Vote(BlockchainObject):
             "reputation",
         ]
         for p in parse_int:
-            if p in output and isinstance(output[p], integer_types):
+            if p in output and isinstance(output[p], int):
                 output[p] = str(output[p])
         return json.loads(str(json.dumps(output)))
 
@@ -456,7 +455,7 @@ class ActiveVotes(VotesObject):
                     authorperm["author"], authorperm["permlink"], api="condenser"
                 )
             authorperm = authorperm["authorperm"]
-        elif isinstance(authorperm, string_types):
+        elif isinstance(authorperm, str):
             [author, permlink] = resolve_authorperm(authorperm)
             if self.blockchain.rpc.get_use_appbase():
                 self.blockchain.rpc.set_next_node_on_empty_reply(False)
@@ -534,7 +533,7 @@ class AccountVotes(VotesObject):
                 time = x.get("last_update", "")
                 if time != "":
                     x["time"] = time
-            if time != "" and isinstance(time, string_types):
+            if time != "" and isinstance(time, str):
                 d_time = formatTimeString(time)
             elif isinstance(time, datetime):
                 d_time = time

nectar/wallet.py

@@ -409,7 +409,7 @@ class Wallet(object):
         else:
             try:
                 account = Account(name, blockchain_instance=self.blockchain)
-            except:
+            except Exception:
                 return
             return {
                 "name": account["name"],