chore: added ruff formating to root files

Signed-off-by: Manish Dait <daitmanish88@gmail.com>

Author: manishdait

examples/tokens/token_airdrop_transaction.py

@@ -499,7 +499,6 @@ def token_airdrop():
         client,
         operator_id,
         recipient_id,
-        token_id,
         nft_id,
         serial_number,
         balances_before,

examples/tokens/token_create_transaction_token_metadata.py

@@ -210,7 +210,7 @@ def create_token_with_metadata():
     try_update_metadata_without_key(client, operator_key, token_a)
 
     token_b, metadata_key = create_token_with_metadata_key(client, metadata_key, operator_id, operator_key)
-    update_metadata_with_key(client, token_b, metadata_key, operator_key)
+    update_metadata_with_key(client, token_b, metadata_key)
 
     demonstrate_metadata_length_validation(client, operator_key, operator_id)
 

examples/transaction/transfer_transaction_nft.py

@@ -175,7 +175,7 @@ def main():
     client, operator_id, operator_key = setup_client()
     account_id, new_account_private_key = create_test_account(client)
     token_id = create_nft(client, operator_id, operator_key)
-    nft_id = mint_nft(client, token_id, operator_key)
+    nft_id = mint_nft(client, token_id)
     associate_nft(client, account_id, token_id, new_account_private_key)
 
     # Transfer the NFT to the new account

generate_proto.py

@@ -21,6 +21,7 @@
   * TRACE (custom) for verbose details such as per-file rewrites and protoc args.
 Run: python generate_proto.py -vv or with trace logs: python generate_proto.py -vvv
 """
+
 import logging
 import re
 import shutil
@@ -30,26 +31,26 @@
 from pathlib import Path
 from urllib.parse import urlparse
 
-VERSION="v0.72.0-rc.2"
+VERSION = "v0.72.0-rc.2"
 SOURCES = [
     {
         "name": "hedera-protobufs",
         "url": "https://github.com/hashgraph/hedera-protobufs",
         "version": VERSION,
         "strip_count": 1,
-        "modules": ("mirror",)
+        "modules": ("mirror",),
     },
     {
         "name": "hiero-consensus-node",
         "url": "https://github.com/hiero-ledger/hiero-consensus-node",
         "version": VERSION,
-        "strip_count": 6,   
-        "modules": ("services", "platform", "fee", "sdk", "block", "streams", "blocks")
-    }
+        "strip_count": 6,
+        "modules": ("services", "platform", "fee", "sdk", "block", "streams", "blocks"),
+    },
 ]
 
-OUTPUT_DIR="src/hiero_sdk_python/hapi"
-CACHE_DIR=".protos"
+OUTPUT_DIR = "src/hiero_sdk_python/hapi"
+CACHE_DIR = ".protos"
 
 # Map common broken imports in mirror/platform proto
 REPLACEMENTS = {
@@ -70,16 +71,19 @@ class Config:
     name: str
     url: str
     version: str
-    strip_count: int 
+    strip_count: int
     modules: tuple = field(default_factory=tuple)
 
 
 def setup_logging(verbosity: int) -> None:
     level = logging.WARNING
-    if verbosity == 1: level = logging.INFO
-    elif verbosity == 2: level = logging.DEBUG
-    elif verbosity >= 3: level = logging.TRACE_LEVEL
-    
+    if verbosity == 1:
+        level = logging.INFO
+    elif verbosity == 2:
+        level = logging.DEBUG
+    elif verbosity >= 3:
+        level = logging.TRACE_LEVEL
+
     logging.basicConfig(level=level, format="%(levelname)s: %(message)s")
 
 
@@ -93,11 +97,11 @@ def download_protos(config: Config, cache_path: Path) -> None:
 
     try:
         # URL scheme and host validated above
-        with urllib.request.urlopen(url, timeout=30) as resp: # nosec B310
+        with urllib.request.urlopen(url, timeout=30) as resp:  # nosec B310
             safe_extract_tar_stream(resp, config, cache_path)
     except Exception as e:
-        raise RuntimeError(f"Download failed for {config.name}: {e}")
-    
+        raise RuntimeError(f"Download failed for {config.name}: {e}") from e
+
 
 def is_safe_tar_member(member: tarfile.TarInfo, base: Path) -> bool:
     name = member.name
@@ -111,18 +115,19 @@ def is_safe_tar_member(member: tarfile.TarInfo, base: Path) -> bool:
         dest.relative_to(base.resolve())
     except ValueError:
         return False
-    
-    return (member.isdir() or member.isreg())
+
+    return member.isdir() or member.isreg()
 
 
 def safe_extract_tar_stream(resp, config: Config, cache_path: Path):
     with tarfile.open(fileobj=resp, mode="r|gz") as tar:
         for member in tar:
             parts = Path(member.name).parts
 
-            if len(parts) <= config.strip_count: continue
-            member.name = "/".join(parts[config.strip_count:])
-            
+            if len(parts) <= config.strip_count:
+                continue
+            member.name = "/".join(parts[config.strip_count :])
+
             if not any(member.name.startswith(p) for p in config.modules):
                 continue
 
@@ -132,24 +137,23 @@ def safe_extract_tar_stream(resp, config: Config, cache_path: Path):
             if member.isdir():
                 (cache_path / member.name).mkdir(parents=True, exist_ok=True)
                 continue
-            
+
             target = cache_path / member.name
             target.parent.mkdir(parents=True, exist_ok=True)
             with tar.extractfile(member) as src, target.open("wb") as dst:
                 shutil.copyfileobj(src, dst)
 
 
-
 def patch_proto_imports(proto_root: Path):
     logging.info("Patching proto files for consistent import paths...")
 
     for proto_file in proto_root.rglob("*.proto"):
         content = proto_file.read_text(encoding="utf-8")
         new_content = content
-        
+
         for broken, fixed in REPLACEMENTS.items():
             new_content = new_content.replace(broken, fixed)
-        
+
         if "platform" in proto_file.parts:
             new_content = re.sub(r'import "event/', 'import "platform/event/', new_content)
 
@@ -160,6 +164,7 @@ def patch_proto_imports(proto_root: Path):
 def run_protoc(proto_root: Path, output_root: Path) -> None:
     import grpc_tools
     from grpc_tools import protoc
+
     google_include = str(Path(grpc_tools.__file__).parent / "_proto")
     all_protos = [p.as_posix() for p in proto_root.rglob("*.proto")]
 
@@ -184,19 +189,23 @@ def fix_imports(output_root: Path):
         if py_file.name == "__init__.py":
             continue
 
-        py_file.write_text("\n".join(
-            process_file_lines(py_file.read_text(encoding="utf-8").splitlines(), pattern, py_file.relative_to(output_root).parents)
-        ) + "\n", encoding="utf-8")
+        py_file.write_text(
+            "\n".join(
+                process_file_lines(
+                    py_file.read_text(encoding="utf-8").splitlines(), pattern, py_file.relative_to(output_root).parents
+                )
+            )
+            + "\n",
+            encoding="utf-8",
+        )
+
 
 def process_file_lines(lines, pattern, parents):
     """Process each line in a file and fix imports if needed."""
     depth = len(parents) - 1
     dots = "." * (depth + 1)
-    new_lines = []
 
-    for line in lines:
-        new_lines.append(fix_line_import(line, pattern, dots))
-    return new_lines
+    return [fix_line_import(line, pattern, dots) for line in lines]
 
 
 def fix_line_import(line, pattern, dots):
@@ -205,7 +214,7 @@ def fix_line_import(line, pattern, dots):
     if not match:
         return line
 
-    ptype, ppath, psuffix = match.group('type'), match.group('path'), match.group('suffix')
+    ptype, ppath, psuffix = match.group("type"), match.group("path"), match.group("suffix")
     full_module = ppath + psuffix
 
     if ptype == "from":
@@ -217,13 +226,13 @@ def fix_line_import(line, pattern, dots):
     if " as " in line:
         alias = line.split(" as ", 1)[1].strip()
         return (
-            f"from {dots}{module_parts[0]} import {module_parts[1]} as {alias}" 
-            if len(module_parts) > 1 
+            f"from {dots}{module_parts[0]} import {module_parts[1]} as {alias}"
+            if len(module_parts) > 1
             else f"from {dots} import {module_parts[0]} as {alias}"
         )
     return (
-        f"from {dots}{module_parts[0]} import {module_parts[1]}" 
-        if len(module_parts) > 1 
+        f"from {dots}{module_parts[0]} import {module_parts[1]}"
+        if len(module_parts) > 1
         else f"from {dots} import {module_parts[0]}"
     )
 
@@ -233,8 +242,11 @@ def main():
     cache_path = Path(CACHE_DIR)
     out_path = Path(OUTPUT_DIR)
 
-    if cache_path.exists(): shutil.rmtree(cache_path)
-    if out_path.exists(): shutil.rmtree(out_path)
+    if cache_path.exists():
+        shutil.rmtree(cache_path)
+
+    if out_path.exists():
+        shutil.rmtree(out_path)
 
     cache_path.mkdir(parents=True)
     out_path.mkdir(parents=True)
@@ -244,18 +256,19 @@ def main():
         download_protos(src, cache_path)
 
     patch_proto_imports(cache_path)
-    
+
     logging.info("Running protoc...")
     run_protoc(cache_path, out_path)
-    
+
     logging.info("Fixing imports...")
     fix_imports(out_path)
-    
+
     for d in [out_path, *out_path.rglob("*")]:
-        if d.is_dir(): (d / "__init__.py").touch()
+        if d.is_dir():
+            (d / "__init__.py").touch()
 
     print(f"✅ Successfully merged and generated HAPI at {out_path}")
 
 
 if __name__ == "__main__":
-    main()
+    main()

scripts/examples/match_examples_src.py

@@ -1,7 +1,7 @@
 import os
 from collections import defaultdict
 
-EXCLUDE_DIRS = ['hapi', '__pycache__']
+EXCLUDE_DIRS = ["hapi", "__pycache__"]
 
 
 # -----------------------------
@@ -16,7 +16,7 @@ def tokenize_filename(path):
 def longest_shared_prefix_tokens(a, b):
     """Return longest shared prefix between two token lists."""
     prefix = []
-    for x, y in zip(a, b):
+    for x, y in zip(a, b, strict=True):
         if x == y:
             prefix.append(x)
         else:
@@ -67,7 +67,6 @@ def list_files(base_path, exclude_dirs=None):
     return all_files
 
 
-
 # -----------------------------
 # Matching helpers
 # -----------------------------
@@ -81,7 +80,7 @@ def match_exact_folder(norm_ex, folder_ex, src_map, unmatched_src_set):
 
 
 def match_by_filename_only(norm_ex, src_map, unmatched_src_set):
-    for (src_folder, src_norm), src_list in src_map.items():
+    for (_, src_norm), src_list in src_map.items():
         if src_norm == norm_ex:
             for src_file in src_list:
                 unmatched_src_set.discard(src_file)

tests/fuzz/__init__.py

@@ -1 +1 @@
-# with <3 from Anto
+# with <3 from Anto

tests/fuzz/support/helpers.py

@@ -48,11 +48,7 @@ def build_valid_transaction_bytes() -> tuple[bytes, bytes]:
     node_id = AccountId.from_string("0.0.3")
     receiver_id = AccountId.from_string("0.0.5678")
 
-    tx = (
-        TransferTransaction()
-        .add_hbar_transfer(operator_id, -100_000_000)
-        .add_hbar_transfer(receiver_id, 100_000_000)
-    )
+    tx = TransferTransaction().add_hbar_transfer(operator_id, -100_000_000).add_hbar_transfer(receiver_id, 100_000_000)
     tx.transaction_id = TransactionId.generate(operator_id)
     tx.node_account_id = node_id
     tx.freeze()

tests/fuzz/support/registry.py

@@ -142,9 +142,7 @@ def _build_alias_identifier_strategies(
     )
     account_id_valid_evm = st.one_of(
         evm_hex.map(lambda value: AccountIdAliasCase(text=value, shard=0, realm=0, evm_hex=value)),
-        evm_hex.map(
-            lambda value: AccountIdAliasCase(text=f"0x{value}", shard=0, realm=0, evm_hex=value)
-        ),
+        evm_hex.map(lambda value: AccountIdAliasCase(text=f"0x{value}", shard=0, realm=0, evm_hex=value)),
         st.builds(
             lambda shard_value, realm_value, value: AccountIdAliasCase(
                 text=f"{shard_value}.{realm_value}.{value}",
@@ -243,9 +241,7 @@ def _build_invalid_identifier_strategies() -> dict[str, SearchStrategy[Any]]:
 def _build_private_key_strategies(key_samples: _KeySampleValues) -> dict[str, SearchStrategy[Any]]:
     """Build the private key strategies from the canonical valid sample encodings."""
     private_key_valid_string = st.one_of(
-        with_optional_0x(
-            st.sampled_from([key_samples.ed_private_raw, key_samples.ed_private_der])
-        ),
+        with_optional_0x(st.sampled_from([key_samples.ed_private_raw, key_samples.ed_private_der])),
     )
     private_key_valid_bytes = st.sampled_from(
         [
@@ -433,32 +429,18 @@ def _build_contract_value_strategies() -> dict[str, SearchStrategy[Any]]:
     """Build valid and invalid contract parameter cases without changing ABI edge coverage."""
     valid_contract_value = st.one_of(
         st.booleans().map(lambda value: ContractValueCase("add_bool", value)),
-        st.integers(min_value=-(2**31), max_value=2**31 - 1).map(
-            lambda value: ContractValueCase("add_int32", value)
-        ),
-        st.integers(min_value=0, max_value=2**32 - 1).map(
-            lambda value: ContractValueCase("add_uint32", value)
-        ),
-        st.integers(min_value=MIN_I64, max_value=MAX_I64).map(
-            lambda value: ContractValueCase("add_int64", value)
-        ),
-        st.integers(min_value=0, max_value=2**64 - 1).map(
-            lambda value: ContractValueCase("add_uint64", value)
-        ),
+        st.integers(min_value=-(2**31), max_value=2**31 - 1).map(lambda value: ContractValueCase("add_int32", value)),
+        st.integers(min_value=0, max_value=2**32 - 1).map(lambda value: ContractValueCase("add_uint32", value)),
+        st.integers(min_value=MIN_I64, max_value=MAX_I64).map(lambda value: ContractValueCase("add_int64", value)),
+        st.integers(min_value=0, max_value=2**64 - 1).map(lambda value: ContractValueCase("add_uint64", value)),
         st.integers(min_value=-(2**255), max_value=2**255 - 1).map(
             lambda value: ContractValueCase("add_int256", value)
         ),
-        st.integers(min_value=0, max_value=2**256 - 1).map(
-            lambda value: ContractValueCase("add_uint256", value)
-        ),
+        st.integers(min_value=0, max_value=2**256 - 1).map(lambda value: ContractValueCase("add_uint256", value)),
         st.text(min_size=0, max_size=32).map(lambda value: ContractValueCase("add_string", value)),
         st.binary(min_size=0, max_size=64).map(lambda value: ContractValueCase("add_bytes", value)),
-        st.binary(min_size=0, max_size=32).map(
-            lambda value: ContractValueCase("add_bytes32", value)
-        ),
-        st.binary(min_size=20, max_size=20).map(
-            lambda value: ContractValueCase("add_address", value)
-        ),
+        st.binary(min_size=0, max_size=32).map(lambda value: ContractValueCase("add_bytes32", value)),
+        st.binary(min_size=20, max_size=20).map(lambda value: ContractValueCase("add_address", value)),
         with_optional_0x(sized_hex(20)).map(lambda value: ContractValueCase("add_address", value)),
         st.lists(st.integers(min_value=-(2**31), max_value=2**31 - 1), min_size=0, max_size=6).map(
             lambda value: ContractValueCase("add_int32_array", value)

tests/fuzz/test_hbar_fuzz.py

@@ -56,4 +56,4 @@ def test_hbar_rejects_fractional_tinybars(amount: object) -> None:
 def test_hbar_constructor_rejects_invalid_types(value: object) -> None:
     """The constructor must not silently coerce unsupported input types."""
     with pytest.raises(TypeError):
-        Hbar(value)
+        Hbar(value)