chore: updated files to pass linting errors due to ruff update

Author: lempira

examples/payments/payments.py

@@ -1,6 +1,7 @@
+from algokit_utils import AlgorandClient
+
 from algokit_subscriber.subscriber import AlgorandSubscriber
 from algokit_subscriber.types.subscription import SubscribedTransaction
-from algokit_utils import AlgorandClient
 
 algorand = AlgorandClient.mainnet()
 
@@ -58,9 +59,7 @@ def print_payment(transaction: SubscribedTransaction, filter_name: str) -> None:
     Here we are only using this EventListener callback for one filter, but if we had multiple filters we could use the filter name to determine which filter the transaction matched.
     """
     pay = transaction["payment-transaction"]
-    print(
-        f"{filter_name}: {transaction['sender']} sent {pay['receiver']} {pay['amount'] * 1e-6} ALGO"
-    )
+    print(f"{filter_name}: {transaction['sender']} sent {pay['receiver']} {pay['amount'] * 1e-6} ALGO")
 
 
 # Attach our callback to the 'pay txns' filter

examples/usdc/usdc.py

@@ -1,6 +1,7 @@
+from algokit_utils import AlgorandClient
+
 from algokit_subscriber.subscriber import AlgorandSubscriber
 from algokit_subscriber.types.subscription import SubscribedTransaction
-from algokit_utils import AlgorandClient
 
 algorand = AlgorandClient.mainnet()
 
@@ -54,9 +55,7 @@ def print_usdc(transaction: SubscribedTransaction, filter_name: str) -> None:
     Here we are only using this EventListener callback for one filter, but if we had multiple filters we could use the filter name to determine which filter the transaction matched.
     """
     axfer = transaction["asset-transfer-transaction"]
-    print(
-        f"{filter_name}: {transaction['sender']} sent {axfer['receiver']} {axfer['amount'] * 1e-6} USDC"
-    )
+    print(f"{filter_name}: {transaction['sender']} sent {axfer['receiver']} {axfer['amount'] * 1e-6} USDC")
 
 
 subscriber.on("usdc", print_usdc)

src/algokit_subscriber/__init__.py

@@ -15,14 +15,14 @@
 __all__ = [
     "AlgorandSubscriber",
     "AlgorandSubscriberConfig",
-    "TransactionSubscriptionParams",
-    "TransactionSubscriptionResult",
-    "NamedTransactionFilter",
-    "TransactionFilter",
-    "EventListener",
     "Arc28EventGroup",
-    "SubscribedTransaction",
-    "get_subscribed_transactions",
     "BalanceChange",
     "BalanceChangeRole",
+    "EventListener",
+    "NamedTransactionFilter",
+    "SubscribedTransaction",
+    "TransactionFilter",
+    "TransactionSubscriptionParams",
+    "TransactionSubscriptionResult",
+    "get_subscribed_transactions",
 ]

src/algokit_subscriber/block.py

@@ -10,10 +10,8 @@
 
 def block_response_to_block_data(response: bytes) -> BlockData:
     return cast(
-        BlockData,
-        msgpack.unpackb(
-            response, strict_map_key=False, unicode_errors="surrogateescape"
-        ),
+        "BlockData",
+        msgpack.unpackb(response, strict_map_key=False, unicode_errors="surrogateescape"),
     )
 
 
@@ -25,9 +23,7 @@ def get_blocks_bulk(context: dict[str, int], client: AlgodClient) -> list[BlockD
     :return: The blocks
     """
     # Grab 30 at a time to not overload the node
-    block_chunks = chunk_array(
-        range_inclusive(context["start_round"], context["max_round"]), 30
-    )
+    block_chunks = chunk_array(range_inclusive(context["start_round"], context["max_round"]), 30)
     blocks = []
 
     for chunk in block_chunks:
@@ -41,12 +37,10 @@ def get_blocks_bulk(context: dict[str, int], client: AlgodClient) -> list[BlockD
                 params={"format": "msgpack"},
                 response_format="msgpack",
             )
-            decoded = block_response_to_block_data(cast(bytes, response))
+            decoded = block_response_to_block_data(cast("bytes", response))
             blocks.append(decoded)
 
         elapsed_time = time.time() - start_time
-        logger.debug(
-            f"Retrieved {len(chunk)} blocks from round {chunk[0]} via algod in {elapsed_time:.2f}s"
-        )
+        logger.debug(f"Retrieved {len(chunk)} blocks from round {chunk[0]} via algod in {elapsed_time:.2f}s")
 
     return blocks

src/algokit_subscriber/indexer_lookup.py

@@ -26,9 +26,7 @@ def transaction(transaction_id: str, indexer: IndexerClient) -> TransactionLooku
     return indexer.transaction(txid=transaction_id)  # type: ignore[no-untyped-call, no-any-return]
 
 
-def lookup_account_by_address(
-    account_address: str, indexer: IndexerClient
-) -> AccountLookupResult:
+def lookup_account_by_address(account_address: str, indexer: IndexerClient) -> AccountLookupResult:
     """
     Looks up an account by address using Indexer.
     """
@@ -64,9 +62,7 @@ def build_request(next_token: str | None = None) -> dict[str, Any]:
 
         return args
 
-    return execute_paginated_request(
-        indexer.lookup_account_application_by_creator, extract_items, build_request
-    )
+    return execute_paginated_request(indexer.lookup_account_application_by_creator, extract_items, build_request)
 
 
 def lookup_asset_holdings(
@@ -88,29 +84,17 @@ def build_request(next_token: str | None = None) -> dict[str, Any]:
         args: dict[str, Any] = {
             "asset-id": asset_id,
             "limit": pagination_limit or DEFAULT_INDEXER_MAX_API_RESOURCES_PER_ACCOUNT,
-            "include-all": (
-                options["include-all"] if options and "include-all" in options else None
-            ),
-            "currency-greater-than": (
-                options["currency-greater-than"]
-                if options and "currency-greater-than" in options
-                else None
-            ),
-            "currency-less-than": (
-                options["currency-less-than"]
-                if options and "currency-less-than" in options
-                else None
-            ),
+            "include-all": (options["include-all"] if options and "include-all" in options else None),
+            "currency-greater-than": (options["currency-greater-than"] if options and "currency-greater-than" in options else None),
+            "currency-less-than": (options["currency-less-than"] if options and "currency-less-than" in options else None),
         }
 
         if next_token:
             args["next-token"] = next_token
 
         return args
 
-    return execute_paginated_request(
-        indexer.lookup_account_assets, extract_items, build_request
-    )
+    return execute_paginated_request(indexer.lookup_account_assets, extract_items, build_request)
 
 
 def search_transactions(
@@ -127,23 +111,18 @@ def extract_items(response: TransactionSearchResults) -> list[TransactionResult]
         nonlocal current_round
         if "message" in response:
             raise Exception({"status": 404, **response})
-        if response["current-round"] > current_round:
-            current_round = response["current-round"]
+        current_round = max(current_round, response["current-round"])
         return response["transactions"]
 
     def build_request(next_token: str | None = None) -> dict[str, Any]:
         args: dict[str, Any] = search_criteria
-        args["limit"] = (
-            pagination_limit or DEFAULT_INDEXER_MAX_API_RESOURCES_PER_ACCOUNT
-        )
+        args["limit"] = pagination_limit or DEFAULT_INDEXER_MAX_API_RESOURCES_PER_ACCOUNT
         if next_token:
             args["next_page"] = next_token
 
         return args
 
-    transactions = execute_paginated_request(
-        indexer.search_transactions, extract_items, build_request
-    )
+    transactions = execute_paginated_request(indexer.search_transactions, extract_items, build_request)
 
     return {
         "current-round": current_round,

src/algokit_subscriber/subscriber.py

@@ -42,12 +42,12 @@ def __init__(
         self.filter_names = [f["name"] for f in self.config["filters"]]
 
         if config["sync_behaviour"] == "catchup-with-indexer" and not indexer_client:
-            raise ValueError(
-                "Received sync behaviour of catchup-with-indexer, but didn't receive an indexer instance."
-            )
+            raise ValueError("Received sync behaviour of catchup-with-indexer, but didn't receive an indexer instance.")
 
     def default_error_handler(
-        self, error: Any, _str: str | None = None  # noqa: ANN401
+        self,
+        error: Any,  # noqa: ANN401
+        _str: str | None = None,
     ) -> None:
         raise error
 
@@ -56,15 +56,13 @@ def poll_once(self) -> TransactionSubscriptionResult:
         Execute a single subscription poll.
         """
         watermark = self.config["watermark_persistence"]["get"]() or 0
-        current_round = cast(dict, self.algod.status())["last-round"]
+        current_round = cast("dict", self.algod.status())["last-round"]
 
-        self.event_emitter.emit(
-            "before:poll", {"watermark": watermark, "current_round": current_round}
-        )
+        self.event_emitter.emit("before:poll", {"watermark": watermark, "current_round": current_round})
 
         poll_result = get_subscribed_transactions(
             subscription=cast(
-                TransactionSubscriptionParams,
+                "TransactionSubscriptionParams",
                 {"watermark": watermark, "current_round": current_round, **self.config},
             ),
             algod=self.algod,
@@ -74,21 +72,11 @@ def poll_once(self) -> TransactionSubscriptionResult:
         try:
             for filter_name in self.filter_names:
                 mapper = next(
-                    (
-                        f.get("mapper")
-                        for f in self.config["filters"]
-                        if f["name"] == filter_name
-                    ),
+                    (f.get("mapper") for f in self.config["filters"] if f["name"] == filter_name),
                     None,
                 )
-                matched_transactions = [
-                    t
-                    for t in poll_result["subscribed_transactions"]
-                    if filter_name in (t.get("filters_matched") or [])
-                ]
-                mapped_transactions = (
-                    mapper(matched_transactions) if mapper else matched_transactions
-                )
+                matched_transactions = [t for t in poll_result["subscribed_transactions"] if filter_name in (t.get("filters_matched") or [])]
+                mapped_transactions = mapper(matched_transactions) if mapper else matched_transactions
 
                 self.event_emitter.emit(f"batch:{filter_name}", mapped_transactions)
                 for transaction in mapped_transactions:
@@ -124,16 +112,12 @@ def start(  # noqa: C901
                 duration_in_seconds = time.time() - start_time
 
                 if not suppress_log:
-                    logger.info(
-                        f"Subscription poll completed in {duration_in_seconds:.2f}s"
-                    )
+                    logger.info(f"Subscription poll completed in {duration_in_seconds:.2f}s")
                     logger.info(f"Current round: {result['current_round']}")
                     logger.info(f"Starting watermark: {result['starting_watermark']}")
                     logger.info(f"New watermark: {result['new_watermark']}")
                     logger.info(f"Synced round range: {result['synced_round_range']}")
-                    logger.info(
-                        f"Subscribed transactions: {len(result['subscribed_transactions'])}"
-                    )
+                    logger.info(f"Subscribed transactions: {len(result['subscribed_transactions'])}")
 
                 if inspect:
                     inspect(result)
@@ -142,9 +126,7 @@ def start(  # noqa: C901
                 if self.stop_requested:
                     break  # type: ignore[unreachable]
 
-                if result["current_round"] > result[
-                    "new_watermark"
-                ] or not self.config.get("wait_for_block_when_at_tip", False):
+                if result["current_round"] > result["new_watermark"] or not self.config.get("wait_for_block_when_at_tip", False):
                     sleep_time = self.config.get("frequency_in_seconds", 1)
                     if not suppress_log:
                         logger.info(f"Sleeping for {sleep_time}s")
@@ -156,9 +138,7 @@ def start(  # noqa: C901
                     wait_start = time.time()
                     self.algod.status_after_block(result["current_round"])
                     if not suppress_log:
-                        logger.info(
-                            f"Waited for {time.time() - wait_start:.2f}s until next block"
-                        )
+                        logger.info(f"Waited for {time.time() - wait_start:.2f}s until next block")
             except Exception as e:
                 self.event_emitter.emit("error", e)
         self.started = False
@@ -174,15 +154,11 @@ def on(self, filter_name: str, listener: EventListener) -> "AlgorandSubscriber":
         Register an event handler to run on every subscribed transaction matching the given filter name.
         """
         if filter_name == "error":
-            raise ValueError(
-                "'error' is reserved, please supply a different filter_name."
-            )
+            raise ValueError("'error' is reserved, please supply a different filter_name.")
         self.event_emitter.on(filter_name, listener)
         return self
 
-    def on_batch(
-        self, filter_name: str, listener: EventListener
-    ) -> "AlgorandSubscriber":
+    def on_batch(self, filter_name: str, listener: EventListener) -> "AlgorandSubscriber":
         """
         Register an event handler to run on all subscribed transactions matching the given filter name
         for each subscription poll.