dao-treasury 0.0.44__tar.gz → 0.0.45__tar.gz

{dao_treasury-0.0.44 → dao_treasury-0.0.45}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: dao_treasury
-Version: 0.0.44
+Version: 0.0.45
 Summary: Produce comprehensive financial reports for your on-chain org
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
@@ -14,6 +14,13 @@ Classifier: Operating System :: OS Independent
 Classifier: Topic :: Software Development :: Libraries
 Requires-Python: >=3.10,<3.13
 Description-Content-Type: text/markdown
+Requires-Dist: eth-portfolio-temp<0.2,>=0.1.7.dev0
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 DAO Treasury is a comprehensive financial reporting and treasury management solution designed specifically for decentralized organizations. Built as an extension to [eth-portfolio](https://github.com/BobTheBuidler/eth-portfolio)'s [Portfolio Exporter](https://bobthebuidler.github.io/eth-portfolio/exporter.html), DAO Treasury automates the collection and visualization of financial data, enabling organizations to monitor and report on treasury activities with clarity and transparency.
 

{dao_treasury-0.0.44 → dao_treasury-0.0.45}/dao_treasury/db.py

@@ -23,7 +23,18 @@ from functools import lru_cache
 from logging import getLogger
 from os import path
 from pathlib import Path
-from typing import TYPE_CHECKING, Dict, Final, Tuple, Union, final
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Coroutine,
+    Dict,
+    Final,
+    Literal,
+    Tuple,
+    Union,
+    final,
+    overload,
+)
 from datetime import date, datetime, time, timezone
 
 import eth_portfolio
@@ -33,13 +44,14 @@ from brownie.convert.datatypes import HexString
 from brownie.exceptions import EventLookupError
 from brownie.network.event import EventDict, _EventItem
 from brownie.network.transaction import TransactionReceipt
-from eth_typing import ChecksumAddress, HexAddress, HexStr
 from eth_portfolio.structs import (
     InternalTransfer,
     LedgerEntry,
     TokenTransfer,
     Transaction,
 )
+from eth_retry import auto_retry
+from eth_typing import ChecksumAddress, HexAddress, HexStr
 from pony.orm import (
     Database,
     InterfaceError,
@@ -71,6 +83,7 @@ SQLITE_DIR.mkdir(parents=True, exist_ok=True)
 
 _INSERT_THREAD = AsyncThreadPoolExecutor(1)
 _SORT_THREAD = AsyncThreadPoolExecutor(1)
+_EVENTS_THREADS = AsyncThreadPoolExecutor(16)
 _SORT_SEMAPHORE = Semaphore(50)
 
 _UTC = timezone.utc
@@ -731,7 +744,15 @@ class TreasuryTx(DbEntity):
         """Decoded event logs for this transaction."""
         return self._transaction.events
 
-    def get_events(self, event_name: str) -> _EventItem:
+    @overload
+    def get_events(
+        self, event_name: str, sync: Literal[False]
+    ) -> Coroutine[Any, Any, _EventItem]: ...
+    @overload
+    def get_events(self, event_name: str, sync: bool = True) -> _EventItem: ...
+    def get_events(self, event_name: str, sync: bool = True) -> _EventItem:
+        if not sync:
+            return _EVENTS_THREADS.run(self.get_events, event_name)
         try:
             return self.events[event_name]
         except EventLookupError:
@@ -748,6 +769,7 @@ class TreasuryTx(DbEntity):
         return get_transaction(self.hash)
 
     @staticmethod
+    @auto_retry
     async def insert(entry: LedgerEntry) -> None:
         """Asynchronously insert and sort a ledger entry.
 

{dao_treasury-0.0.44 → dao_treasury-0.0.45}/dao_treasury/docker-compose.yaml

@@ -5,7 +5,7 @@ networks:
 
 services:
   grafana:
-    image: grafana/grafana:12.1.0
+    image: grafana/grafana:12.1.1
     ports:
       - 127.0.0.1:${DAO_TREASURY_GRAFANA_PORT:-3004}:3000
     environment:

{dao_treasury-0.0.44 → dao_treasury-0.0.45}/dao_treasury.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
-Name: dao-treasury
-Version: 0.0.44
+Metadata-Version: 2.4
+Name: dao_treasury
+Version: 0.0.45
 Summary: Produce comprehensive financial reports for your on-chain org
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
@@ -14,6 +14,13 @@ Classifier: Operating System :: OS Independent
 Classifier: Topic :: Software Development :: Libraries
 Requires-Python: >=3.10,<3.13
 Description-Content-Type: text/markdown
+Requires-Dist: eth-portfolio-temp<0.2,>=0.1.7.dev0
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 DAO Treasury is a comprehensive financial reporting and treasury management solution designed specifically for decentralized organizations. Built as an extension to [eth-portfolio](https://github.com/BobTheBuidler/eth-portfolio)'s [Portfolio Exporter](https://bobthebuidler.github.io/eth-portfolio/exporter.html), DAO Treasury automates the collection and visualization of financial data, enabling organizations to monitor and report on treasury activities with clarity and transparency.
 

{dao_treasury-0.0.44 → dao_treasury-0.0.45}/dao_treasury.egg-info/SOURCES.txt

@@ -38,4 +38,6 @@ dao_treasury/sorting/rules/__init__.py
 dao_treasury/sorting/rules/ignore/__init__.py
 dao_treasury/sorting/rules/ignore/llamapay.py
 dao_treasury/streams/__init__.py
-dao_treasury/streams/llamapay.py
+dao_treasury/streams/llamapay.py
+tests/test_treasury.py
+tests/test_wallet.py

dao_treasury-0.0.45/dao_treasury.egg-info/requires.txt

@@ -0,0 +1 @@
+eth-portfolio-temp<0.2,>=0.1.7.dev0

{dao_treasury-0.0.44 → dao_treasury-0.0.45}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "dao-treasury"
-version = "0.0.44"
+version = "0.0.45"
 description = "Produce comprehensive financial reports for your on-chain org"
 authors = ["BobTheBuidler <bobthebuidlerdefi@gmail.com>"]
 license = "MIT"
@@ -11,7 +11,7 @@ dao-treasury = "dao_treasury.main:main"
 
 [tool.poetry.dependencies]
 python = ">=3.10,<3.13"
-eth-portfolio-temp = ">=0.1.6.dev0,<0.2"
+eth-portfolio-temp = ">=0.1.7.dev0,<0.2"
 
 [tool.poetry.group.dev.dependencies]
 pytest = "^6.2.5"

dao_treasury-0.0.45/tests/test_treasury.py

@@ -0,0 +1,63 @@
+import pytest
+from unittest.mock import AsyncMock, patch
+
+from brownie.convert.datatypes import EthAddress
+
+from dao_treasury import Treasury, TreasuryWallet, treasury
+
+
+@pytest.fixture(autouse=True)
+def reset_treasury():
+    # Clear global state before each test
+    treasury.TREASURY = None
+    yield
+    # Clear global state after each test
+    treasury.TREASURY = None
+
+
+def test_successful_creation():
+    wallets = ["0x0000000000000000000000000000000000000001"]
+    treasury = Treasury(wallets)
+
+    assert isinstance(treasury, Treasury)
+    assert all(isinstance(wallet, TreasuryWallet) for wallet in treasury.wallets)
+
+
+def test_wallet_processing():
+    wallets = [
+        "0x0000000000000000000000000000000000000001",
+        EthAddress("0x0000000000000000000000000000000000000002"),
+        TreasuryWallet("0x0000000000000000000000000000000000000003"),
+    ]
+    treasury = Treasury(wallets)
+    assert treasury.wallets[0].address == "0x0000000000000000000000000000000000000001"
+    assert treasury.wallets[1].address == "0x0000000000000000000000000000000000000002"
+    assert treasury.wallets[2].address == "0x0000000000000000000000000000000000000003"
+
+
+def test_invalid_wallet_type():
+    with pytest.raises(TypeError):
+        Treasury(["0x0000000000000000000000000000000000000001", 123])
+
+
+def test_asynchronous_creation():
+    wallets = ["0x0000000000000000000000000000000000000001"]
+    treasury = Treasury(wallets, asynchronous=True)
+    assert treasury.asynchronous == True
+
+
+@patch(
+    "eth_portfolio_scripts._portfolio.ExportablePortfolio.describe",
+    new_callable=AsyncMock,
+)
+# @pytest.mark.asyncio
+def test_describe(mock_describe):
+    wallets = ["0x0000000000000000000000000000000000000001"]
+    treasury = Treasury(wallets)
+
+    block = 1234567
+    mock_describe.return_value = {"balance": 100}
+    result = treasury.describe(block)
+
+    mock_describe.assert_awaited_once_with(block)
+    assert result == {"balance": 100}

dao_treasury-0.0.45/tests/test_wallet.py

@@ -0,0 +1,298 @@
+import pytest
+from brownie.convert.datatypes import EthAddress
+
+from dao_treasury import TreasuryWallet
+
+
+def test_successful_creation():
+    address = "0x0000000000000000000000000000000000000001"
+    wallet = TreasuryWallet(address)
+    assert wallet.address == EthAddress(address)
+    assert wallet.start_block is None
+    assert wallet.end_block is None
+    assert wallet.start_timestamp is None
+    assert wallet.end_timestamp is None
+
+
+def test_eth_address_conversion():
+    address = "0x0000000000000000000000000000000000000001"
+    wallet = TreasuryWallet(address)
+    assert isinstance(wallet.address, EthAddress)
+
+
+def test_conflicting_start_block_and_timestamp():
+    address = "0x0000000000000000000000000000000000000001"
+    with pytest.raises(ValueError) as excinfo:
+        TreasuryWallet(address, start_block=1, start_timestamp=1234567890)
+    assert "You can only pass a start block or a start timestamp" in str(excinfo.value)
+
+
+def test_conflicting_end_block_and_timestamp():
+    address = "0x0000000000000000000000000000000000000001"
+    with pytest.raises(ValueError) as excinfo:
+        TreasuryWallet(address, end_block=1, end_timestamp=1234567890)
+    assert "You can only pass an end block or an end timestamp" in str(excinfo.value)
+
+
+"""
+def test_conflicting_start_block_and_end_block():
+    address = "0x0000000000000000000000000000000000000001"
+    with pytest.raises(ValueError) as excinfo:
+        TreasuryWallet(address, end_block=1, end_timestamp=1234567890)
+    assert "You can only pass an end block or an end timestamp" in str(excinfo.value)
+
+def test_conflicting_start_timestamp_and_end_timestamp():
+    address = "0x0000000000000000000000000000000000000001"
+    with pytest.raises(ValueError) as excinfo:
+        TreasuryWallet(address, end_block=1, end_timestamp=1234567890)
+    assert "You can only pass an end block or an end timestamp" in str(excinfo.value)
+
+def test_conflicting_start_block_and_end_timestamp():
+    address = "0x0000000000000000000000000000000000000001"
+    with pytest.raises(ValueError) as excinfo:
+        TreasuryWallet(address, end_block=1, end_timestamp=1234567890)
+    assert "You can only pass an end block or an end timestamp" in str(excinfo.value)
+
+def test_conflicting_start_timestamp_and_end_block():
+    address = "0x0000000000000000000000000000000000000001"
+    with pytest.raises(ValueError) as excinfo:
+        TreasuryWallet(address, end_block=1, end_timestamp=1234567890)
+    assert "You can only pass an end block or an end timestamp" in str(excinfo.value)
+"""
+
+
+@pytest.mark.parametrize(
+    "wallet_address, other, expected, id",
+    [
+        # Happy path: same address, both as hex strings
+        (
+            "0x000000000000000000000000000000000000dead",
+            "0x000000000000000000000000000000000000dead",
+            True,
+            "same_hex_string",
+        ),
+        # Happy path: same address, other as checksummed
+        (
+            "0x000000000000000000000000000000000000dEaD",
+            "0x000000000000000000000000000000000000dead",
+            True,
+            "same_mixed_case",
+        ),
+        # Happy path: different addresses
+        (
+            "0x000000000000000000000000000000000000dead",
+            "0x000000000000000000000000000000000000beef",
+            False,
+            "different_addresses",
+        ),
+        # Edge: other is already a bytes address
+        (
+            "0x000000000000000000000000000000000000dead",
+            bytes.fromhex("000000000000000000000000000000000000dead"),
+            TypeError,
+            "other_bytes",
+        ),
+        # Edge: wallet address is checksummed, other is lower
+        (
+            "0x000000000000000000000000000000000000dEaD",
+            "0x000000000000000000000000000000000000dead",
+            True,
+            "wallet_checksummed",
+        ),
+        # Edge: wallet address is lower, other is checksummed
+        (
+            "0x000000000000000000000000000000000000dead",
+            "0x000000000000000000000000000000000000dEaD",
+            True,
+            "other_checksummed",
+        ),
+        # Edge: other is an int (invalid, should raise)
+        ("0x000000000000000000000000000000000000dead", 12345, TypeError, "other_int"),
+        # Edge: other is None (invalid, should raise)
+        ("0x000000000000000000000000000000000000dead", None, TypeError, "other_none"),
+        # Edge: wallet address is invalid (should raise on instantiation)
+        (
+            "not_an_address",
+            "0x000000000000000000000000000000000000dead",
+            ValueError,
+            "wallet_invalid",
+        ),
+        # Edge: other is invalid address string (should raise)
+        (
+            "0x000000000000000000000000000000000000dead",
+            "not_an_address",
+            TypeError,
+            "other_invalid",
+        ),
+    ],
+    ids=lambda x: x if isinstance(x, str) else None,
+)
+def test_wallet_eq(wallet_address, other, expected, id):
+    # sourcery skip: no-conditionals-in-tests
+    try:
+        exc_expected = issubclass(expected, Exception)
+    except TypeError:
+        exc_expected = False
+
+    if exc_expected:
+        with pytest.raises(expected):
+            wallet = TreasuryWallet(address=wallet_address)
+            _ = wallet.address == other
+
+    else:
+        wallet = TreasuryWallet(address=wallet_address)
+        result = wallet.address == other
+
+        # Assert
+        assert result is expected
+
+
+# We cannot mock closest_block_after_timestamp, so we must use real values.
+# closest_block_after_timestamp will be called with the provided timestamp.
+# For edge cases, we can use 0 or very large/small timestamps.
+
+
+@pytest.mark.parametrize(
+    "start_block, start_timestamp, expected, id",
+    [
+        # Happy path: start_block is set
+        (12345, None, 12345, "start_block_set"),
+        # Happy path: start_block is None, start_timestamp is set (use a realistic timestamp)
+        (None, 1700000000, None, "start_timestamp_set"),
+        # Edge: both start_block and start_timestamp are None
+        (None, None, 0, "both_none"),
+        # Edge: start_block is 0
+        (0, None, 0, "start_block_zero"),
+        # Edge: start_timestamp is 0
+        (None, 0, None, "start_timestamp_zero"),
+    ],
+    ids=lambda x: x if isinstance(x, str) else None,
+)
+def test_start_block_property(start_block, start_timestamp, expected, id):
+    # Arrange
+    # Use a valid EthAddress string (20 bytes hex)
+    address = "0x000000000000000000000000000000000000dead"
+    wallet = TreasuryWallet(
+        address=address,
+        start_block=start_block,
+        start_timestamp=start_timestamp,
+    )
+
+    # Act
+    result = wallet._start_block
+
+    # Assert
+    if start_block is not None:
+        assert result == expected
+    elif start_timestamp is not None:
+        # We can't know the exact block, but it should be an int and >= 0
+        assert isinstance(result, int)
+        # For negative timestamps, the block may be negative, but for 0 or positive, should be >= 0
+        if start_timestamp >= 0:
+            assert result >= 0
+    else:
+        assert result == 0
+
+
+@pytest.mark.parametrize(
+    "start_block, start_timestamp, expected_exception, id",
+    [
+        # Error: both start_block and start_timestamp are set
+        (123, 456, ValueError, "both_start_block_and_start_timestamp"),
+        # Error: start_block is not an int (e.g., string)
+        ("not_a_block", None, TypeError, "start_block_invalid_type"),
+        # Error: start_timestamp is not an int (e.g., string)
+        (None, "not_a_timestamp", TypeError, "start_timestamp_invalid_type"),
+        # Error: both are invalid
+        ("not_a_block", "not_a_timestamp", TypeError, "both_invalid"),
+        # Error: start_block is negative
+        (-1, None, ValueError, "start_block_negative"),
+        # Error: start_timestamp is negative
+        (None, -100, ValueError, "start_timestamp_negative"),
+    ],
+    ids=lambda x: x if isinstance(x, str) else None,
+)
+def test_start_block_property_errors(
+    start_block, start_timestamp, expected_exception, id
+):
+    # Arrange
+    address = "0x000000000000000000000000000000000000dead"
+
+    # Act & Assert
+    with pytest.raises(expected_exception):
+        TreasuryWallet(
+            address=address,
+            start_block=start_block,
+            start_timestamp=start_timestamp,
+        )._start_block
+
+
+@pytest.mark.parametrize(
+    "end_block, end_timestamp, expected, id",
+    [
+        # Happy path: end_block is set
+        (123456, None, 123456, "end_block_set"),
+        # Happy path: end_block is None, end_timestamp is set (realistic timestamp)
+        (None, 1700000000, None, "end_timestamp_set"),
+        # Edge: both end_block and end_timestamp are None
+        (None, None, None, "both_none"),
+        # Edge: end_block is 0
+        (0, None, 0, "end_block_zero"),
+        # Edge: end_timestamp is 0
+        (None, 0, None, "end_timestamp_zero"),
+    ],
+    ids=lambda x: x if isinstance(x, str) else None,
+)
+def test_end_block_property(end_block, end_timestamp, expected, id):
+    # Arrange
+    address = "0x000000000000000000000000000000000000dead"
+    wallet = TreasuryWallet(
+        address=address,
+        end_block=end_block,
+        end_timestamp=end_timestamp,
+    )
+
+    # Act
+    result = wallet._end_block
+
+    # Assert
+    if end_block is not None:
+        assert result == expected
+    elif end_timestamp is not None:
+        # We can't know the exact block, but it should be an int and >= 0
+        assert isinstance(result, int), (type(result), result)
+        if end_timestamp >= 0:
+            assert result >= 0
+    else:
+        assert result is None
+
+
+@pytest.mark.parametrize(
+    "end_block, end_timestamp, expected_exception, id",
+    [
+        # Error: both end_block and end_timestamp are set
+        (123, 456, ValueError, "both_end_block_and_end_timestamp"),
+        # Error: end_block is not an int (e.g., string)
+        ("not_a_block", None, TypeError, "end_block_invalid_type"),
+        # Error: end_timestamp is not an int (e.g., string)
+        (None, "not_a_timestamp", TypeError, "end_timestamp_invalid_type"),
+        # Error: both are invalid
+        ("not_a_block", "not_a_timestamp", ValueError, "both_invalid"),
+        # Edge: end_block is negative
+        (-1, None, ValueError, "end_block_negative"),
+        # Edge: end_timestamp is negative
+        (None, -100, ValueError, "end_timestamp_negative"),
+    ],
+    ids=lambda x: x if isinstance(x, str) else None,
+)
+def test_end_block_property_errors(end_block, end_timestamp, expected_exception, id):
+    # Arrange
+    address = "0x000000000000000000000000000000000000dead"
+
+    # Act & Assert
+    with pytest.raises(expected_exception):
+        TreasuryWallet(
+            address=address,
+            end_block=end_block,
+            end_timestamp=end_timestamp,
+        )._end_block

dao_treasury-0.0.44/dao_treasury.egg-info/requires.txt

@@ -1 +0,0 @@
-eth-portfolio-temp<0.2,>=0.1.6.dev0