feat: replace SLSQP solver with MILP (cvxpy+HiGHS) and add fractional asset support

- Rewrite rebalancing_helper.py: drop scipy, use cvxpy MILP with HiGHS backend
  - Objective: L1 norm on dollar deviations from target (MILP-compatible)
  - Per-asset integer or continuous variables based on 'fractional' flag
  - Fix selling_allowed delta-units bug (absolute → delta conversion)
- Add 'fractional: bool = False' field to Asset, AssetConfig, loader
  - Fractional assets use continuous cp.Variable(); others integer-constrained
  - Mutual funds (0P*.ST tickers) marked fractional in portfolio JSONs
- Update schemas.py: float quantity field, integer validator for non-fractional
- portfolio.py: fractional-aware display, rename abbreviations for clarity
- Bump to v0.4.0, replace scipy with cvxpy>=1.8.2 in dependencies
- Add tests: mixed-fractional unit tests, solver validation integration tests

Author: kallegrens

pyproject.toml

@@ -13,7 +13,7 @@ authors = [{ name = "Karl Lundgren", email = "k.github@lundgrens.net" }]
 dependencies = [
     "numpy>=1.26.1",
     "requests>=2.31.0",
-    "scipy>=1.11.3",
+    "cvxpy>=1.8.2",
     "yfinance>=0.2.65",
     "pydantic>=2.0",
     "rich>=13.0",
@@ -38,7 +38,7 @@ select = ["E", "F", "I", "B", "UP"]
 ignore = ["E501"]
 
 [tool.ty.analysis]
-allowed-unresolved-imports = ["scipy", "yfinance"]
+allowed-unresolved-imports = ["cvxpy", "yfinance"]
 
 [tool.pytest.ini_options]
 testpaths = ["rebalance/tests"]

rebalance/asset.py

@@ -19,26 +19,35 @@ def __init__(
         nasdaq_nordic_id=None,
         nasdaq_nordic_asset_class=None,
         name=None,
+        fractional=False,
     ):
         """
         Initialization.
 
         Args
         ----
         - ticker (str): Ticker of the asset.
-        - quantity (int, optional): Number of units of the asset. Default is zero.
+        - quantity (int or float, optional): Number of units of the asset. Must be an
+          integer when ``fractional=False`` (the default). Default is zero.
         - session (optional): Requests session passed to the Nasdaq Nordic
             fetcher. Not used for yfinance (which manages its own session).
         - nasdaq_nordic_id (str, optional): Nasdaq Nordic instrument ID (e.g. "TX4856348"). If provided, price is fetched from the Nasdaq Nordic API.
         - nasdaq_nordic_asset_class (str, optional): Asset class for Nasdaq Nordic API (e.g. "ETN/ETC", "ETF", "Share"). Required when nasdaq_nordic_id is set.
         - name (str, optional): Human-readable name of the asset. Default is None.
+        - fractional (bool, optional): When True, the asset supports fractional units
+          (e.g. mutual funds). Default is False.
         """
 
         assert ticker is not None, "ticker symbol is a mandatory argument."
-        assert isinstance(quantity, int), "quantity must be integer."
+        assert isinstance(quantity, (int, float)), "quantity must be numeric."
+        if not fractional:
+            assert quantity == int(quantity), (
+                "quantity must be integer for non-fractional assets."
+            )
 
         self._ticker = ticker
-        self._quantity = quantity
+        self._quantity = float(quantity)
+        self._fractional = fractional
         self._name = name
 
         if nasdaq_nordic_id is not None:
@@ -62,15 +71,24 @@ def name(self):
         """(str | None): Human-readable name of the asset."""
         return self._name
 
+    @property
+    def fractional(self):
+        """(bool): Whether this asset supports fractional units."""
+        return self._fractional
+
     @property
     def quantity(self):
-        """(int): Number of units of the asset."""
+        """(int | float): Number of units of the asset."""
         return self._quantity
 
     @quantity.setter
     def quantity(self, quantity):
-        assert isinstance(quantity, int), "quantity must be integer."
-        self._quantity = quantity
+        assert isinstance(quantity, (int, float)), "quantity must be numeric."
+        if not self._fractional:
+            assert quantity == int(quantity), (
+                "quantity must be integer for non-fractional assets."
+            )
+        self._quantity = float(quantity)
 
     @property
     def price(self):
@@ -163,4 +181,7 @@ def mer(self):
     def __str__(self):
         # return yf.Ticker(
         #     self._ticker).info['shortName'] + " (" + self._ticker + ")"
-        return f"{self._ticker:4s}  {self._quantity:4d} {self.market_value():8.2f}"
+        qty = (
+            f"{self._quantity:.3f}" if self._fractional else f"{int(self._quantity):4d}"
+        )
+        return f"{self._ticker:4s}  {qty} {self.market_value():8.2f}"

rebalance/loader.py

@@ -25,7 +25,7 @@ def _make_session() -> requests.Session:
 
 
 def _build_asset(asset_config, session: requests.Session) -> Asset:
-    kwargs: dict = {"session": session}
+    kwargs: dict = {"session": session, "fractional": asset_config.fractional}
     if asset_config.nasdaq_nordic_id is not None:
         kwargs["nasdaq_nordic_id"] = asset_config.nasdaq_nordic_id
         kwargs["nasdaq_nordic_asset_class"] = asset_config.nasdaq_nordic_asset_class

rebalance/portfolio.py

@@ -173,11 +173,11 @@ def market_value(self, currency):
             float: The total market value of the assets in the portfolio.
         """
 
-        mv = 0.0
+        total = 0.0
         for asset in self.assets.values():
-            mv += asset.market_value_in(currency)
+            total += asset.market_value_in(currency)
 
-        return mv
+        return total
 
     def cash_value(self, currency):
         """
@@ -190,11 +190,11 @@ def cash_value(self, currency):
             float: The total cash value in the portfolio.
         """
 
-        cv = 0.0
+        total = 0.0
         for cash in self.cash.values():
-            cv += cash.amount_in(currency)
+            total += cash.amount_in(currency)
 
-        return cv
+        return total
 
     def value(self, currency):
         """
@@ -315,15 +315,17 @@ def rebalance(self, target_allocation, verbose=False):
 
         # offload heavy work
         (balanced_portfolio, new_units, prices, cost, exchange_history) = (
-            rebalancing_helper.rebalance(self, target_allocation_np)
+            rebalancing_helper.rebalance(self, target_allocation_reordered)
         )
 
         # compute old and new asset allocation
         # and largest diff between new and target asset allocation
-        old_alloc = self.asset_allocation()
-        new_alloc = balanced_portfolio.asset_allocation()
-        max_diff = max(
-            abs(target_allocation_np - np.fromiter(new_alloc.values(), dtype=float))
+        old_allocation = self.asset_allocation()
+        new_allocation = balanced_portfolio.asset_allocation()
+        largest_discrepancy = max(
+            abs(
+                target_allocation_np - np.fromiter(new_allocation.values(), dtype=float)
+            )
         )
 
         if verbose:
@@ -352,17 +354,18 @@ def rebalance(self, target_allocation, verbose=False):
 
                 qty = new_units[ticker]
                 amt = cost[ticker]
+                qty_fmt = f"{qty:,d}" if isinstance(qty, int) else f"{qty:,.3f}"
                 if qty > 0:
-                    qty_str = f"[green]{qty:,d}[/green]"
+                    qty_str = f"[green]{qty_fmt}[/green]"
                     amt_str = f"[green]{amt:,.0f}[/green]"
                 elif qty < 0:
-                    qty_str = f"[red]{qty:,d}[/red]"
+                    qty_str = f"[red]{qty_fmt}[/red]"
                     amt_str = f"[red]{amt:,.0f}[/red]"
                 else:
-                    qty_str = f"[dim]{qty:,d}[/dim]"
+                    qty_str = f"[dim]{qty_fmt}[/dim]"
                     amt_str = f"[dim]{amt:,.0f}[/dim]"
 
-                new_a = new_alloc[ticker]
+                new_a = new_allocation[ticker]
                 tgt_a = target_allocation[ticker]
                 new_alloc_str = (
                     f"[yellow]{new_a:.2f}[/yellow]"
@@ -381,7 +384,7 @@ def rebalance(self, target_allocation, verbose=False):
                     qty_str,
                     amt_str,
                     prices[ticker][1],
-                    f"{old_alloc[ticker]:.2f}",
+                    f"{old_allocation[ticker]:.2f}",
                     new_alloc_str,
                     f"{tgt_a:.2f}",
                 ]
@@ -390,7 +393,7 @@ def rebalance(self, target_allocation, verbose=False):
             _console.print()
             _console.print(table)
             _console.print(
-                f"Largest discrepancy between new and target allocation: [bold]{max_diff:.2f}%[/bold]"
+                f"Largest discrepancy between new and target allocation: [bold]{largest_discrepancy:.2f}%[/bold]"
             )
 
             if exchange_history:
@@ -418,9 +421,11 @@ def rebalance(self, target_allocation, verbose=False):
 
         # Now that we're done, we can replace old portfolio with the new one
         self.__dict__.update(balanced_portfolio.__dict__)
-        logger.info("Rebalancing complete (largest discrepancy: {:.2f}%)", max_diff)
+        logger.info(
+            "Rebalancing complete (largest discrepancy: {:.2f}%)", largest_discrepancy
+        )
 
-        return (new_units, prices, exchange_history, max_diff)
+        return (new_units, prices, exchange_history, largest_discrepancy)
 
     def _sell_everything(self):
         """
@@ -472,27 +477,27 @@ def _smart_exchange(self, currency_amount):
 
         # first, compute amount we have to convert to and amount we have for conversion
 
-        to_conv = {}
-        from_conv = copy.deepcopy(self.cash)
-        for curr in currency_amount:
-            if curr not in self.cash:
-                from_conv[curr] = Cash(0.00, curr)
+        to_fund = {}
+        available = copy.deepcopy(self.cash)
+        for currency in currency_amount:
+            if currency not in self.cash:
+                available[currency] = Cash(0.00, currency)
 
-            to = currency_amount[curr] - from_conv[curr].amount
+            shortfall = currency_amount[currency] - available[currency].amount
 
-            if to > 0:
-                to_conv[curr] = Cash(to, curr)
-                del from_conv[curr]  # no extra cash available for conversion
+            if shortfall > 0:
+                to_fund[currency] = Cash(shortfall, currency)
+                del available[currency]  # no extra cash available for conversion
             else:
                 # no conversion will be necessary
-                from_conv[curr].amount -= currency_amount[curr]
+                available[currency].amount -= currency_amount[currency]
 
         # perform currency exchange
         exchange_history = []
-        for to_cash in to_conv.values():
-            one_exchange = False
+        for to_cash in to_fund.values():
+            single_source_sufficient = False
             # Try converting one shot if possible
-            for from_cash in from_conv.values():
+            for from_cash in available.values():
                 if from_cash.amount_in(to_cash.currency) >= to_cash.amount:
                     # perform conversion
                     self.exchange_currency(
@@ -519,14 +524,14 @@ def _smart_exchange(self, currency_amount):
                     to_cash.amount = 0.00
 
                     # move to next 'to_cash'
-                    one_exchange = True
+                    single_source_sufficient = True
                     break
 
             # If we reached here,
             # it means we couldn't perform one currency exchange to meet our 'to_cash'
             # So we'll just convert whatever we can
-            if not one_exchange:
-                for from_cash in from_conv.values():
+            if not single_source_sufficient:
+                for from_cash in available.values():
                     if from_cash.amount_in(to_cash.currency) >= to_cash.amount:
                         # perform conversion
                         self.exchange_currency(