eth-portfolio-temp 0.0.38.dev0__cp311-cp311-win_amd64.whl → 0.3.0__cp311-cp311-win_amd64.whl

eth_portfolio/protocols/lending/maker.py

@@ -1,10 +1,12 @@
 from asyncio import gather
-from typing import List, Optional
+from typing import Final, List, Optional
 
 from a_sync import igather
-from async_lru import alru_cache
+from brownie import ZERO_ADDRESS
 from dank_mids.exceptions import Revert
 from eth_typing import HexStr
+from faster_async_lru import alru_cache
+from faster_eth_abi import encode
 from y import Contract, Network, contract_creation_block_async, get_price
 from y._decorators import stuck_coro_debugger
 from y.constants import dai
@@ -14,18 +16,15 @@ from eth_portfolio._utils import Decimal
 from eth_portfolio.protocols.lending._base import LendingProtocolWithLockedCollateral
 from eth_portfolio.typing import Balance, TokenBalances
 
-try:
-    # this is only available in 4.0.0+
-    from eth_abi import encode
 
-    encode_bytes = lambda bytestring: encode(["bytes32"], [bytestring])
-except ImportError:
-    from eth_abi import encode_single
+yfi: Final = "0x0bc529c00C6401aEF6D220BE8C6Ea1667F6Ad93e"
+dai: Contract
+_1e18: Final = Decimal(10**18)
+_1e45: Final = Decimal(10**45)
 
-    encode_bytes = lambda bytestring: encode_single("bytes32", bytestring)
 
-yfi = "0x0bc529c00C6401aEF6D220BE8C6Ea1667F6Ad93e"
-dai: Contract
+def encode_bytes(bytestring: str) -> bytes:
+    return encode(["bytes32"], [bytestring])
 
 
 class Maker(LendingProtocolWithLockedCollateral):
@@ -50,8 +49,8 @@ class Maker(LendingProtocolWithLockedCollateral):
 
         balances: TokenBalances = TokenBalances(block=block)
         for token, data in zip(gems, ink_data):
-            if ink := data.dict()["ink"]:
-                balance = ink / Decimal(10**18)
+            if token != ZERO_ADDRESS and (ink := data.dict()["ink"]):
+                balance = ink / _1e18
                 value = round(balance * Decimal(await get_price(token, block, sync=False)), 18)
                 balances[token] = Balance(balance, value, token=token, block=block)
         return balances
@@ -75,7 +74,7 @@ class Maker(LendingProtocolWithLockedCollateral):
         for urns, ilk_info in data:
             art = urns.dict()["art"]
             rate = ilk_info.dict()["rate"]
-            debt = art * rate / Decimal(1e45)
+            debt = art * rate / _1e45
             balances[dai.address] += Balance(debt, debt, token=dai, block=block)
         return balances
 

eth_portfolio/structs/structs.py

@@ -80,7 +80,7 @@ class _LedgerEntryBase(DictStruct, kw_only=True, frozen=True, omit_defaults=True
     The USD value of the cryptocurrency transferred in the {cls_name}, if price is known.
     """
 
-    def __init_subclass__(cls, **kwargs):
+    def __init_subclass__(cls, **kwargs: Any) -> None:
         super().__init_subclass__(**kwargs)
 
         # Replace {cls_name} in attribute-level docstrings
@@ -273,7 +273,7 @@ class _TransactionBase(
         return self.transaction.yParity
 
     @property
-    def __db_primary_key__(self):
+    def __db_primary_key__(self) -> Dict[str, tuple[int, Address] | int]:
         return {"from_address": (chain.id, self.from_address), "nonce": self.nonce}
 
 

eth_portfolio/typing/__init__.py

@@ -43,10 +43,10 @@ from typing import (
 )
 
 from checksum_dict import DefaultChecksumDict
-from eth_typing import BlockNumber
+from eth_typing import BlockNumber, HexAddress
 from pandas import DataFrame, concat
 from typing_extensions import ParamSpec, Self
-from y import ERC20
+from y import Contract, ERC20
 from y.datatypes import Address
 
 from eth_portfolio._decimal import Decimal
@@ -159,10 +159,10 @@ class TokenBalances(DefaultChecksumDict[Balance], _SummableNonNumericMixin):  #
                     raise
                 self[token.address] += balance
 
-    def __getitem__(self, key) -> Balance:
+    def __getitem__(self, key: HexAddress) -> Balance:
         return super().__getitem__(key) if key in self else Balance(token=key, block=self.block)
 
-    def __setitem__(self, key, value):
+    def __setitem__(self, key: HexAddress, value: Balance) -> None:
         """
         Sets the balance for a given token address.
 
@@ -393,7 +393,7 @@ class RemoteTokenBalances(DefaultDict[ProtocolLabel, TokenBalances], _SummableNo
                 )
             self[remote] += token_balances  # type: ignore [has-type]
 
-    def __setitem__(self, protocol: str, value: TokenBalances):
+    def __setitem__(self, protocol: str, value: TokenBalances) -> None:
         """
         Sets the token balances for a given protocol.
 
@@ -911,7 +911,7 @@ class PortfolioBalances(DefaultChecksumDict[WalletBalances], _SummableNonNumeric
                 )
             self[wallet] += balances
 
-    def __setitem__(self, key, value):
+    def __setitem__(self, key: HexAddress, value: WalletBalances) -> None:
         if not isinstance(value, WalletBalances):
             raise TypeError(
                 f"value must be a `WalletBalances` object. You passed {value}"

eth_portfolio_scripts/_portfolio.py

@@ -1,14 +1,16 @@
+import asyncio
 from datetime import datetime, timezone
 from logging import getLogger
 from math import floor
-from typing import Awaitable, Callable, Final, Iterator, List, Optional, Tuple
+from typing import Awaitable, Callable, Final, Iterator, List, Optional, Tuple, Dict
 
 import a_sync
 import eth_retry
+import y
 from a_sync.functools import cached_property_unsafe as cached_property
 from eth_typing import BlockNumber, ChecksumAddress
 from msgspec import ValidationError, json
-from y import ERC20, Network, NonStandardERC20, get_block_at_timestamp
+from y import ERC20, Network, NonStandardERC20
 from y.constants import CHAINID
 from y.time import NoBlockFound
 
@@ -33,6 +35,19 @@ logger: Final = getLogger("eth_portfolio")
 log_debug: Final = logger.debug
 log_error: Final = logger.error
 
+_block_at_timestamp_semaphore: Final = a_sync.Semaphore(
+    50, name="eth-portfolio get_block_at_timestamp"
+)
+
+
+async def get_block_at_timestamp(dt: datetime) -> BlockNumber:
+    async with _block_at_timestamp_semaphore:
+        while True:
+            try:
+                return await y.get_block_at_timestamp(dt, sync=False)
+            except NoBlockFound:
+                await asyncio.sleep(10)
+
 
 class ExportablePortfolio(Portfolio):
     """Adds methods to export full portoflio data."""
@@ -40,17 +55,35 @@ class ExportablePortfolio(Portfolio):
     def __init__(
         self,
         addresses: Addresses,
+        *,
         start_block: int = 0,
         label: str = _DEFAULT_LABEL,
+        concurrency: int = 40,
         load_prices: bool = True,
-        get_bucket: Callable[[ChecksumAddress], Awaitable[str]] = get_token_bucket,
+        get_bucket: Callable[[ChecksumAddress], Awaitable[str]] = None,
         num_workers_transactions: int = 1000,
         asynchronous: bool = False,
+        custom_buckets: Optional[Dict[str, str]] = None,
     ):
         super().__init__(
             addresses, start_block, label, load_prices, num_workers_transactions, asynchronous
         )
-        self.get_bucket = get_bucket
+        self._semaphore = a_sync.Semaphore(concurrency)
+
+        # Lowercase all keys in custom_buckets if provided
+        self.custom_buckets = (
+            {k.lower(): v for k, v in custom_buckets.items()} if custom_buckets else None
+        )
+
+        # If get_bucket is not provided, use get_token_bucket with the lowercased mapping
+        if get_bucket is None:
+            self.get_bucket = lambda token: get_token_bucket(token, self.custom_buckets)
+        elif custom_buckets:
+            raise RuntimeError(
+                "You cannot pass in a custom get_bucket function AND a custom_buckets mapping, choose one."
+            )
+        else:
+            self.get_bucket = get_bucket
 
     @cached_property
     def _data_queries(self) -> Tuple[str, str]:
@@ -71,53 +104,48 @@ class ExportablePortfolio(Portfolio):
                 return True
         return False
 
-    async def export_snapshot(self, dt: datetime):
+    async def export_snapshot(self, dt: datetime) -> None:
         log_debug("checking data at %s for %s", dt, self.label)
         try:
-            if not await self.data_exists(dt, sync=False):
-                while True:
-                    try:
-                        block = await get_block_at_timestamp(dt, sync=False)
-                    except NoBlockFound:
-                        pass
-                    else:
-                        break
-                log_debug("block at %s: %s", dt, block)
-                data = await self.get_data_for_export(block, dt, sync=False)
-                await victoria.post_data(data)
+            if await self.data_exists(dt, sync=False):
+                return
+            block = await get_block_at_timestamp(dt)
+            log_debug("block at %s: %s", dt, block)
+            data = await self.get_data_for_export(block, dt, sync=False)
+            await victoria.post_data(data)
         except Exception as e:
             log_error("Error processing %s:", dt, exc_info=True)
 
-    @a_sync.Semaphore(60)
     async def get_data_for_export(self, block: BlockNumber, ts: datetime) -> List[victoria.Metric]:
-        print(f"exporting {ts} for {self.label}")
-        start = datetime.now(tz=timezone.utc)
-
-        metrics_to_export = []
-        data: PortfolioBalances = await self.describe(block, sync=False)
-
-        for wallet, wallet_data in dict.items(data):
-            for section, section_data in wallet_data.items():
-                if isinstance(section_data, TokenBalances):
-                    for token, bals in dict.items(section_data):
-                        metrics_to_export.extend(
-                            await self.__process_token(ts, section, wallet, token, bals)
-                        )
-                elif isinstance(section_data, RemoteTokenBalances):
-                    if section == "external":
-                        section = "assets"
-                    for protocol, token_bals in section_data.items():
-                        for token, bals in dict.items(token_bals):
+        async with self._semaphore:
+            print(f"exporting {ts} for {self.label}")
+            start = datetime.now(tz=timezone.utc)
+
+            metrics_to_export = []
+            data: PortfolioBalances = await self.describe(block, sync=False)
+
+            for wallet, wallet_data in dict.items(data):
+                for section, section_data in wallet_data.items():
+                    if isinstance(section_data, TokenBalances):
+                        for token, bals in dict.items(section_data):
                             metrics_to_export.extend(
-                                await self.__process_token(
-                                    ts, section, wallet, token, bals, protocol=protocol
-                                )
+                                await self.__process_token(ts, section, wallet, token, bals)
                             )
-                else:
-                    raise NotImplementedError()
+                    elif isinstance(section_data, RemoteTokenBalances):
+                        if section == "external":
+                            section = "assets"
+                        for protocol, token_bals in section_data.items():
+                            for token, bals in dict.items(token_bals):
+                                metrics_to_export.extend(
+                                    await self.__process_token(
+                                        ts, section, wallet, token, bals, protocol=protocol
+                                    )
+                                )
+                    else:
+                        raise NotImplementedError()
 
-        print(f"got data for {ts} in {datetime.now(tz=timezone.utc) - start}")
-        return metrics_to_export
+            print(f"got data for {ts} in {datetime.now(tz=timezone.utc) - start}")
+            return metrics_to_export
 
     def __get_data_exists_coros(self, dt: datetime) -> Iterator[str]:
         for query in self._data_queries:
@@ -131,7 +159,7 @@ class ExportablePortfolio(Portfolio):
         token: ChecksumAddress,
         bal: Balance,
         protocol: Optional[str] = None,
-    ):
+    ) -> Tuple[victoria.types.PrometheusItem, victoria.types.PrometheusItem]:
         # TODO wallet nicknames in grafana
         # wallet = KNOWN_ADDRESSES[wallet] if wallet in KNOWN_ADDRESSES else wallet
         if protocol is not None:
@@ -172,7 +200,7 @@ class ExportablePortfolio(Portfolio):
         )
 
 
-async def _get_symbol(token) -> str:
+async def _get_symbol(token: str) -> str:
     if token == "ETH":
         return "ETH"
     try:

eth_portfolio_scripts/_utils.py

@@ -1,18 +1,18 @@
 import re
 from asyncio import Task, create_task, sleep
 from datetime import datetime, timedelta, timezone
-from typing import Any, AsyncGenerator, Dict, List, Optional
+from typing import Any, AsyncGenerator, Dict, Final, List, Optional
 
 from brownie import chain
 
 
-def parse_timedelta(value: str) -> timedelta:
-    regex = re.compile(r"(\d+)([dhms]?)")
-    result = regex.findall(value)
+timedelta_pattern: Final = re.compile(r"(\d+)([dhms]?)")
+
 
+def parse_timedelta(value: str) -> timedelta:
     days, hours, minutes, seconds = 0, 0, 0, 0
 
-    for val, unit in result:
+    for val, unit in timedelta_pattern.findall(value):
         val = int(val)
         if unit == "d":
             days = val
@@ -58,10 +58,24 @@ async def aiter_timestamps(
 
     timestamp = start
 
+    timestamps = []
     while timestamp <= datetime.now(tz=timezone.utc):
-        yield timestamp
+        timestamps.append(timestamp)
         timestamp = timestamp + interval
 
+    # cycle between yielding earliest, latest, and middle from `timestamps` until complete
+    while timestamps:
+        # yield the earliest timestamp
+        yield timestamps.pop(0)
+        # yield the most recent timestamp if there is one
+        if timestamps:
+            yield timestamps.pop(-1)
+            # yield the most middle timestamp if there is one
+            if timestamps:
+                yield timestamps.pop(len(timestamps) // 2)
+
+    del timestamps
+
     while run_forever:
         while timestamp > datetime.now(tz=timezone.utc):
             await _get_waiter(timestamp)

eth_portfolio_scripts/balances.py

@@ -26,13 +26,16 @@ async def export_balances(args: Namespace) -> None:
 
     interval = parse_timedelta(args.interval)
     portfolio = ExportablePortfolio(
-        args.wallet, label=args.label, start_block=args.first_tx_block, load_prices=False
+        args.wallet,
+        label=args.label,
+        start_block=args.first_tx_block,
+        concurrency=args.concurrency,
+        load_prices=False,
     )
 
     if export_start_block := args.export_start_block or args.first_tx_block:
-        start = datetime.fromtimestamp(
-            await dank_mids.eth.get_block_timestamp(args.export_start_block), tz=timezone.utc
-        )
+        start_ts = await dank_mids.eth.get_block_timestamp(export_start_block)
+        start = datetime.fromtimestamp(start_ts, tz=timezone.utc)
     else:
         start = None
 

eth_portfolio_scripts/docker/check.py

@@ -1,5 +1,6 @@
 from functools import lru_cache
 from subprocess import CalledProcessError, check_output
+from typing import List
 
 
 def check_docker() -> None:
@@ -9,48 +10,58 @@ def check_docker() -> None:
     Raises:
         RuntimeError: If docker is not installed.
     """
+    print(" 🔍 checking your computer for docker")
     try:
         check_output(["docker", "--version"])
-        print("docker found!")
     except (CalledProcessError, FileNotFoundError):
-        print("checking your computer for docker")
         raise RuntimeError(
             "Docker is not installed. You must install Docker before using dao-treasury."
         ) from None
+    else:
+        print(" ✔️ eth-portfolio found docker!")
 
 
-def check_docker_compose() -> None:
+def check_docker_compose() -> List[str]:
     """
-    Check that docker-compose is installed on the user's system.
+    Check that either `docker-compose` or `docker compose` is installed on the user's system.
+
+    Returns:
+        A valid compose command.
 
     Raises:
         RuntimeError: If docker-compose is not installed.
     """
-    try:
-        check_output(["docker-compose", "--version"])
-        print("docker-compose found!")
-    except (CalledProcessError, FileNotFoundError):
-        print("checking your computer for docker-compose")
+    for cmd in ["docker-compose", "docker compose"]:
+        print(f" 🔍 checking your computer for {cmd}")
+
         try:
-            check_output(["docker", "compose", "--version"])
-            print("docker compose found!")
+            check_output([*cmd.split(" "), "--version"])
         except (CalledProcessError, FileNotFoundError):
-            print("docker-compose not found, checking your computer for docker compose")
-            raise RuntimeError(
-                "Docker Compose is not installed. You must install Docker Compose before using dao-treasury."
-            ) from None
+            print(f" ❌ {cmd} not found")
+            continue
+        else:
+            print(f" ✔️ eth-portfolio found {cmd}!")
+            return cmd.split(" ")
+
+    raise RuntimeError(
+        "Docker Compose is not installed. You must install Docker Compose before using dao-treasury."
+    ) from None
 
 
 @lru_cache(maxsize=None)
-def check_system() -> None:
+def check_system() -> List[str]:
     """
     Check that docker and docker-compose is installed on the user's system.
 
+    Returns:
+        A valid compose command.
+
     Raises:
         RuntimeError: If docker-compose is not installed.
     """
+    print("eth-portfolio is checking for the required docker dependencies...")
     check_docker()
-    check_docker_compose()
+    return check_docker_compose()
 
 
 __all__ = ["check_docker", "check_docker_compose", "check_system"]

eth_portfolio_scripts/docker/docker-compose.yaml

@@ -3,7 +3,7 @@ networks:
 
 services:
   grafana:
-    image: grafana/grafana:10.2.0
+    image: grafana/grafana:12.2.1
     ports:
       - 127.0.0.1:${GRAFANA_PORT:-3000}:3000
     environment:
@@ -47,7 +47,7 @@ services:
     restart: always
 
   victoria-metrics:
-    image: victoriametrics/victoria-metrics:v1.81.1
+    image: victoriametrics/victoria-metrics:v1.129.1
     volumes:
       - ~/.eth-portfolio/data/victoria/:/victoria-metrics-data
     command:

eth_portfolio_scripts/docker/docker_compose.py

@@ -3,7 +3,7 @@ from functools import wraps
 from importlib import resources
 from os import path
 from subprocess import CalledProcessError, check_output
-from typing import Callable, Final, Iterable, List, Tuple, TypeVar
+from typing import Callable, Final, Iterable, List, Literal, Tuple, TypeVar
 
 from typing_extensions import ParamSpec
 
@@ -12,33 +12,33 @@ from eth_portfolio_scripts.docker.check import check_system
 
 logger: Final = logging.getLogger(__name__)
 
-compose_file: Final = str(
+COMPOSE_FILE: Final = str(
     resources.files("eth_portfolio_scripts").joinpath("docker/docker-compose.yaml")
 )
 
 
 def up(*services: str) -> None:
+    """Build and start the specified docker-compose services."""
     build(*services)
-    print("starting the infra containers...")
+    _print_notice("starting", services)
     _exec_command(["up", "-d", *services])
 
 
 def down() -> None:
+    """Stop all of eth-portfolio's docker-compose services."""
     _exec_command(["down"])
 
 
 def build(*services: str) -> None:
-    print("building the grafana containers")
+    """Build the specified docker-compose services."""
+    _print_notice("building", services)
     _exec_command(["build", *services])
 
 
-def stop(container_name: str) -> None:
-    """
-    Stop the specified container if it is running.
-    Defaults to stopping the 'renderer' container.
-    """
-    print(f"stopping the {container_name} container...")
-    _exec_command(["stop", container_name])
+def stop(*services: str) -> None:
+    """Stop the specified docker-compose services, if running."""
+    _print_notice("stopping", services)
+    _exec_command(["stop", *services])
 
 
 _P = ParamSpec("_P")
@@ -67,12 +67,32 @@ def ensure_containers(fn: Callable[_P, _T]) -> Callable[_P, _T]:
     return compose_wrap
 
 
-def _exec_command(command: List[str], *, compose_options: Tuple[str, ...] = ()) -> None:
-    check_system()
+def _print_notice(
+    doing: Literal["building", "starting", "stopping"],
+    services: Tuple[str, ...],
+) -> None:
+    if len(services) == 0:
+        print(f"{doing} the backend containers")
+    elif len(services) == 1:
+        container = services[0]
+        print(f"{doing} the {container} container")
+    elif len(services) == 2:
+        first, second = services
+        print(f"{doing} the {first} and {second} containers")
+    else:
+        *all_but_last, last = services
+        print(f"{doing} the {', '.join(all_but_last)}, and {last} containers")
+
+
+def _exec_command(
+    command: List[str],
+    *,
+    compose_file: str = COMPOSE_FILE,
+    compose_options: Tuple[str, ...] = (),
+) -> None:
+    compose = check_system()
+    full_command = [*compose, *compose_options, "-f", compose_file, *command]
     try:
-        check_output(["docker", "compose", *compose_options, "-f", compose_file, *command])
+        check_output(full_command)
     except (CalledProcessError, FileNotFoundError) as e:
-        try:
-            check_output(["docker-compose", *compose_options, "-f", compose_file, *command])
-        except (CalledProcessError, FileNotFoundError) as _e:
-            raise RuntimeError(f"Error occurred while running {' '.join(command)}: {_e}") from _e
+        raise RuntimeError(f"Error occurred while running `{' '.join(full_command)}`: {e}") from e

eth_portfolio_scripts/main.py

@@ -54,6 +54,12 @@ export_parser.add_argument(
     help="The time interval between datapoints. default: 6h",
     default="6h",
 )
+export_parser.add_argument(
+    "--concurrency",
+    type=int,
+    help="The max number of historical blocks to export concurrently. default: 40",
+    default=40,
+)
 export_parser.add_argument(
     "--first-tx-block",
     type=int,

eth_portfolio_scripts/victoria/__init__.py

@@ -68,3 +68,6 @@ async def post_data(metrics_to_export: List["Metric"]) -> None:
 def __set_session(sesh: ClientSession) -> None:
     global session
     session = sesh
+
+
+__all__ = ["Metric", "get", "post_data"]

{eth_portfolio_temp-0.0.38.dev0.dist-info → eth_portfolio_temp-0.3.0.dist-info}/METADATA

@@ -1,22 +1,23 @@
 Metadata-Version: 2.4
 Name: eth_portfolio_temp
-Version: 0.0.38.dev0
+Version: 0.3.0
 Summary: eth-portfolio makes it easy to analyze your portfolio.
 Home-page: https://github.com/BobTheBuidler/eth-portfolio
 Author: BobTheBuidler
 Author-email: bobthebuidlerdefi@gmail.com
-Requires-Python: >=3.9,<3.13
+Requires-Python: >=3.10,<3.14
 Requires-Dist: checksum_dict>=2.1.7
 Requires-Dist: dank_mids>=4.20.154
-Requires-Dist: eth-brownie<1.23,>=1.21.0
+Requires-Dist: eth-brownie<1.23,>=1.22.0.dev0
 Requires-Dist: eth_retry<1,>=0.3.4
 Requires-Dist: evmspec>=0.4.1
-Requires-Dist: ez-a-sync>=0.32.7
+Requires-Dist: ez-a-sync>=0.32.27
+Requires-Dist: faster-async-lru==2.0.5
 Requires-Dist: faster-eth-utils
-Requires-Dist: numpy<2
-Requires-Dist: pandas<1.6,>=1.4.3
+Requires-Dist: numpy<3
+Requires-Dist: pandas<3,>=1.4.3
 Requires-Dist: typed-envs>=0.0.9
-Requires-Dist: ypricemagic<5,>=4.6.17.dev0
+Requires-Dist: ypricemagic<5,>=4.10.0
 Dynamic: author
 Dynamic: author-email
 Dynamic: home-page