mm-balance 0.5.1__tar.gz → 0.6.0__tar.gz

mm_balance-0.6.0/.claude/settings.local.json

@@ -0,0 +1,12 @@
+{
+  "permissions": {
+    "allow": [
+      "mcp__ide__getDiagnostics",
+      "Bash(uv run pytest:*)",
+      "Bash(just lint)",
+      "Bash(uv run ruff check:*)"
+    ],
+    "deny": [],
+    "ask": []
+  }
+}

{mm_balance-0.5.1 → mm_balance-0.6.0}/.gitignore

@@ -13,3 +13,4 @@ pip-wheel-metadata
 /build
 /tmp
 .DS_Store
+requirements.txt

mm_balance-0.6.0/CLAUDE.md

@@ -0,0 +1,13 @@
+# Claude Guidelines
+
+## Critical Guidelines
+
+1. **Always communicate in English** - Regardless of the language the user speaks, always respond in English. All code, comments, and documentation must be in English.
+
+2. **Minimal documentation** - Only add comments/documentation when it simplifies understanding and isn't obvious from the code itself. Keep it strictly relevant and concise.
+
+3. **Critical thinking** - Always critically evaluate user ideas. Users can make mistakes. Think first about whether the user's idea is good before implementing.
+
+4. **Lint after changes** - After making code changes, always run `just lint` to verify code quality and fix any linter issues.
+
+5. **No disabling linter rules** - Never use special disabling comments (like `# noqa`, `# type: ignore`, `# ruff: noqa`, etc.) to turn off linter rules without explicit permission. If you believe a rule should be disabled, ask first.

mm_balance-0.6.0/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: mm-balance
+Version: 0.6.0
+Requires-Python: >=3.13
+Requires-Dist: deepdiff==8.6.1
+Requires-Dist: mm-apt==0.5.0
+Requires-Dist: mm-btc==0.5.5
+Requires-Dist: mm-concurrency~=0.1.0
+Requires-Dist: mm-eth==0.7.3
+Requires-Dist: mm-sol==0.7.3

{mm_balance-0.5.1 → mm_balance-0.6.0}/justfile

@@ -21,7 +21,7 @@ lint: format
 
 audit:
     uv export --no-dev --all-extras --format requirements-txt --no-emit-project > requirements.txt
-    uv run pip-audit -r requirements.txt --disable-pip
+    uv run pip-audit -r requirements.txt --disable-pip --ignore-vuln GHSA-wj6h-64fc-37mp
     rm requirements.txt
     uv run bandit --silent --recursive --configfile "pyproject.toml" src
 

{mm_balance-0.5.1 → mm_balance-0.6.0}/pyproject.toml

@@ -1,15 +1,15 @@
 [project]
 name = "mm-balance"
-version = "0.5.1"
+version = "0.6.0"
 description = ""
 requires-python = ">=3.13"
 dependencies = [
     "mm-concurrency~=0.1.0",
-    "mm-apt==0.4.2",
-    "mm-btc==0.5.3",
-    "mm-eth==0.7.1",
-    "mm-sol==0.7.1",
-    "deepdiff==8.5.0",
+    "mm-apt==0.5.0",
+    "mm-btc==0.5.5",
+    "mm-eth==0.7.3",
+    "mm-sol==0.7.3",
+    "deepdiff==8.6.1",
 ]
 [project.scripts]
 mm-balance = "mm_balance.cli:app"
@@ -18,14 +18,14 @@ mm-balance = "mm_balance.cli:app"
 requires = ["hatchling"]
 build-backend = "hatchling.build"
 
-[tool.uv]
-dev-dependencies = [
-    "pytest~=8.4.0",
-    "pytest-xdist~=3.7.0",
-    "ruff~=0.11.13",
+[dependency-groups]
+dev = [
+    "pytest~=8.4.2",
+    "pytest-xdist~=3.8.0",
+    "ruff~=0.14.2",
     "pip-audit~=2.9.0",
-    "bandit~=1.8.3",
-    "mypy~=1.16.0",
+    "bandit~=1.8.6",
+    "mypy~=1.18.2",
 ]
 
 [tool.mypy]

{mm_balance-0.5.1 → mm_balance-0.6.0}/src/mm_balance/cli.py

@@ -25,8 +25,8 @@ def example_callback(value: bool) -> None:
     if value:
         data = pkgutil.get_data(__name__, "config/example.toml")
         if data is None:
-            mm_print.fatal("Example config not found")
-        mm_print.toml(toml=data.decode("utf-8"))
+            mm_print.exit_with_error("Example config not found")
+        mm_print.toml(data.decode("utf-8"))
         raise typer.Exit
 
 

{mm_balance-0.5.1 → mm_balance-0.6.0}/src/mm_balance/command_runner.py

@@ -63,7 +63,7 @@ async def run(params: CommandParameters) -> None:
     elif config.settings.print_format is PrintFormat.JSON:
         json_format.print_result(config, token_decimals, prices, workers, result)
     else:
-        mm_print.fatal("Unsupported print format")
+        mm_print.exit_with_error("Unsupported print format")
 
     if params.save_balances:
         BalancesDict.from_balances_result(result).save_to_path(params.save_balances)

{mm_balance-0.5.1 → mm_balance-0.6.0}/src/mm_balance/config/example.toml

@@ -17,7 +17,7 @@ addresses = """
 bc1qgdjqv0av3q56jvd82tkdjpy7gdp9ut8tlqmgrpmv24sq90ecnvqqjwvw97 # bitfinex
 bc1ql49ydapnjafl5t2cp9zqpjwe6pdgmxy98859v2 # robinhood
 """
-share = 0.1
+share = "0.5(total - 100.5)"  # or: "total - 1000", "0.3total + 50", etc.
 
 [[coins]]
 ticker = "ETH"

{mm_balance-0.5.1 → mm_balance-0.6.0}/src/mm_balance/config.py

@@ -10,7 +10,7 @@ from mm_web3 import ConfigValidators, Web3CliConfig
 from pydantic import BeforeValidator, Field, StringConstraints, model_validator
 
 from mm_balance.constants import DEFAULT_NODES, TOKEN_ADDRESS, Network
-from mm_balance.utils import PrintFormat
+from mm_balance.utils import PrintFormat, evaluate_share_expression
 
 
 class Validators(ConfigValidators):
@@ -32,7 +32,7 @@ class AssetGroup(Web3CliConfig):
     decimals: int | None = None
     coingecko_id: str | None = None
     addresses: Annotated[list[str], BeforeValidator(Validators.addresses(deduplicate=True))]
-    share: Decimal = Decimal(1)
+    share: str = "total"
 
     @property
     def name(self) -> str:
@@ -42,6 +42,10 @@ class AssetGroup(Web3CliConfig):
         result += " / " + self.network
         return result
 
+    def evaluate_share(self, balance_sum: Decimal) -> Decimal:
+        """Evaluate share expression with actual balance_sum value."""
+        return evaluate_share_expression(self.share, balance_sum)
+
     @model_validator(mode="after")
     def final_validator(self) -> Self:
         if self.token is None:
@@ -58,7 +62,7 @@ class AssetGroup(Web3CliConfig):
                 if path.is_file():
                     result += path.read_text().strip().splitlines()
                 else:
-                    mm_print.fatal(f"File with addresses not found: {path}")
+                    mm_print.exit_with_error(f"File with addresses not found: {path}")
             elif line.startswith("group:"):
                 group_name = line.removeprefix("group:").strip()
                 address_group = next((ag for ag in address_groups if ag.name == group_name), None)
@@ -96,7 +100,7 @@ class Config(Web3CliConfig):
     settings: Settings = Field(default_factory=Settings)  # type: ignore[arg-type]
 
     def has_share(self) -> bool:
-        return any(g.share != Decimal(1) for g in self.groups)
+        return any(g.share != "total" for g in self.groups)
 
     def networks(self) -> list[Network]:
         return pydash.uniq([group.network for group in self.groups])

{mm_balance-0.5.1 → mm_balance-0.6.0}/src/mm_balance/diff.py

@@ -97,7 +97,7 @@ class Diff(BaseModel):
                     for address in self.balance_changed[network][ticker]:
                         old_value, new_value = self.balance_changed[network][ticker][address]
                         rows.append([network, ticker, address, old_value, new_value, new_value - old_value])
-            mm_print.table("", ["Network", "Ticker", "Address", "Old", "New", "Change"], rows)
+            mm_print.table(["Network", "Ticker", "Address", "Old", "New", "Change"], rows)
 
     def _print_json(self) -> None:
         # mm_print.json(data=self.model_dump(), type_handlers=str) ?? default?

{mm_balance-0.5.1 → mm_balance-0.6.0}/src/mm_balance/output/formats/table_format.py

@@ -14,18 +14,18 @@ def print_nodes(config: Config) -> None:
     rows = []
     for network, nodes in config.nodes.items():
         rows.append([network, "\n".join(nodes)])
-    mm_print.table("Nodes", ["network", "nodes"], rows)
+    mm_print.table(["network", "nodes"], rows, title="Nodes")
 
 
 def print_proxy_count(config: Config) -> None:
-    mm_print.table("Proxies", ["count"], [[len(config.settings.proxies)]])
+    mm_print.table(["count"], [[len(config.settings.proxies)]], title="Proxies")
 
 
 def print_token_decimals(token_decimals: TokenDecimals) -> None:
     rows = []
     for network, decimals in token_decimals.items():
         rows.append([network, decimals])
-    mm_print.table("Token Decimals", ["network", "decimals"], rows)
+    mm_print.table(["network", "decimals"], rows, title="Token Decimals")
 
 
 def print_prices(config: Config, prices: Prices) -> None:
@@ -35,7 +35,7 @@ def print_prices(config: Config, prices: Prices) -> None:
             rows.append(
                 [ticker, format_number(price, config.settings.format_number_separator, "$", config.settings.round_ndigits)]
             )
-        mm_print.table("Prices", ["coin", "usd"], rows)
+        mm_print.table(["coin", "usd"], rows, title="Prices")
 
 
 def print_result(config: Config, result: BalancesResult, workers: BalanceFetcher) -> None:
@@ -57,7 +57,7 @@ def _print_errors(config: Config, workers: BalanceFetcher) -> None:
     for task in error_tasks:
         group = config.groups[task.group_index]
         rows.append([group.ticker + " / " + group.network, task.wallet_address, task.balance.error])  # type: ignore[union-attr]
-    mm_print.table("Errors", ["coin", "address", "error"], rows)
+    mm_print.table(["coin", "address", "error"], rows, title="Errors")
 
 
 def _print_total(config: Config, total: Total, is_share_total: bool) -> None:
@@ -80,7 +80,7 @@ def _print_total(config: Config, total: Total, is_share_total: bool) -> None:
             rows.append(["stablecoin_sum", format_number(total.stablecoin_sum, config.settings.format_number_separator, "$")])
         rows.append(["total_usd_sum", format_number(total.total_usd_sum, config.settings.format_number_separator, "$")])
 
-    mm_print.table(table_name, headers, rows)
+    mm_print.table(headers, rows, title=table_name)
 
 
 def _print_group(config: Config, group: GroupResult) -> None:
@@ -108,7 +108,7 @@ def _print_group(config: Config, group: GroupResult) -> None:
         sum_row.append(format_number(group.usd_sum, config.settings.format_number_separator, "$"))
     rows.append(sum_row)
 
-    if group.share < Decimal(1):
+    if group.share != "total":
         sum_share_str = format_number(group.balance_sum_share, config.settings.format_number_separator)
         sum_share_row = [f"sum_share, {group.share}", sum_share_str]
         if config.settings.price:
@@ -118,4 +118,4 @@ def _print_group(config: Config, group: GroupResult) -> None:
     table_headers = ["address", "balance"]
     if config.settings.price:
         table_headers += ["usd"]
-    mm_print.table(group_name, table_headers, rows)
+    mm_print.table(table_headers, rows, title=group_name)

{mm_balance-0.5.1 → mm_balance-0.6.0}/src/mm_balance/price.py

@@ -34,7 +34,7 @@ async def get_prices(config: Config) -> Prices:
         if res.status_code != 200:
             continue
 
-        json_body = res.parse_json_body() or {}
+        json_body = res.parse_json()
 
         for ticker, coingecko_id in coingecko_map.items():
             if coingecko_id in json_body:

{mm_balance-0.5.1 → mm_balance-0.6.0}/src/mm_balance/result.py

@@ -26,12 +26,12 @@ class GroupResult:
     ticker: str
     network: Network
     comment: str
-    share: Decimal
+    share: str
     addresses: list[AddressBalance]
     balance_sum: Decimal  # sum of all balances in the group
     usd_sum: Decimal  # sum of all usd values in the group
-    balance_sum_share: Decimal  # sum of all balances in the group multiplied by share
-    usd_sum_share: Decimal  # sum of all usd values in the group multiplied by share
+    balance_sum_share: Decimal  # calculated from share expression
+    usd_sum_share: Decimal  # proportional to balance_sum_share
 
 
 @dataclass
@@ -113,8 +113,8 @@ def _create_group_result(config: Config, group: AssetGroup, tasks: list[Task], p
             balance = task.balance.unwrap_err()
         addresses.append(AddressBalance(address=task.wallet_address, balance=balance))
 
-    balance_sum_share = balance_sum * group.share
-    usd_sum_share = usd_sum * group.share
+    balance_sum_share = group.evaluate_share(balance_sum)
+    usd_sum_share = usd_sum * (balance_sum_share / balance_sum) if balance_sum > 0 else Decimal(0)
 
     return GroupResult(
         ticker=group.ticker,

{mm_balance-0.5.1 → mm_balance-0.6.0}/src/mm_balance/token_decimals.py

@@ -30,7 +30,7 @@ async def get_token_decimals(config: Config) -> TokenDecimals:
             elif group.network in (NETWORK_BITCOIN, NETWORK_APTOS):
                 result[group.network][None] = 8
             else:
-                mm_print.fatal(f"Can't get token decimals for native token on network: {group.network}")
+                mm_print.exit_with_error(f"Can't get token decimals for native token on network: {group.network}")
             continue
 
         # get token_decimals via RPC
@@ -46,7 +46,7 @@ async def get_token_decimals(config: Config) -> TokenDecimals:
             msg = f"can't get decimals for token {group.ticker} / {group.token}, error={res.unwrap_err()}"
             if config.settings.print_debug:
                 msg += f"\n{res.extra}"
-            mm_print.fatal(msg)
+            mm_print.exit_with_error(msg)
 
         result[group.network][group.token] = res.unwrap()
 

mm_balance-0.6.0/src/mm_balance/utils.py

@@ -0,0 +1,163 @@
+import re
+from decimal import Decimal
+from enum import StrEnum, unique
+
+
+def fnumber(value: Decimal, separator: str, extra: str | None = None) -> str:
+    str_value = f"{value:,}".replace(",", separator)
+    if extra == "$":
+        return "$" + str_value
+    if extra == "%":
+        return str_value + "%"
+    return str_value
+
+
+def scale_and_round(value: int, decimals: int, round_ndigits: int) -> Decimal:
+    if value == 0:
+        return Decimal(0)
+    return round(Decimal(value / 10**decimals), round_ndigits)
+
+
+def round_decimal(value: Decimal, round_ndigits: int) -> Decimal:
+    if value == Decimal(0):
+        return Decimal(0)
+    return round(value, round_ndigits)
+
+
+class _ExpressionParser:
+    """Recursive descent parser for arithmetic expressions.
+
+    Parses expressions by reading left-to-right, respecting operator precedence:
+    1. Parentheses and unary +/- (highest)
+    2. Multiplication and division
+    3. Addition and subtraction (lowest)
+
+    Uses self.pos as a cursor tracking current position in the string.
+    """
+
+    def __init__(self, expr: str) -> None:
+        self.expr = expr.replace(" ", "")  # Expression string with spaces removed
+        self.pos = 0  # Current position/index in the string (starts at beginning)
+
+    def parse(self) -> Decimal:
+        result = self._parse_expression()
+        if self.pos < len(self.expr):
+            raise ValueError(f"Unexpected character at position {self.pos}: '{self.expr[self.pos]}'")
+        return result
+
+    def _parse_expression(self) -> Decimal:
+        """Parse addition and subtraction (lowest precedence)."""
+        result = self._parse_term()
+
+        while self.pos < len(self.expr):
+            if self._peek() == "+":
+                self.pos += 1
+                result = result + self._parse_term()
+            elif self._peek() == "-":
+                self.pos += 1
+                result = result - self._parse_term()
+            else:
+                break
+
+        return result
+
+    def _parse_term(self) -> Decimal:
+        """Parse multiplication and division (medium precedence)."""
+        result = self._parse_factor()
+
+        while self.pos < len(self.expr):
+            if self._peek() == "*":
+                self.pos += 1
+                result = result * self._parse_factor()
+            elif self._peek() == "/":
+                self.pos += 1
+                divisor = self._parse_factor()
+                if divisor == 0:
+                    raise ValueError("Division by zero")
+                result = result / divisor
+            else:
+                break
+
+        return result
+
+    def _parse_factor(self) -> Decimal:
+        """Parse unary +/-, numbers, and parentheses (highest precedence)."""
+        if self._peek() == "+":
+            self.pos += 1
+            return self._parse_factor()
+        if self._peek() == "-":
+            self.pos += 1
+            return -self._parse_factor()
+
+        if self._peek() == "(":
+            self.pos += 1
+            result = self._parse_expression()
+            if self._peek() != ")":
+                raise ValueError(f"Expected ')' at position {self.pos}")
+            self.pos += 1
+            return result
+
+        return self._parse_number()
+
+    def _parse_number(self) -> Decimal:
+        """Parse a numeric value.
+
+        Scans digits, optionally followed by a decimal point and more digits.
+        Advances self.pos past the entire number.
+        """
+        start = self.pos
+
+        # Scan integer part: consecutive digits
+        while self.pos < len(self.expr) and self.expr[self.pos].isdigit():
+            self.pos += 1
+
+        # If there's a decimal point, scan fractional part
+        if self.pos < len(self.expr) and self.expr[self.pos] == ".":
+            self.pos += 1
+            while self.pos < len(self.expr) and self.expr[self.pos].isdigit():
+                self.pos += 1
+
+        # Ensure we consumed at least one digit
+        if start == self.pos:
+            raise ValueError(f"Expected number at position {self.pos}")
+
+        # Extract the substring from start to current position
+        return Decimal(self.expr[start : self.pos])
+
+    def _peek(self) -> str | None:
+        """Peek at the current character without consuming it."""
+        if self.pos < len(self.expr):
+            return self.expr[self.pos]
+        return None
+
+
+def evaluate_share_expression(expression: str, balance_sum: Decimal) -> Decimal:
+    """Evaluate share expression with actual balance_sum value.
+
+    Supports expressions like:
+    - "total" -> full balance
+    - "0.5total" -> 50% of balance
+    - "0.5(total - 100)" -> 50% of (balance - 100)
+    - "total - 1000" -> balance minus 1000
+    """
+    if not re.match(r"^[0-9+\-*/.() total]+$", expression):
+        raise ValueError(f"Invalid share expression '{expression}': contains invalid characters")
+
+    # Insert * before ( when preceded by digit or )
+    expr = re.sub(r"(\d|\))\(", r"\1*(", expression)
+    # Insert * before 'total' when preceded by digit or )
+    expr = re.sub(r"(\d|\))total", r"\1*total", expr)
+    # Replace 'total' with actual value in parentheses
+    expr = expr.replace("total", f"({balance_sum})")
+    try:
+        parser = _ExpressionParser(expr)
+        return parser.parse()
+    except Exception as e:
+        raise ValueError(f"Invalid share expression '{expression}': {e}") from e
+
+
+@unique
+class PrintFormat(StrEnum):
+    PLAIN = "plain"
+    TABLE = "table"
+    JSON = "json"

mm_balance-0.6.0/tests/test_share_expression.py

@@ -0,0 +1,88 @@
+from decimal import Decimal
+
+import pytest
+
+from mm_balance.utils import evaluate_share_expression
+
+
+def test_total_expression():
+    """Test simple 'total' expression returns full balance."""
+    assert evaluate_share_expression("total", Decimal(100)) == Decimal(100)
+    assert evaluate_share_expression("total", Decimal("1234.56")) == Decimal("1234.56")
+    assert evaluate_share_expression("total", Decimal(0)) == Decimal(0)
+
+
+def test_percentage_expressions():
+    """Test percentage-style expressions with implicit multiplication."""
+    assert evaluate_share_expression("0.5total", Decimal(100)) == Decimal(50)
+    assert evaluate_share_expression("0.1total", Decimal(1000)) == Decimal(100)
+    assert evaluate_share_expression("0.25total", Decimal(200)) == Decimal(50)
+
+
+def test_subtraction_expressions():
+    """Test expressions with subtraction."""
+    assert evaluate_share_expression("total - 100", Decimal(500)) == Decimal(400)
+    assert evaluate_share_expression("total - 50.5", Decimal(200)) == Decimal("149.5")
+    assert evaluate_share_expression("0.5total - 100", Decimal(1000)) == Decimal(400)
+
+
+def test_parentheses_expressions():
+    """Test expressions with parentheses and implicit multiplication."""
+    assert evaluate_share_expression("0.5(total - 100)", Decimal(500)) == Decimal(200)
+    assert evaluate_share_expression("0.5(total - 50.44)", Decimal(200)) == Decimal("74.78")
+    assert evaluate_share_expression("(total - 1000)", Decimal(5000)) == Decimal(4000)
+
+
+def test_addition_expressions():
+    """Test expressions with addition."""
+    assert evaluate_share_expression("total + 100", Decimal(500)) == Decimal(600)
+    assert evaluate_share_expression("0.3total + 50", Decimal(100)) == Decimal(80)
+
+
+def test_complex_expressions():
+    """Test more complex mathematical expressions."""
+    assert evaluate_share_expression("(total - 100) * 0.5", Decimal(500)) == Decimal(200)
+    assert evaluate_share_expression("total / 2", Decimal(100)) == Decimal(50)
+    assert evaluate_share_expression("2(total - 50)", Decimal(100)) == Decimal(100)
+
+
+def test_nested_parentheses():
+    """Test expressions with nested parentheses."""
+    assert evaluate_share_expression("0.5((total - 100) + 50)", Decimal(500)) == Decimal(225)
+
+
+def test_zero_balance():
+    """Test expressions with zero balance."""
+    assert evaluate_share_expression("total", Decimal(0)) == Decimal(0)
+    assert evaluate_share_expression("0.5total", Decimal(0)) == Decimal(0)
+    assert evaluate_share_expression("total - 100", Decimal(0)) == Decimal(-100)
+
+
+def test_negative_results():
+    """Test expressions that result in negative values."""
+    assert evaluate_share_expression("total - 1000", Decimal(500)) == Decimal(-500)
+    assert evaluate_share_expression("0.5total - 100", Decimal(100)) == Decimal(-50)
+
+
+def test_invalid_characters():
+    """Test that invalid characters are rejected."""
+    with pytest.raises(ValueError, match="invalid characters"):
+        evaluate_share_expression("total; import os", Decimal(100))
+
+    with pytest.raises(ValueError, match="invalid characters"):
+        evaluate_share_expression("__import__('os')", Decimal(100))
+
+    with pytest.raises(ValueError, match="invalid characters"):
+        evaluate_share_expression("total & 1", Decimal(100))
+
+
+def test_invalid_syntax():
+    """Test that invalid syntax is rejected."""
+    with pytest.raises(ValueError, match="Invalid share expression"):
+        evaluate_share_expression("total +", Decimal(100))
+
+    with pytest.raises(ValueError, match="Invalid share expression"):
+        evaluate_share_expression("(total", Decimal(100))
+
+    with pytest.raises(ValueError, match="Invalid share expression"):
+        evaluate_share_expression("total total", Decimal(100))