ruff formatting

Author: ape364

aioetherscan/__init__.py

@@ -1 +1 @@
-from aioetherscan.client import Client
+from aioetherscan.client import Client  # noqa: F401

aioetherscan/client.py

@@ -19,9 +19,17 @@
 
 
 class Client:
-    def __init__(self, api_key: str, api_kind: str = 'eth', network: str = 'main',
-                 loop: AbstractEventLoop = None, timeout: ClientTimeout = None, proxy: str = None,
-                 throttler: AsyncContextManager = None, retry_options: RetryOptionsBase = None) -> None:
+    def __init__(
+        self,
+        api_key: str,
+        api_kind: str = 'eth',
+        network: str = 'main',
+        loop: AbstractEventLoop = None,
+        timeout: ClientTimeout = None,
+        proxy: str = None,
+        throttler: AsyncContextManager = None,
+        retry_options: RetryOptionsBase = None,
+    ) -> None:
         self._url_builder = UrlBuilder(api_key, api_kind, network)
         self._http = Network(self._url_builder, loop, timeout, proxy, throttler, retry_options)
 

aioetherscan/common.py

@@ -23,7 +23,7 @@ def check_tag(tag: Union[str, int]) -> str:
     _TAGS = (
         'earliest',  # the earliest/genesis block
         'latest',  # the latest mined block
-        'pending'  # for the pending state/transactions
+        'pending',  # for the pending state/transactions
     )
 
     if tag in _TAGS:
@@ -34,23 +34,23 @@ def check_tag(tag: Union[str, int]) -> str:
 def check_sort_direction(sort: str) -> str:
     _SORT_ORDERS = (
         'asc',  # ascending order
-        'desc'  # descending order
+        'desc',  # descending order
     )
     return check_value(sort, _SORT_ORDERS)
 
 
 def check_blocktype(blocktype: str) -> str:
     _BLOCK_TYPES = (
         'blocks',  # full blocks only
-        'uncles'  # uncle blocks only
+        'uncles',  # uncle blocks only
     )
     return check_value(blocktype, _BLOCK_TYPES)
 
 
 def check_closest_value(closest_value: str) -> str:
     _CLOSEST_VALUES = (
         'before',  # ascending order
-        'after'  # descending order
+        'after',  # descending order
     )
 
     return check_value(closest_value, _CLOSEST_VALUES)
@@ -90,5 +90,5 @@ def get_daily_stats_params(action: str, start_date: date, end_date: date, sort:
         action=action,
         startdate=start_date.isoformat(),
         enddate=end_date.isoformat(),
-        sort=check_sort_direction(sort)
+        sort=check_sort_direction(sort),
     )

aioetherscan/modules/account.py

@@ -1,6 +1,11 @@
 from typing import Iterable, Optional, List, Dict
 
-from aioetherscan.common import check_tag, check_sort_direction, check_blocktype, check_token_standard
+from aioetherscan.common import (
+    check_tag,
+    check_sort_direction,
+    check_blocktype,
+    check_token_standard,
+)
 from aioetherscan.modules.base import BaseModule
 
 
@@ -16,28 +21,22 @@ def _module(self) -> str:
 
     async def balance(self, address: str, tag: str = 'latest') -> str:
         """Get Ether Balance for a single Address."""
-        return await self._get(
-            action='balance',
-            address=address,
-            tag=check_tag(tag)
-        )
+        return await self._get(action='balance', address=address, tag=check_tag(tag))
 
     async def balances(self, addresses: Iterable[str], tag: str = 'latest') -> List[Dict]:
         """Get Ether Balance for multiple Addresses in a single call."""
         return await self._get(
-            action='balancemulti',
-            address=','.join(addresses),
-            tag=check_tag(tag)
+            action='balancemulti', address=','.join(addresses), tag=check_tag(tag)
         )
 
     async def normal_txs(
-            self,
-            address: str,
-            start_block: Optional[int] = None,
-            end_block: Optional[int] = None,
-            sort: Optional[str] = None,
-            page: Optional[int] = None,
-            offset: Optional[int] = None
+        self,
+        address: str,
+        start_block: Optional[int] = None,
+        end_block: Optional[int] = None,
+        sort: Optional[str] = None,
+        page: Optional[int] = None,
+        offset: Optional[int] = None,
     ) -> List[Dict]:
         """Get a list of 'Normal' Transactions By Address."""
         return await self._get(
@@ -47,18 +46,18 @@ async def normal_txs(
             endblock=end_block,
             sort=check_sort_direction(sort),
             page=page,
-            offset=offset
+            offset=offset,
         )
 
     async def internal_txs(
-            self,
-            address: str,
-            start_block: Optional[int] = None,
-            end_block: Optional[int] = None,
-            sort: Optional[str] = None,
-            page: Optional[int] = None,
-            offset: Optional[int] = None,
-            txhash: Optional[str] = None
+        self,
+        address: str,
+        start_block: Optional[int] = None,
+        end_block: Optional[int] = None,
+        sort: Optional[str] = None,
+        page: Optional[int] = None,
+        offset: Optional[int] = None,
+        txhash: Optional[str] = None,
     ) -> List[Dict]:
         """Get a list of 'Internal' Transactions by Address or Transaction Hash."""
         return await self._get(
@@ -69,30 +68,26 @@ async def internal_txs(
             sort=check_sort_direction(sort),
             page=page,
             offset=offset,
-            txhash=txhash
+            txhash=txhash,
         )
 
     async def token_transfers(
-            self,
-            address: Optional[str] = None,
-            contract_address: Optional[str] = None,
-            start_block: Optional[int] = None,
-            end_block: Optional[int] = None,
-            sort: Optional[str] = None,
-            page: Optional[int] = None,
-            offset: Optional[int] = None,
-            token_standard: str = 'erc20'
+        self,
+        address: Optional[str] = None,
+        contract_address: Optional[str] = None,
+        start_block: Optional[int] = None,
+        end_block: Optional[int] = None,
+        sort: Optional[str] = None,
+        page: Optional[int] = None,
+        offset: Optional[int] = None,
+        token_standard: str = 'erc20',
     ) -> List[Dict]:
         """Get a list of "ERC20 - Token Transfer Events" by Address"""
         if not address and not contract_address:
             raise ValueError('At least one of address or contract_address must be specified.')
 
         token_standard = check_token_standard(token_standard)
-        actions = dict(
-            erc20='tokentx',
-            erc721='tokennfttx',
-            erc1155='token1155tx'
-        )
+        actions = dict(erc20='tokentx', erc721='tokennfttx', erc1155='token1155tx')
 
         return await self._get(
             action=actions.get(token_standard),
@@ -102,36 +97,35 @@ async def token_transfers(
             sort=check_sort_direction(sort),
             page=page,
             offset=offset,
-            contractaddress=contract_address
+            contractaddress=contract_address,
         )
 
     async def mined_blocks(
-            self,
-            address: str,
-            blocktype: str = 'blocks',
-            page: Optional[int] = None,
-            offset: Optional[int] = None
+        self,
+        address: str,
+        blocktype: str = 'blocks',
+        page: Optional[int] = None,
+        offset: Optional[int] = None,
     ) -> List:
         """Get list of Blocks Validated by Address"""
         return await self._get(
             action='getminedblocks',
             address=address,
             blocktype=check_blocktype(blocktype),
             page=page,
-            offset=offset
+            offset=offset,
         )
 
     async def beacon_chain_withdrawals(
-            self,
-            address: str,
-            start_block: Optional[int] = None,
-            end_block: Optional[int] = None,
-            sort: Optional[str] = None,
-            page: Optional[int] = None,
-            offset: Optional[int] = None,
+        self,
+        address: str,
+        start_block: Optional[int] = None,
+        end_block: Optional[int] = None,
+        sort: Optional[str] = None,
+        page: Optional[int] = None,
+        offset: Optional[int] = None,
     ) -> List[Dict]:
         """Get Beacon Chain Withdrawals by Address and Block Range"""
-        # todo: refactor
         return await self._get(
             action='txsBeaconWithdrawal',
             address=address,
@@ -145,8 +139,5 @@ async def beacon_chain_withdrawals(
     async def account_balance_by_blockno(self, address: str, blockno: int) -> str:
         """Get Historical Ether Balance for a Single Address By BlockNo"""
         return await self._get(
-            module='account',
-            action='balancehistory',
-            address=address,
-            blockno=blockno
+            module='account', action='balancehistory', address=address, blockno=blockno
         )

aioetherscan/modules/block.py

@@ -17,43 +17,54 @@ def _module(self) -> str:
 
     async def block_reward(self, blockno: int) -> Dict:
         """Get Block And Uncle Rewards by BlockNo"""
-        return await self._get(
-            action='getblockreward',
-            blockno=blockno
-        )
+        return await self._get(action='getblockreward', blockno=blockno)
 
     async def est_block_countdown_time(self, blockno: int) -> Dict:
         """Get Estimated Block Countdown Time by BlockNo"""
-        return await self._get(
-            action='getblockcountdown',
-            blockno=blockno
-        )
+        return await self._get(action='getblockcountdown', blockno=blockno)
 
     async def block_number_by_ts(self, ts: int, closest: str) -> Dict:
         """Get Block Number by Timestamp"""
         return await self._get(
-            action='getblocknobytime',
-            timestamp=ts,
-            closest=check_closest_value(closest)
+            action='getblocknobytime', timestamp=ts, closest=check_closest_value(closest)
         )
 
-    async def daily_average_block_size(self, start_date: date, end_date: date, sort: Optional[str] = None) -> Dict:
+    async def daily_average_block_size(
+        self, start_date: date, end_date: date, sort: Optional[str] = None
+    ) -> Dict:
         """Get Daily Average Block Size"""
-        return await self._get(**get_daily_stats_params('dailyavgblocksize', start_date, end_date, sort))
+        return await self._get(
+            **get_daily_stats_params('dailyavgblocksize', start_date, end_date, sort)
+        )
 
-    async def daily_block_count(self, start_date: date, end_date: date, sort: Optional[str] = None) -> Dict:
+    async def daily_block_count(
+        self, start_date: date, end_date: date, sort: Optional[str] = None
+    ) -> Dict:
         """Get Daily Block Count and Rewards"""
-        return await self._get(**get_daily_stats_params('dailyblkcount', start_date, end_date, sort))
+        return await self._get(
+            **get_daily_stats_params('dailyblkcount', start_date, end_date, sort)
+        )
 
-    async def daily_block_rewards(self, start_date: date, end_date: date, sort: Optional[str] = None) -> Dict:
+    async def daily_block_rewards(
+        self, start_date: date, end_date: date, sort: Optional[str] = None
+    ) -> Dict:
         """Get Daily Block Rewards"""
-        return await self._get(**get_daily_stats_params('dailyblockrewards', start_date, end_date, sort))
+        return await self._get(
+            **get_daily_stats_params('dailyblockrewards', start_date, end_date, sort)
+        )
 
-    async def daily_average_time_for_a_block(self, start_date: date, end_date: date,
-                                             sort: Optional[str] = None) -> Dict:
+    async def daily_average_time_for_a_block(
+        self, start_date: date, end_date: date, sort: Optional[str] = None
+    ) -> Dict:
         """Get Daily Average Time for A Block to be Included in the Ethereum Blockchain"""
-        return await self._get(**get_daily_stats_params('dailyavgblocktime', start_date, end_date, sort))
+        return await self._get(
+            **get_daily_stats_params('dailyavgblocktime', start_date, end_date, sort)
+        )
 
-    async def daily_uncle_block_count(self, start_date: date, end_date: date, sort: Optional[str] = None) -> Dict:
+    async def daily_uncle_block_count(
+        self, start_date: date, end_date: date, sort: Optional[str] = None
+    ) -> Dict:
         """Get Daily Uncle Block Count and Rewards"""
-        return await self._get(**get_daily_stats_params('dailyuncleblkcount', start_date, end_date, sort))
+        return await self._get(
+            **get_daily_stats_params('dailyuncleblkcount', start_date, end_date, sort)
+        )