wbportfolio 1.52.5__tar.gz → 1.52.6__tar.gz

{wbportfolio-1.52.5 → wbportfolio-1.52.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wbportfolio
-Version: 1.52.5
+Version: 1.52.6
 Author-email: Christopher Wittlinger <c.wittlinger@stainly.com>
 License-File: LICENSE
 Requires-Dist: cryptography==3.4.*

{wbportfolio-1.52.5 → wbportfolio-1.52.6}/wbportfolio/models/asset.py

@@ -708,7 +708,7 @@ class AssetPosition(ImportMixin, models.Model):
             instrument_type=self.underlying_quote.security_instrument_type.id,
             currency=self.underlying_quote.currency.id,
             country=self.underlying_quote.country.id if self.underlying_quote.country else None,
-            is_cash=self.underlying_quote.is_cash,
+            is_cash=self.underlying_quote.is_cash or self.underlying_quote.is_cash_equivalent,
             primary_classification=(
                 self.underlying_quote.primary_classification.id
                 if self.underlying_quote.primary_classification

{wbportfolio-1.52.5 → wbportfolio-1.52.6}/wbportfolio/models/portfolio.py

@@ -926,7 +926,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
         if self.is_composition:
             assets = list(self.get_lookthrough_positions(val_date, **kwargs))
         else:
-            assets = self.assets.filter(date=val_date)
+            assets = list(self.assets.filter(date=val_date))
         return assets
 
     def compute_lookthrough(self, from_date: date, to_date: date | None = None):

{wbportfolio-1.52.5 → wbportfolio-1.52.6}/wbportfolio/models/transactions/trade_proposals.py

@@ -2,10 +2,9 @@ import logging
 from contextlib import suppress
 from datetime import date, timedelta
 from decimal import Decimal
-from typing import TypeVar
+from typing import Any, TypeVar
 
 from celery import shared_task
-from django.contrib.messages import error, info
 from django.core.exceptions import ValidationError
 from django.db import models
 from django.utils.functional import cached_property
@@ -92,14 +91,14 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
             )
         super().save(*args, **kwargs)
 
-    @property
-    def checked_object(self):
-        return self.portfolio
-
     @property
     def check_evaluation_date(self):
         return self.trade_date
 
+    @property
+    def checked_object(self) -> Any:
+        return self.portfolio
+
     @cached_property
     def portfolio_total_asset_value(self) -> Decimal:
         return self.portfolio.get_total_asset_value(self.last_effective_date)
@@ -109,10 +108,13 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
         """
         This property holds the validated trading services and cache it.This property expect to be set only if is_valid return True
         """
+        target_portfolio = self._build_dto().convert_to_portfolio()
+
         return TradingService(
             self.trade_date,
             effective_portfolio=self.portfolio._build_dto(self.last_effective_date),
-            target_portfolio=self._build_dto().convert_to_portfolio(),
+            target_portfolio=target_portfolio,
+            total_target_weight=target_portfolio.total_weight,
         )
 
     @cached_property
@@ -197,25 +199,30 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
 
         return trade_proposal_clone
 
-    def normalize_trades(self):
+    def normalize_trades(self, total_target_weight: Decimal = Decimal("1.0")):
         """
         Call the trading service with the existing trades and normalize them in order to obtain a total sum target weight of 100%
         The existing trade will be modified directly with the given normalization factor
         """
-        service = TradingService(self.trade_date, trades_batch=self._build_dto())
-        service.normalize()
+        service = TradingService(
+            self.trade_date,
+            effective_portfolio=self.portfolio._build_dto(self.last_effective_date),
+            target_portfolio=self._build_dto().convert_to_portfolio(),
+            total_target_weight=total_target_weight,
+        )
         leftovers_trades = self.trades.all()
-        total_target_weight = Decimal("0.0")
         for underlying_instrument_id, trade_dto in service.trades_batch.trades_map.items():
             with suppress(Trade.DoesNotExist):
                 trade = self.trades.get(underlying_instrument_id=underlying_instrument_id)
                 trade.weighting = round(trade_dto.delta_weight, 6)
                 trade.save()
-                total_target_weight += trade._target_weight
                 leftovers_trades = leftovers_trades.exclude(id=trade.id)
         leftovers_trades.delete()
+        t_weight = self.trades.all().annotate_base_info().aggregate(models.Sum("target_weight"))[
+            "target_weight__sum"
+        ] or Decimal("0.0")
         # we handle quantization error due to the decimal max digits. In that case, we take the biggest trade (highest weight) and we remove the quantization error
-        if quantize_error := (total_target_weight - Decimal("1.0")):
+        if quantize_error := (t_weight - total_target_weight):
             biggest_trade = self.trades.latest("weighting")
             biggest_trade.weighting -= quantize_error
             biggest_trade.save()
@@ -234,7 +241,12 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
         # Return the current portfolio by default
         return self.portfolio._build_dto(self.last_effective_date)
 
-    def reset_trades(self, target_portfolio: PortfolioDTO | None = None, validate_trade: bool = True):
+    def reset_trades(
+        self,
+        target_portfolio: PortfolioDTO | None = None,
+        validate_trade: bool = True,
+        total_target_weight: Decimal = Decimal("1.0"),
+    ):
         """
         Will delete all existing trades and recreate them from the method `create_or_update_trades`
         """
@@ -249,6 +261,7 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
                 self.trade_date,
                 effective_portfolio=effective_portfolio,
                 target_portfolio=target_portfolio,
+                total_target_weight=total_target_weight,
             )
             if validate_trade:
                 service.is_valid()
@@ -279,6 +292,11 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
                         status=Trade.Status.DRAFT,
                         currency_fx_rate=currency_fx_rate,
                     )
+                trade.price = trade.get_price()
+                # if we cannot automatically find a price, we consider the stock is invalid and we sell it
+                if trade.price is None:
+                    trade.price = Decimal("0.0")
+                    trade.weighting = -trade_dto.effective_weight
                 trade.save()
 
     def replay(self):
@@ -329,7 +347,7 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
                 last_trade_proposal_created = False
                 last_trade_proposal = next_trade_proposal
 
-    def get_estimated_shares(self, weight: Decimal, underlying_quote: Instrument) -> Decimal:
+    def get_estimated_shares(self, weight: Decimal, underlying_quote: Instrument, quote_price: Decimal) -> Decimal:
         """
         Estimates the number of shares for a trade based on the given weight and underlying quote.
 
@@ -342,23 +360,19 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
         Returns:
             Decimal | None: The estimated number of shares or None if the calculation fails.
         """
-        try:
-            # Retrieve the price of the underlying quote on the trade date TODO: this is very slow and probably due to the to_date argument to the dl which slowdown drastically the query
-            quote_price = Decimal(underlying_quote.get_price(self.trade_date))
+        # Retrieve the price of the underlying quote on the trade date TODO: this is very slow and probably due to the to_date argument to the dl which slowdown drastically the query
 
-            # Calculate the trade's total value in the portfolio's currency
-            trade_total_value_fx_portfolio = self.portfolio_total_asset_value * weight
+        # Calculate the trade's total value in the portfolio's currency
+        trade_total_value_fx_portfolio = self.portfolio_total_asset_value * weight
 
-            # Convert the quote price to the portfolio's currency
-            price_fx_portfolio = quote_price * underlying_quote.currency.convert(
-                self.trade_date, self.portfolio.currency, exact_lookup=False
-            )
+        # Convert the quote price to the portfolio's currency
+        price_fx_portfolio = quote_price * underlying_quote.currency.convert(
+            self.trade_date, self.portfolio.currency, exact_lookup=False
+        )
 
-            # If the price is valid, calculate and return the estimated shares
-            if price_fx_portfolio:
-                return trade_total_value_fx_portfolio / price_fx_portfolio
-        except Exception:
-            raise ValueError("We couldn't estimate the number of shares")
+        # If the price is valid, calculate and return the estimated shares
+        if price_fx_portfolio:
+            return trade_total_value_fx_portfolio / price_fx_portfolio
 
     def get_estimated_target_cash(self, currency: Currency) -> AssetPosition:
         """
@@ -399,7 +413,7 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
 
             # Estimate the target shares for the cash component
             with suppress(ValueError):
-                total_target_shares = self.get_estimated_shares(target_cash_weight, cash_component)
+                total_target_shares = self.get_estimated_shares(target_cash_weight, cash_component, Decimal("1.0"))
 
         cash_component = Cash.objects.get_or_create(
             currency=self.portfolio.currency, defaults={"name": self.portfolio.currency.title}
@@ -447,46 +461,23 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
         },
     )
     def submit(self, by=None, description=None, **kwargs):
-        self.reset_trades(target_portfolio=self._build_dto().convert_to_portfolio())
         trades = []
-        trades_validation_errors = []
+        trades_validation_warnings = []
         for trade in self.trades.all():
-            if not trade.last_underlying_quote_price:
-                trade.status = Trade.Status.FAILED
-                trades_validation_errors.append(
-                    f"Trade failed because no price is found for {trade.underlying_instrument.computed_str} on {trade.transaction_date:%Y-%m-%d}"
-                )
-            else:
-                trade.status = Trade.Status.SUBMIT
+            trade_warnings = trade.submit(by=by, description=description, **kwargs)
+            if trade_warnings:
+                trades_validation_warnings.extend(trade_warnings)
             trades.append(trade)
 
-        Trade.objects.bulk_update(trades, ["status"])
+        Trade.objects.bulk_update(trades, ["status", "shares", "weighting"])
 
         # If we estimate cash on this trade proposal, we make sure to create the corresponding cash component
         estimated_cash_position = self.get_estimated_target_cash(self.portfolio.currency)
-        target_portfolio = self.validated_trading_service.target_portfolio
-        if estimated_cash_position.weighting:
-            if existing_cash_position := target_portfolio.positions_map.get(
-                estimated_cash_position.underlying_quote.id
-            ):
-                existing_cash_position += estimated_cash_position
-            else:
-                target_portfolio.positions_map[estimated_cash_position.underlying_quote.id] = (
-                    estimated_cash_position._build_dto()
-                )
-            target_portfolio = PortfolioDTO(positions=tuple(target_portfolio.positions_map.values()))
+        target_portfolio = self.validated_trading_service.trades_batch.convert_to_portfolio(
+            estimated_cash_position._build_dto()
+        )
         self.evaluate_active_rules(self.trade_date, target_portfolio, asynchronously=True)
-
-        if (
-            trades_validation_errors
-            and (fsm_context := getattr(self, "fsm_context", None))
-            and (request := fsm_context.get("request", None))
-        ):
-            msg = f"""The reason for the failed trades are: <ul>
-            {''.join(map(lambda o: '<li>' + o + '</li>', trades_validation_errors))}
-            </ul>
-            """
-            error(request, msg, extra_tags="auto_close=0")
+        return trades_validation_warnings
 
     def can_submit(self):
         errors = dict()
@@ -496,7 +487,7 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
         service = self.validated_trading_service
         try:
             service.is_valid(ignore_error=True)
-            # if service.trades_batch.totat_abs_delta_weight == 0:
+            # if service.trades_batch.total_abs_delta_weight == 0:
             #     errors_list.append(
             #         "There is no change detected in this trade proposal. Please submit at last one valid trade"
             #     )
@@ -542,6 +533,7 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
             raise ValueError("Non-Rebalanceable portfolio cannot be traded manually.")
         trades = []
         assets = []
+        warnings = []
         # We do not want to create the estimated cash position if there is not trades in the trade proposal (shouldn't be possible anyway)
         estimated_cash_position = self.get_estimated_target_cash(self.portfolio.currency)
 
@@ -556,13 +548,11 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
 
         # if there is cash leftover, we create an extra asset position to hold the cash component
         if estimated_cash_position.weighting and len(trades) > 0:
+            warnings.append(
+                f"We created automatically a cash position of weight {estimated_cash_position.weighting:.2%}"
+            )
             estimated_cash_position.pre_save()
             assets.append(estimated_cash_position)
-            if (fsm_context := getattr(self, "fsm_context", None)) and (request := fsm_context.get("request", None)):
-                info(
-                    request,
-                    f"We created automatically a cash position of weight {estimated_cash_position.weighting:.2%}",
-                )
 
         Trade.objects.bulk_update(trades, ["status"])
         self.portfolio.bulk_create_positions(
@@ -570,6 +560,7 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
         )
         if replay and self.portfolio.is_manageable:
             replay_as_task.delay(self.id, user_id=by.id if by else None)
+        return warnings
 
     def can_approve(self):
         errors = dict()

{wbportfolio-1.52.5 → wbportfolio-1.52.6}/wbportfolio/models/transactions/trades.py

@@ -249,9 +249,7 @@ class Trade(TransactionMixin, ImportMixin, OrderedModel, models.Model):
         field=status,
         source=Status.DRAFT,
         target=GET_STATE(
-            lambda self, **kwargs: (
-                self.Status.SUBMIT if self.last_underlying_quote_price is not None else self.Status.FAILED
-            ),
+            lambda self, **kwargs: (self.Status.SUBMIT if self.price else self.Status.FAILED),
             states=[Status.SUBMIT, Status.FAILED],
         ),
         permission=lambda instance, user: PortfolioRole.is_portfolio_manager(
@@ -271,7 +269,12 @@ class Trade(TransactionMixin, ImportMixin, OrderedModel, models.Model):
         on_error="FAILED",
     )
     def submit(self, by=None, description=None, **kwargs):
-        pass
+        errors = []
+        if not self.price:
+            errors.append(
+                f"Trade failed because no price is found for {self.underlying_instrument.computed_str} on {self.transaction_date:%Y-%m-%d}"
+            )
+        return errors
 
     def can_submit(self):
         pass
@@ -287,6 +290,7 @@ class Trade(TransactionMixin, ImportMixin, OrderedModel, models.Model):
     def fail(self, **kwargs):
         pass
 
+    # TODO To be removed
     @cached_property
     def last_underlying_quote_price(self) -> InstrumentPrice | None:
         try:
@@ -343,7 +347,7 @@ class Trade(TransactionMixin, ImportMixin, OrderedModel, models.Model):
             )
 
     def can_execute(self):
-        if not self.last_underlying_quote_price:
+        if not self.price:
             return {"underlying_instrument": [_("Cannot execute a trade without a valid quote price")]}
         if not self.portfolio.is_manageable:
             return {
@@ -531,19 +535,22 @@ class Trade(TransactionMixin, ImportMixin, OrderedModel, models.Model):
 
     def save(self, *args, **kwargs):
         if self.trade_proposal:
+            if not self.underlying_instrument.is_investable_universe:
+                self.underlying_instrument.is_investable_universe = True
+                self.underlying_instrument.save()
             self.portfolio = self.trade_proposal.portfolio
             self.transaction_date = self.trade_proposal.trade_date
             self.value_date = self.trade_proposal.last_effective_date
-            if not self.portfolio.only_weighting:
-                with suppress(ValueError):
-                    self.shares = self.trade_proposal.get_estimated_shares(self.weighting, self.underlying_instrument)
+        if self.price is None:
+            # we try to get the price if not provided directly from the underlying instrument
+            self.price = self.get_price()
+        if self.trade_proposal and not self.portfolio.only_weighting:
+            self.shares = self.trade_proposal.get_estimated_shares(
+                self.weighting, self.underlying_instrument, self.price
+            )
 
         if not self.custodian and self.bank:
             self.custodian = Custodian.get_by_mapping(self.bank)
-        if self.price is None:
-            # we try to get the price if not provided directly from the underlying instrument
-            with suppress(Exception):
-                self.price = self.underlying_instrument.get_price(self.value_date)
 
         if self.transaction_subtype is None or self.trade_proposal:
             # if subtype not provided, we extract it automatically from the existing data.
@@ -588,9 +595,6 @@ class Trade(TransactionMixin, ImportMixin, OrderedModel, models.Model):
         """
 
     def get_asset(self) -> AssetPosition:
-        last_underlying_quote_price = self.last_underlying_quote_price
-        if not last_underlying_quote_price:
-            raise ValueError("No price found")
         asset = AssetPosition(
             underlying_quote=self.underlying_instrument,
             portfolio_created=None,
@@ -598,9 +602,8 @@ class Trade(TransactionMixin, ImportMixin, OrderedModel, models.Model):
             date=self.transaction_date,
             initial_currency_fx_rate=self.currency_fx_rate,
             weighting=self._target_weight,
-            initial_price=self.last_underlying_quote_price.net_value,
+            initial_price=self.price,
             initial_shares=None,
-            underlying_quote_price=self.last_underlying_quote_price,
             asset_valuation_date=self.transaction_date,
             currency=self.currency,
             is_estimated=False,
@@ -609,6 +612,11 @@ class Trade(TransactionMixin, ImportMixin, OrderedModel, models.Model):
         asset.pre_save()
         return asset
 
+    def get_price(self) -> Decimal | None:
+        if self.value_date:
+            with suppress(ValueError):
+                return Decimal(self.underlying_instrument.get_price(self.value_date))
+
     def delete(self, **kwargs):
         pre_collection.send(sender=self.__class__, instance=self)
         super().delete(**kwargs)
@@ -631,6 +639,7 @@ class Trade(TransactionMixin, ImportMixin, OrderedModel, models.Model):
             instrument_type=self.underlying_instrument.security_instrument_type.id,
             currency=self.underlying_instrument.currency,
             date=self.transaction_date,
+            is_cash=self.underlying_instrument.is_cash or self.underlying_instrument.is_cash_equivalent,
         )
 
     def get_alternative_valid_trades(self, share_delta: float = 0):

{wbportfolio-1.52.5 → wbportfolio-1.52.6}/wbportfolio/pms/trading/handler.py

@@ -17,25 +17,20 @@ class TradingService:
         trade_date: date,
         effective_portfolio: Portfolio | None = None,
         target_portfolio: Portfolio | None = None,
-        trades_batch: TradeBatch | None = None,
-        total_value: Decimal = None,
+        total_target_weight: Decimal = Decimal("1.0"),
     ):
-        self.total_value = total_value
         self.trade_date = trade_date
         if target_portfolio is None:
             target_portfolio = Portfolio(positions=())
         if effective_portfolio is None:
             effective_portfolio = Portfolio(positions=())
-        # If effective portfoolio and trades batch is provided, we ensure the trade batch contains at least one trade for every position
-        trades_batch = self.build_trade_batch(effective_portfolio, target_portfolio, trades_batch=trades_batch)
-        # if no trade but a effective portfolio is provided, we get the trade batch only from the effective portofolio (and the target portfolio if provided, but optional. Without it, the trade delta weight will be 0 )
-        # Finally, we compute the target portfolio
-        if trades_batch and not target_portfolio:
-            target_portfolio = trades_batch.convert_to_portfolio()
+        # If effective portfolio and trades batch is provided, we ensure the trade batch contains at least one trade for every position
+        self.trades_batch = self.build_trade_batch(effective_portfolio, target_portfolio).normalize(
+            total_target_weight
+        )
 
-        self.trades_batch = trades_batch
-        self.effective_portfolio = effective_portfolio
-        self.target_portfolio = target_portfolio
+        self._effective_portfolio = effective_portfolio
+        self._target_portfolio = target_portfolio
 
     @property
     def errors(self) -> list[str]:
@@ -62,12 +57,11 @@ class TradingService:
         Test the given value against all the validators on the field,
         and either raise a `ValidationError` or simply return.
         """
-        # TradeBatch(validated_trades).validate()
-        if self.effective_portfolio:
+        if self._effective_portfolio:
             for trade in validated_trades:
                 if (
                     trade.effective_weight
-                    and trade.underlying_instrument not in self.effective_portfolio.positions_map
+                    and trade.underlying_instrument not in self._effective_portfolio.positions_map
                 ):
                     raise ValidationError("All effective position needs to be matched with a validated trade")
 
@@ -75,7 +69,6 @@ class TradingService:
         self,
         effective_portfolio: Portfolio,
         target_portfolio: Portfolio,
-        trades_batch: TradeBatch | None = None,
     ) -> TradeBatch:
         """
         Given combination of effective portfolio and either a trades batch or a target portfolio, ensure all theres variables are set
@@ -87,39 +80,35 @@ class TradingService:
 
         Returns: The normalized trades batch
         """
-        instruments = list(effective_portfolio.positions_map.keys())
-        instruments.extend(list(target_portfolio.positions_map.keys()))
-        if trades_batch:
-            instruments.extend(list(trades_batch.trades_map.keys()))
-        _trades: list[Trade] = []
-        for instrument in set(instruments):
-            effective_weight = target_weight = 0
-            effective_shares = 0
-            instrument_type = currency = None
-            if effective_pos := effective_portfolio.positions_map.get(instrument, None):
-                effective_weight = effective_pos.weighting
-                effective_shares = effective_pos.shares
-                instrument_type, currency = effective_pos.instrument_type, effective_pos.currency
-            if target_pos := target_portfolio.positions_map.get(instrument, None):
-                target_weight = target_pos.weighting
-                instrument_type, currency = target_pos.instrument_type, target_pos.currency
-            if trades_batch and (trade := trades_batch.trades_map.get(instrument, None)):
-                effective_weight, target_weight = trade.effective_weight, trade.target_weight
-                effective_shares = trade.effective_shares
-                instrument_type, currency = trade.instrument_type, trade.currency
-
-            _trades.append(
-                Trade(
-                    underlying_instrument=instrument,
-                    effective_weight=effective_weight,
-                    target_weight=target_weight,
-                    effective_shares=effective_shares,
-                    date=self.trade_date,
-                    instrument_type=instrument_type,
-                    currency=currency,
+        instruments = effective_portfolio.positions_map.copy()
+        instruments.update(target_portfolio.positions_map)
+
+        trades: list[Trade] = []
+        for instrument_id, pos in instruments.items():
+            if not pos.is_cash:
+                effective_weight = target_weight = 0
+                effective_shares = 0
+                instrument_type = currency = None
+                if effective_pos := effective_portfolio.positions_map.get(instrument_id, None):
+                    effective_weight = effective_pos.weighting
+                    effective_shares = effective_pos.shares
+                    instrument_type, currency = effective_pos.instrument_type, effective_pos.currency
+                if target_pos := target_portfolio.positions_map.get(instrument_id, None):
+                    target_weight = target_pos.weighting
+                    instrument_type, currency = target_pos.instrument_type, target_pos.currency
+
+                trades.append(
+                    Trade(
+                        underlying_instrument=instrument_id,
+                        effective_weight=effective_weight,
+                        target_weight=target_weight,
+                        effective_shares=effective_shares,
+                        date=self.trade_date,
+                        instrument_type=instrument_type,
+                        currency=currency,
+                    )
                 )
-            )
-        return TradeBatch(tuple(_trades))
+        return TradeBatch(tuple(trades))
 
     def is_valid(self, ignore_error: bool = False) -> bool:
         """
@@ -151,11 +140,3 @@ class TradingService:
                 raise ValidationError(self.errors)
 
         return not bool(self._errors)
-
-    def normalize(self):
-        """
-        Normalize the instantiate trades batch so that the target weight is 100%
-        """
-        self.trades_batch = TradeBatch(
-            [trade.normalize_target(self.trades_batch.total_target_weight) for trade in self.trades_batch.trades]
-        )

{wbportfolio-1.52.5 → wbportfolio-1.52.6}/wbportfolio/pms/typing.py

@@ -48,7 +48,7 @@ class Position:
 @dataclass(frozen=True)
 class Portfolio:
     positions: tuple[Position] | tuple
-    positions_map: dict[Position] = field(init=False, repr=False)
+    positions_map: dict[int, Position] = field(init=False, repr=False)
 
     def __post_init__(self):
         positions_map = {}
@@ -80,7 +80,7 @@ class Portfolio:
 @dataclass(frozen=True)
 class Trade:
     underlying_instrument: int
-    instrument_type: str
+    instrument_type: int
     currency: int
     date: date_lib
 
@@ -88,6 +88,7 @@ class Trade:
     target_weight: Decimal
     id: int | None = None
     effective_shares: Decimal = None
+    is_cash: bool = False
 
     def __add__(self, other):
         return Trade(
@@ -121,9 +122,9 @@ class Trade:
         # if self.target_weight < 0 or self.target_weight > 1.0:
         #     raise ValidationError("Target Weight needs to be in range [0, 1]")
 
-    def normalize_target(self, total_target_weight: Decimal):
+    def normalize_target(self, factor: Decimal):
         t = Trade(
-            target_weight=self.target_weight / total_target_weight if total_target_weight else self.target_weight,
+            target_weight=self.target_weight * factor,
             **{f.name: getattr(self, f.name) for f in fields(Trade) if f.name not in ["target_weight"]},
         )
         return t
@@ -145,15 +146,15 @@ class TradeBatch:
 
     @property
     def total_target_weight(self) -> Decimal:
-        return round(sum([trade.target_weight for trade in self.trades]), 6)
+        return round(sum([trade.target_weight for trade in self.trades], Decimal("0")), 6)
 
     @property
     def total_effective_weight(self) -> Decimal:
-        return round(sum([trade.effective_weight for trade in self.trades]), 6)
+        return round(sum([trade.effective_weight for trade in self.trades], Decimal("0")), 6)
 
     @property
-    def totat_abs_delta_weight(self) -> Decimal:
-        return sum([abs(trade.delta_weight) for trade in self.trades])
+    def total_abs_delta_weight(self) -> Decimal:
+        return sum([abs(trade.delta_weight) for trade in self.trades], Decimal("0"))
 
     def __add__(self, other):
         return TradeBatch(tuple(self.trades + other.trades))
@@ -165,7 +166,7 @@ class TradeBatch:
         if round(float(self.total_target_weight), 4) != 1:  # we do that to remove decimal over precision
             raise ValidationError(f"Total Weight cannot be different than 1 ({float(self.total_target_weight)})")
 
-    def convert_to_portfolio(self):
+    def convert_to_portfolio(self, *extra_positions):
         positions = []
         for instrument, trade in self.trades_map.items():
             positions.append(
@@ -175,6 +176,23 @@ class TradeBatch:
                     weighting=trade.target_weight,
                     currency=trade.currency,
                     date=trade.date,
+                    is_cash=trade.is_cash,
                 )
             )
+        for position in extra_positions:
+            if position.weighting:
+                positions.append(position)
         return Portfolio(tuple(positions))
+
+    def normalize(self, total_target_weight: Decimal = Decimal("1.0")):
+        """
+        Normalize the instantiate trades batch so that the target weight is 100%
+        """
+        normalization_factor = (
+            total_target_weight / self.total_target_weight if self.total_target_weight else Decimal("0.0")
+        )
+        normalized_trades = []
+        for trade in self.trades:
+            normalized_trades.append(trade.normalize_target(normalization_factor))
+        tb = TradeBatch(normalized_trades)
+        return tb