eth-portfolio 0.5.7__cp312-cp312-win32.whl

eth_portfolio/typing/balance/single.py

@@ -0,0 +1,176 @@
+from typing import Literal, Union, final
+
+from dictstruct import DictStruct
+from eth_typing import BlockNumber, ChecksumAddress
+from mypy_extensions import mypyc_attr
+
+from eth_portfolio._decimal import Decimal
+
+
+@final
+@mypyc_attr(native_class=False)
+class Balance(
+    DictStruct, frozen=True, omit_defaults=True, repr_omit_defaults=True, forbid_unknown_fields=True
+):
+    """
+    Represents the balance of a single token, including its token amount and equivalent USD value.
+
+    Example:
+        >>> balance1 = Balance(Decimal('100'), Decimal('2000'))
+        >>> balance2 = Balance(Decimal('50'), Decimal('1000'))
+        >>> combined_balance = balance1 + balance2
+        >>> combined_balance.balance
+        Decimal('150')
+        >>> combined_balance.usd_value
+        Decimal('3000')
+    """
+
+    balance: Decimal = Decimal(0)
+    """
+    The amount of the token.
+    """
+
+    usd_value: Decimal = Decimal(0)
+    """
+    The USD equivalent value of the token amount.
+    """
+
+    token: ChecksumAddress | None = None
+    """
+    The token the balance is of, if known.
+    """
+
+    block: BlockNumber | None = None
+    """
+    The block from which the balance was taken, if known.
+    """
+
+    @property
+    def usd(self) -> Decimal:
+        """
+        An alias for `usd_value`. Returns the USD value of the token amount.
+        """
+        return self.usd_value
+
+    def __add__(self, other: "Balance") -> "Balance":
+        """
+        Adds two :class:`~eth_portfolio.typing.Balance` objects together. It is the user's responsibility to ensure that the two
+        :class:`~eth_portfolio.typing.Balance` instances represent the same token.
+
+        Args:
+            other: Another :class:`~eth_portfolio.typing.Balance` object.
+
+        Returns:
+            A new :class:`~eth_portfolio.typing.Balance` object with the summed values.
+
+        Raises:
+            TypeError: If the other object is not a :class:`~eth_portfolio.typing.Balance`.
+            Exception: If any other error occurs during addition.
+
+        Example:
+            >>> balance1 = Balance(Decimal('100'), Decimal('2000'))
+            >>> balance2 = Balance(Decimal('50'), Decimal('1000'))
+            >>> combined_balance = balance1 + balance2
+            >>> combined_balance.balance
+            Decimal('150')
+            >>> combined_balance.usd_value
+            Decimal('3000')
+        """
+        if not isinstance(other, Balance):
+            raise TypeError(f"{other} is not a `Balance` object")
+        if self.token != other.token:
+            raise ValueError(
+                f"These Balance objects represent balances of different tokens ({self.token} and {other.token})"
+            )
+        if self.block != other.block:
+            raise ValueError(
+                f"These Balance objects represent balances from different blocks ({self.block} and {other.block})"
+            )
+        try:
+            return Balance(
+                balance=self.balance + other.balance,
+                usd_value=self.usd_value + other.usd_value,
+                token=self.token,
+                block=self.block,
+            )
+        except Exception as e:
+            e.args = (f"Cannot add {self} and {other}: {e}", *e.args)
+            raise
+
+    def __radd__(self, other: Union["Balance", Literal[0]]) -> "Balance":
+        """
+        Supports the addition operation from the right side to enable use of `sum`.
+
+        Args:
+            other: Another :class:`~eth_portfolio.typing.Balance` object or zero.
+
+        Returns:
+            A new :class:`~eth_portfolio.typing.Balance` object with the summed values.
+
+        Raises:
+            TypeError: If the other object is not a :class:`~eth_portfolio.typing.Balance`.
+            Exception: If any other error occurs during addition.
+
+        Example:
+            >>> balance = Balance(Decimal('100'), Decimal('2000'))
+            >>> sum_balance = sum([balance, Balance()])
+            >>> sum_balance.balance
+            Decimal('100')
+        """
+        return self if other == 0 else self.__add__(other)  # type: ignore
+
+    def __sub__(self, other: "Balance") -> "Balance":
+        """
+        Subtracts one :class:`~eth_portfolio.typing.Balance` object from another. It is the user's responsibility to ensure that
+        the two :class:`~eth_portfolio.typing.Balance` instances represent the same token.
+
+        Args:
+            other: Another :class:`~eth_portfolio.typing.Balance` object.
+
+        Returns:
+            A new :class:`~eth_portfolio.typing.Balance` object with the subtracted values.
+
+        Raises:
+            TypeError: If the other object is not a :class:`~eth_portfolio.typing.Balance`.
+            Exception: If any other error occurs during subtraction.
+
+        Example:
+            >>> balance1 = Balance(Decimal('100'), Decimal('2000'))
+            >>> balance2 = Balance(Decimal('50'), Decimal('1000'))
+            >>> result_balance = balance1 - balance2
+            >>> result_balance.balance
+            Decimal('50')
+        """
+        if not isinstance(other, Balance):
+            raise TypeError(f"{other} is not a `Balance` object.")
+        if self.token != other.token:
+            raise ValueError(
+                f"These Balance objects represent balances of different tokens ({self.token} and {other.token})"
+            )
+        if self.block != other.block:
+            raise ValueError(
+                f"These Balance objects represent balances from different blocks ({self.block} and {other.block})"
+            )
+        try:
+            return Balance(
+                balance=self.balance - other.balance,
+                usd_value=self.usd_value - other.usd_value,
+                token=self.token,
+                block=self.block,
+            )
+        except Exception as e:
+            raise e.__class__(f"Cannot subtract {self} and {other}: {e}") from e
+
+    def __bool__(self) -> bool:
+        """
+        Evaluates the truth value of the :class:`~eth_portfolio.typing.Balance` object.
+
+        Returns:
+            True if either the balance or the USD value is non-zero, otherwise False.
+
+        Example:
+            >>> balance = Balance(Decimal('0'), Decimal('0'))
+            >>> bool(balance)
+            False
+        """
+        return self.balance != 0 or self.usd_value != 0

eth_portfolio-0.5.7.dist-info/METADATA

@@ -0,0 +1,26 @@
+Metadata-Version: 2.4
+Name: eth_portfolio
+Version: 0.5.7
+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.10,<3.14
+Requires-Dist: checksum_dict>=2.1.7
+Requires-Dist: dank_mids>=4.20.192
+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.33.10
+Requires-Dist: faster-async-lru==2.0.5.3
+Requires-Dist: faster-eth-utils
+Requires-Dist: numpy<3
+Requires-Dist: pandas<3,>=1.4.3
+Requires-Dist: typed-envs>=0.2.3
+Requires-Dist: ypricemagic<5.2,>=5.1.3
+Dynamic: author
+Dynamic: author-email
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

eth_portfolio-0.5.7.dist-info/RECORD

@@ -0,0 +1,83 @@
+eth_portfolio__mypyc.cp312-win32.pyd,sha256=bwBx2Xjvu1zbViE8tin9f1nyCSgfg5ly4-s8QbcobRU,267264
+eth_portfolio/__init__.py,sha256=uCSi24HXqtcGiC98YQcWl6oqhjQecnr0ndQnTPOKS4E,523
+eth_portfolio/_argspec.cp312-win32.pyd,sha256=yBlUydU2A48VUKLRf7k2ZgHBNCJGLmlYG7y26HDYR5A,9216
+eth_portfolio/_argspec.py,sha256=311dk4kMWCRegjSYvoG3D8wBUSF4be5xJrRAXare1qE,1646
+eth_portfolio/_cache.py,sha256=i1MlpkJvLYzuI3jqIgg_1GsLpUKt98OQWDKzIgGC6Yk,4847
+eth_portfolio/_config.cp312-win32.pyd,sha256=orLZPbDbGbZIzFSr0DNWxS3tuTStJ5kwi4l_DuzS5aI,9216
+eth_portfolio/_config.py,sha256=BSOvFS4D0oqgVTtBbtW2g2kpL8Mk6xiP0PipfXs_91A,102
+eth_portfolio/_decimal.py,sha256=KDTNEfMQo-Ypr3G7hoRsSFLZY_UL5f_KaHpZZHmGqgw,4968
+eth_portfolio/_decorators.py,sha256=8rjemWjJQ3wuVw7kNcxIfwsL_D_NLKuSamTBBE-fKKs,2875
+eth_portfolio/_exceptions.py,sha256=FySY2tnUpqONsp7HXqIxPWr0MUqNy24kJDYNV0PJKzA,2488
+eth_portfolio/_shitcoins.cp312-win32.pyd,sha256=UVQxvATfqwO_TGRWs-NquhQ_oKWh0YOby_Tg-72dCqQ,9216
+eth_portfolio/_shitcoins.py,sha256=OdYTv6UzBF_jQ308Nv7l2VYdomEbx4f6-Ux3VI4uvd0,18006
+eth_portfolio/_stableish.cp312-win32.pyd,sha256=MuAZLMtNpG5tXszhXRTQS6QxG4BaLmxrszdhnVZmgvI,9216
+eth_portfolio/_stableish.py,sha256=nui4S0BZvFM1i-Gp8SeW8W5DMUgwXMw6wW23qFbPGV0,2058
+eth_portfolio/_submodules.py,sha256=MHM7p7jajEolkaw9yIsbdQKgKLSI8JaUIIo-g0wA3mk,2249
+eth_portfolio/_utils.py,sha256=AldFoIAVNQttP-PnitRLn_ArkCSOo1Qaw0q_8Zn-uko,7816
+eth_portfolio/address.py,sha256=uI1oM7PAEiYnOhsuQNWecD2UkvV7ikXQT8yBG8AhTLY,14497
+eth_portfolio/buckets.py,sha256=jGMtcR1ji5_Czte6rJLT9gXusc6Na6ddmOPaefa27Lg,7775
+eth_portfolio/constants.cp312-win32.pyd,sha256=-KF2tdulRhHvQ6zcTEm4jLyyz7qPcteh0dCr4-tD0uA,9216
+eth_portfolio/constants.py,sha256=IKMVKXjoQ74RRnpK3sEtqbbGmwKlYg0pXzuGVO0R0B8,4063
+eth_portfolio/portfolio.py,sha256=mBrwOwhKfT7dwC3EyPhAFsa4QUsMANd5BFOj3ePgz98,24871
+eth_portfolio/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+eth_portfolio/_db/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+eth_portfolio/_db/decorators.py,sha256=zOz-rFj2kIpxdOxBE55E23U9sz0slCUY87nNvZCdtYE,5334
+eth_portfolio/_db/entities.py,sha256=smj7xBHB4jJNLeWI7IYTvPGKCBcy7pu5ihJ4qAheL-k,10326
+eth_portfolio/_db/utils.py,sha256=wuHU1TJr_EiafNqgJWj7ns_paSY7MALeIzY3S4RAEYo,22307
+eth_portfolio/_ledgers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+eth_portfolio/_ledgers/address.py,sha256=-Ez2UYp8-zErrth6o-9DnseLS2LxzcJAKtHxC-if1LQ,33653
+eth_portfolio/_ledgers/portfolio.py,sha256=7wLE-tDWtlBfQpwX6SbTeF_hqQx4lc5yMFesS8oz894,13411
+eth_portfolio/_loaders/__init__.py,sha256=1-fvYUf9nDB-udpp4LQmrrRYa0vqwjOCO9MgiPzqQmk,1735
+eth_portfolio/_loaders/_nonce.cp312-win32.pyd,sha256=jFke9C4CZvEj7ywCST4qP6o69ZzIXI_eodnqrz1jEbg,9216
+eth_portfolio/_loaders/_nonce.py,sha256=rT1WDYFCFNEaoOjhMn3hCKTAb08ndjpM1FI4qU6r6To,6406
+eth_portfolio/_loaders/balances.cp312-win32.pyd,sha256=xX81j61-Txr2-XWn5rbuIi5fLekalfN-Ttnh12WIAU0,9216
+eth_portfolio/_loaders/balances.py,sha256=XTl109mc_0IAe_l6kR2C5cPs4RcElBxGqO7fGztKeUw,3406
+eth_portfolio/_loaders/token_transfer.py,sha256=qaHCL6bQec7IfvZDl6PFUeBNQjqZjE8sMYWIRHtsL7U,8707
+eth_portfolio/_loaders/transaction.py,sha256=h9xMQzOu4jMrTa8T4jAt2gx1mMtuTZFVMmcCodtyzOE,9390
+eth_portfolio/_loaders/utils.cp312-win32.pyd,sha256=3KPz3bSnxxfl0dEuQXHsWIaFhqkNF3-8DKeL3Xd4sAg,9216
+eth_portfolio/_loaders/utils.py,sha256=rvgu3H38WG17KX0lQS1NcH_R_1sCdJE15tgJuBcOPTs,2331
+eth_portfolio/_ydb/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+eth_portfolio/_ydb/token_transfers.py,sha256=ajcPFzPqhIoWHJyyFo_nwfBJ_RUB04oKaHi0GVj30Aw,5317
+eth_portfolio/protocols/__init__.py,sha256=NG6u79GKUzZcR6SBN6mfmnjdoZ9yJ_jfdebHt5vFxuk,2581
+eth_portfolio/protocols/_base.py,sha256=pVCo7JyZ-jvZe3Tx9tHTz5h3Zc07QgFPJZ0QWPgdRZk,3740
+eth_portfolio/protocols/convex.py,sha256=az8FhxLtXf0WKo25Ke0IDRGF8x1yMlffoCRz9aG2fGE,535
+eth_portfolio/protocols/dsr.py,sha256=v8hrcIctOSA6W_gsTDlxaKUBs51-EkQs8bIlUy2oE8Y,1788
+eth_portfolio/protocols/liquity.py,sha256=80W-o_4JaB2rXIXpCCh66gf-hfNWnJrphuwbGPKNrSo,658
+eth_portfolio/protocols/lending/README.md,sha256=0C941RnyfQwT1DE9bvxwLP-gBTHlQcQysF-75FXHINo,498
+eth_portfolio/protocols/lending/__init__.py,sha256=49__JYku_iE59Z2MdNHeGoZspHQyVXOtkQLWgWt0NUc,1681
+eth_portfolio/protocols/lending/_base.py,sha256=MRZBYBc9UyFbjlDmL5Xv76I7G6ugOye7fI3KW-F6kDM,2276
+eth_portfolio/protocols/lending/compound.py,sha256=3YhJIYaQD19BcrR_hOD76Ra_IJCA-OwjpJyp6es_3qc,7392
+eth_portfolio/protocols/lending/liquity.py,sha256=Kcj_glFd5LNVkuCI35QbmPbDmZRYRecqcrdalGxlwcU,4257
+eth_portfolio/protocols/lending/maker.py,sha256=LLuABFg8dMna2qery4NM7Lh4tQ6x9r4bbnXa9VH7b8U,4392
+eth_portfolio/protocols/lending/unit.py,sha256=9x_npC9ZWCTITWcyu2aJL3EY-_y_9aulJq7QnFo9m-0,1974
+eth_portfolio/structs/__init__.py,sha256=x-9CdKe8XMukp8Kjr_lD49ohrSd0iGEvvsMAHtAPrLI,1486
+eth_portfolio/structs/modified.py,sha256=QIuFh-u5VTHe0oborn3oHAiAGD0wqhUQW7XFJVZu2KI,1853
+eth_portfolio/structs/structs.py,sha256=gJYoRiXxnuX_v5imJp6f5fuG8GKUpANrcJZTH2IiqCM,20334
+eth_portfolio/typing/__init__.py,sha256=ja6XhyzBeInat7tejA-l97poDNJvY6ogXaDh8fIoZqE,58478
+eth_portfolio/typing/balance/single.py,sha256=A0bxQvaJsXy7P2zNAYBwWH8GUOFXl1iY10qnT1vMVao,6485
+eth_portfolio_scripts/__init__.py,sha256=DjzksD_vlJC5UeeEucCPMT3D4oClcK17JhLQoHH_hTU,275
+eth_portfolio_scripts/_args.py,sha256=M33vPkja62XEJeCZAqacNSBCqbzse07wepwyBOtkvVo,682
+eth_portfolio_scripts/_logging.py,sha256=Oj_6t99vRjM3gSIMLzjiKWbOGMkt0W3NhespQ7SYzAk,367
+eth_portfolio_scripts/_portfolio.py,sha256=YUerI8eUnsDvG7rLQUa7foaUOh0VbCGImPedx58O8Jk,7994
+eth_portfolio_scripts/_utils.py,sha256=RmaIorH3vrwm8ltd9-0iJCwwfCeEd2swHcdFnTPKWNA,3164
+eth_portfolio_scripts/balances.cp312-win32.pyd,sha256=dpPAUcG6mx6P7FZCLr68Y2MGT_K-8vYtBKUOGDd-72g,9216
+eth_portfolio_scripts/balances.py,sha256=EKKfBLPbWCpbe-e0vZVzWPsdXQnNq6ppyt4dw55HPQ8,1780
+eth_portfolio_scripts/main.py,sha256=T151lGdqdnkvHyjYyLVNsdXU6rkAvfDUj6lqXZKWzx0,3794
+eth_portfolio_scripts/py.typed,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
+eth_portfolio_scripts/docker/__init__.cp312-win32.pyd,sha256=RUkXjlmo-C3JpwjOiYL2VQpl4z6HMpWpnKedEx9lHso,9216
+eth_portfolio_scripts/docker/__init__.py,sha256=LFmgKAsw1hhGHbKZYLambYvAuj_RANZM_JrHMC2vtRI,409
+eth_portfolio_scripts/docker/check.cp312-win32.pyd,sha256=x66h_zZzKjh5pv_R44dmhR1ENMksXY0WuugUprz_-Vk,9216
+eth_portfolio_scripts/docker/check.py,sha256=_NyFsuqyiqnAIWXzA2g-mJhBFMbiRCqtV3gh_yrpHr0,1972
+eth_portfolio_scripts/docker/docker-compose.yaml,sha256=CO7RzS-PYXi7AeRX1DDA8LQB8HOAPfMIBZW9kE85W2k,1870
+eth_portfolio_scripts/docker/docker_compose.cp312-win32.pyd,sha256=40YYPWnE7NnSFMGQMcTrDhmin46Q4VgQBj7B8FIhT1g,9216
+eth_portfolio_scripts/docker/docker_compose.py,sha256=oOAjTzmWjoBYZ1kav-pDqcOA_yKVyn13LZ366Ga-SUI,2885
+eth_portfolio_scripts/docker/.grafana/dashboards/dashboards.yaml,sha256=wktTI-OAdF_khhbciZFo4Gt2V9bUjbe7GLqwdzTKf0U,212
+eth_portfolio_scripts/docker/.grafana/dashboards/Portfolio/Balances.json,sha256=XGMV8e4tDak53e9bmymwAB4uqZmAIcU5JlRT3OiwTeU,70750
+eth_portfolio_scripts/docker/.grafana/datasources/datasources.yml,sha256=8PPH_QDhfbRRh3IidskW46rifJejloa1a9I1KCw2FTk,199
+eth_portfolio_scripts/victoria/__init__.py,sha256=krFduQKal90rA3TFkP5tWZWcuaLVdBODMczroZwHOlY,2036
+eth_portfolio_scripts/victoria/types.py,sha256=oCJizCdTqgFjnR7krW7sLEVeQGa3MpJO4dd8Om41FNI,732
+eth_portfolio-0.5.7.dist-info/METADATA,sha256=N3dA5VED34QtfuJTOlE2zEYvn0eNpUtp6z1rmpsxtmM,837
+eth_portfolio-0.5.7.dist-info/WHEEL,sha256=LwxTQZ0gyDP_uaeNCLm-ZIktY9hv6x0e22Q-hgFd-po,97
+eth_portfolio-0.5.7.dist-info/entry_points.txt,sha256=yqoC6X3LU1NA_-oJ6mloEYEPNmS-0hPS9OtEwgIeDGU,66
+eth_portfolio-0.5.7.dist-info/top_level.txt,sha256=4MlbY-Yj8oGBGL8piXiO4SOpk2gZFF9ZXVTObTZOzqM,57
+eth_portfolio-0.5.7.dist-info/RECORD,,

eth_portfolio-0.5.7.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: false
+Tag: cp312-cp312-win32
+

eth_portfolio-0.5.7.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+eth-portfolio = eth_portfolio_scripts.main:main

eth_portfolio-0.5.7.dist-info/top_level.txt

@@ -0,0 +1,3 @@
+eth_portfolio
+eth_portfolio__mypyc
+eth_portfolio_scripts

eth_portfolio_scripts/__init__.py

@@ -0,0 +1,17 @@
+from os import environ
+
+environ["DANKMIDS_GANACHE_FORK"] = "0"
+environ["DANKMIDS_COLLECT_STATS"] = "0"
+
+
+from dotenv import load_dotenv
+
+load_dotenv()
+
+
+from eth_portfolio_scripts._logging import logger, setup_logging
+
+setup_logging()
+
+
+__all__ = ["logger"]

eth_portfolio_scripts/_args.py

@@ -0,0 +1,26 @@
+from argparse import ArgumentParser
+
+
+def get_arg_parser(description: str) -> ArgumentParser:
+    return ArgumentParser(description)
+
+
+def add_infra_port_args(parser: ArgumentParser) -> None:
+    parser.add_argument(
+        "--grafana-port",
+        type=int,
+        help="The port that will be used by grafana",
+        default=3000,
+    )
+    parser.add_argument(
+        "--renderer-port",
+        type=int,
+        help="The port that will be used by grafana",
+        default=8091,
+    )
+    parser.add_argument(
+        "--victoria-port",
+        type=int,
+        help="The port that will be used by victoria metrics",
+        default=8428,
+    )

eth_portfolio_scripts/_logging.py

@@ -0,0 +1,14 @@
+import warnings
+from logging import INFO, basicConfig, getLogger
+
+from brownie.exceptions import BrownieCompilerWarning, BrownieEnvironmentWarning
+
+logger = getLogger(__name__)
+
+
+def setup_logging() -> None:
+    basicConfig(level=INFO)
+
+
+warnings.simplefilter("ignore", BrownieCompilerWarning)
+warnings.simplefilter("ignore", BrownieEnvironmentWarning)

eth_portfolio_scripts/_portfolio.py

@@ -0,0 +1,209 @@
+import asyncio
+from collections.abc import Awaitable, Callable, Iterator
+from datetime import datetime, timezone
+from logging import getLogger
+from math import floor
+from typing import Final
+
+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
+from y.constants import CHAINID
+from y.time import NoBlockFound
+
+from eth_portfolio import Portfolio
+from eth_portfolio.buckets import get_token_bucket
+from eth_portfolio.portfolio import _DEFAULT_LABEL
+from eth_portfolio.typing import (
+    Addresses,
+    Balance,
+    PortfolioBalances,
+    RemoteTokenBalances,
+    TokenBalances,
+)
+from eth_portfolio_scripts import victoria
+
+NETWORK_LABEL: Final = Network.label(CHAINID)
+
+decode: Final = json.decode
+
+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."""
+
+    def __init__(
+        self,
+        addresses: Addresses,
+        *,
+        start_block: int = 0,
+        label: str = _DEFAULT_LABEL,
+        concurrency: int = 30,
+        load_prices: bool = True,
+        get_bucket: Callable[[ChecksumAddress], Awaitable[str]] = None,
+        num_workers_transactions: int = 1000,
+        asynchronous: bool = False,
+        custom_buckets: dict[str, str] | None = None,
+    ):
+        super().__init__(
+            addresses, start_block, label, load_prices, num_workers_transactions, asynchronous
+        )
+        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]:
+        label = self.label.lower().replace(" ", "_")
+        return f"{label}_assets", f"{label}_debts"
+
+    @eth_retry.auto_retry
+    @a_sync.Semaphore(16)
+    async def data_exists(self, dt: datetime) -> bool:
+        # sourcery skip: use-contextlib-suppress
+        async for data in a_sync.as_completed(list(self.__get_data_exists_coros(dt)), aiter=True):
+            try:
+                result = decode(data, type=victoria.types.Response)
+            except ValidationError:
+                raise victoria.VictoriaMetricsError(data.decode()) from None
+            if result.status == "success" and len(result.data.result) > 0:
+                print(f"{dt} already loaded")
+                return True
+        return False
+
+    async def export_snapshot(self, dt: datetime) -> None:
+        log_debug("checking data at %s for %s", dt, self.label)
+        try:
+            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)
+
+    async def get_data_for_export(self, block: BlockNumber, ts: datetime) -> list[victoria.Metric]:
+        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)
+                            )
+                    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
+
+    def __get_data_exists_coros(self, dt: datetime) -> Iterator[str]:
+        for query in self._data_queries:
+            yield victoria.get(f"/api/v1/query?query={query}&time={int(dt.timestamp())}")
+
+    async def __process_token(
+        self,
+        ts: datetime,
+        section: str,
+        wallet: ChecksumAddress,
+        token: ChecksumAddress,
+        bal: Balance,
+        protocol: str | None = 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:
+            wallet = f"{protocol} | {wallet}"
+
+        label_and_section = f"{self.label}_{section}".lower().replace(" ", "_")
+        symbol = await _get_symbol(token)
+        bucket = await self.get_bucket(token)
+        ts_millis = floor(ts.timestamp()) * 1000
+
+        return (
+            victoria.types.PrometheusItem(
+                metric=victoria.Metric(
+                    param="balance",
+                    wallet=wallet,
+                    token_address=token,
+                    token=symbol,
+                    bucket=bucket,
+                    network=NETWORK_LABEL,
+                    __name__=label_and_section,
+                ),
+                values=[float(bal.balance)],
+                timestamps=[ts_millis],
+            ),
+            victoria.types.PrometheusItem(
+                metric=victoria.Metric(
+                    param="usd value",
+                    wallet=wallet,
+                    token_address=token,
+                    token=symbol,
+                    bucket=bucket,
+                    network=NETWORK_LABEL,
+                    __name__=label_and_section,
+                ),
+                values=[float(bal.usd)],
+                timestamps=[ts_millis],
+            ),
+        )
+
+
+async def _get_symbol(token: str) -> str:
+    if token == "ETH":
+        return "ETH"
+    try:
+        return await ERC20(token, asynchronous=True).symbol
+    except NonStandardERC20:
+        return "<NonStandardERC20>"

eth_portfolio_scripts/_utils.py

@@ -0,0 +1,106 @@
+import re
+from asyncio import Task, create_task, sleep
+from collections.abc import AsyncGenerator
+from datetime import datetime, timedelta, timezone
+from typing import Any, Final
+
+from brownie import chain
+
+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 timedelta_pattern.findall(value):
+        val = int(val)
+        if unit == "d":
+            days = val
+        elif unit == "h":
+            hours = val
+        elif unit == "m":
+            minutes = val
+        elif unit == "s":
+            seconds = val
+
+    return timedelta(days=days, hours=hours, minutes=minutes, seconds=seconds)
+
+
+async def aiter_timestamps(
+    *,
+    start: datetime | None = None,
+    interval: timedelta = timedelta(days=1),
+    run_forever: bool = False,
+) -> AsyncGenerator[datetime, None]:
+    """
+    Generates the timestamps to be queried based on the specified range and interval.
+    """
+    if not isinstance(run_forever, bool):
+        raise TypeError(f"`run_forever` must be boolean. You passed {run_forever}")
+
+    if start is None:
+        start = datetime.now(tz=timezone.utc)
+
+    block0_ts = datetime.fromtimestamp(chain[0].timestamp, tz=timezone.utc)
+    helper = datetime(
+        year=block0_ts.year,
+        month=block0_ts.month,
+        day=block0_ts.day,
+        hour=block0_ts.hour,
+        minute=block0_ts.minute,
+        tzinfo=timezone.utc,
+    )
+    while helper + interval < start:
+        helper += interval
+    start = helper
+    if start < block0_ts:
+        start += interval
+
+    timestamp = start
+
+    timestamps = []
+    while timestamp <= datetime.now(tz=timezone.utc):
+        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)
+        yield timestamp
+        timestamp += interval
+
+
+_waiters: dict[datetime, "Task[None]"] = {}
+
+
+def _get_waiter(timestamp: datetime) -> "Task[None]":
+    if timestamp not in _waiters:
+        waiter = create_task(sleep_until(timestamp))
+        waiter.add_done_callback(_sleep_done_callback)
+        _waiters[timestamp] = waiter
+    return _waiters[timestamp]
+
+
+async def sleep_until(until: datetime) -> None:
+    now = datetime.now(tz=timezone.utc)
+    await sleep((until - now).total_seconds())
+
+
+def _sleep_done_callback(t: "Task[Any]") -> None:
+    low_to_hi = sorted(_waiters)
+    for k in low_to_hi:
+        if _waiters[k] is t:
+            _waiters.pop(k)