wbportfolio 1.52.0__py2.py3-none-any.whl → 1.59.4__py2.py3-none-any.whl

wbportfolio/pms/trading/handler.py

@@ -1,161 +0,0 @@
-from datetime import date
-from decimal import Decimal
-
-from django.core.exceptions import ValidationError
-
-from wbportfolio.pms.typing import Portfolio, Trade, TradeBatch
-
-
-class TradingService:
-    """
-    This class represents the trading service. It can be instantiated either with the target portfolio and the effective portfolio or given a direct list of trade
-    In any case, it will compute all three states
-    """
-
-    def __init__(
-        self,
-        trade_date: date,
-        effective_portfolio: Portfolio | None = None,
-        target_portfolio: Portfolio | None = None,
-        trades_batch: TradeBatch | None = None,
-        total_value: Decimal = None,
-    ):
-        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()
-
-        self.trades_batch = trades_batch
-        self.effective_portfolio = effective_portfolio
-        self.target_portfolio = target_portfolio
-
-    @property
-    def errors(self) -> list[str]:
-        """
-        Returned the list of errors stored during the validation process. Can only be called after is_valid
-        """
-        if not hasattr(self, "_errors"):
-            msg = "You must call `.is_valid()` before accessing `.errors`."
-            raise AssertionError(msg)
-        return self._errors
-
-    @property
-    def validated_trades(self) -> list[Trade]:
-        """
-        Returned the list of validated trade stored during the validation process. Can only be called after is_valid
-        """
-        if not hasattr(self, "_validated_trades"):
-            msg = "You must call `.is_valid()` before accessing `.validated_trades`."
-            raise AssertionError(msg)
-        return self._validated_trades
-
-    def run_validation(self, validated_trades: list[Trade]):
-        """
-        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:
-            for trade in validated_trades:
-                if (
-                    trade.effective_weight
-                    and trade.underlying_instrument not in self.effective_portfolio.positions_map
-                ):
-                    raise ValidationError("All effective position needs to be matched with a validated trade")
-
-    def build_trade_batch(
-        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
-
-        Args:
-            effective_portfolio: The effective portfolio
-            target_portfolio: The optional target portfolio
-            trades_batch: The optional trades batch
-
-        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,
-                )
-            )
-        return TradeBatch(tuple(_trades))
-
-    def is_valid(self, ignore_error: bool = False) -> bool:
-        """
-        Validate the trade batch against a set of default rules. Populate the validated_trades and errors property.
-        Ignore error by default
-        Args:
-            ignore_error: If true, will raise the error. False by default
-
-        Returns: True if the trades batch is valid
-        """
-        if not hasattr(self, "_validated_trades"):
-            self._validated_trades = []
-            self._errors = []
-            # Run validation for every trade. If a trade is not valid, we simply exclude it from the validated trades list
-            for _, trade in self.trades_batch.trades_map.items():
-                try:
-                    trade.validate()
-                    self._validated_trades.append(trade)
-                except ValidationError as exc:
-                    self._errors.append(exc.message)
-            try:
-                # Check the overall validity of the trade batch. If this fail, we consider all trade invalids
-                self.run_validation(self._validated_trades)
-            except ValidationError as exc:
-                self._validated_trades = []
-                self._errors.append(exc.message)
-
-            if self._errors and not ignore_error:
-                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/serializers/transactions/expiry.py

@@ -1,18 +0,0 @@
-from wbportfolio.models import Expiry
-
-from .transactions import (
-    TransactionModelSerializer,
-    TransactionRepresentationSerializer,
-)
-
-
-class ExpiryRepresentationSerializer(TransactionRepresentationSerializer):
-    class Meta:
-        model = Expiry
-        fields = TransactionRepresentationSerializer.Meta.fields
-
-
-class ExpiryModelSerializer(TransactionModelSerializer):
-    class Meta:
-        model = Expiry
-        fields = TransactionModelSerializer.Meta.fields

wbportfolio/serializers/transactions/trade_proposals.py

@@ -1,76 +0,0 @@
-from django.contrib.messages import warning
-from django.core.exceptions import ValidationError
-from rest_framework.reverse import reverse
-from wbcore import serializers as wb_serializers
-from wbcore.serializers import DefaultFromView
-
-from wbportfolio.models import Portfolio, RebalancingModel, TradeProposal
-
-from .. import PortfolioRepresentationSerializer, RebalancingModelRepresentationSerializer
-
-
-class TradeProposalModelSerializer(wb_serializers.ModelSerializer):
-    rebalancing_model = wb_serializers.PrimaryKeyRelatedField(queryset=RebalancingModel.objects.all(), required=False)
-    _rebalancing_model = RebalancingModelRepresentationSerializer(source="rebalancing_model")
-    target_portfolio = wb_serializers.PrimaryKeyRelatedField(
-        queryset=Portfolio.objects.all(), write_only=True, required=False, default=DefaultFromView("portfolio")
-    )
-    _target_portfolio = PortfolioRepresentationSerializer(source="target_portfolio")
-
-    trade_date = wb_serializers.DateField(
-        read_only=lambda view: not view.new_mode, default=DefaultFromView("default_trade_date")
-    )
-
-    def create(self, validated_data):
-        target_portfolio = validated_data.pop("target_portfolio", None)
-        rebalancing_model = validated_data.get("rebalancing_model", None)
-        if request := self.context.get("request"):
-            validated_data["creator"] = request.user.profile
-        obj = super().create(validated_data)
-
-        target_portfolio_dto = None
-        if target_portfolio and not rebalancing_model and (last_effective_date := obj.last_effective_date):
-            target_portfolio_dto = target_portfolio._build_dto(last_effective_date)
-        try:
-            obj.reset_trades(target_portfolio=target_portfolio_dto)
-        except ValidationError as e:
-            if request := self.context.get("request"):
-                warning(request, str(e), extra_tags="auto_close=0")
-        return obj
-
-    @wb_serializers.register_only_instance_resource()
-    def additional_resources(self, instance, request, user, **kwargs):
-        res = {}
-        if instance.status == TradeProposal.Status.APPROVED:
-            res["replay"] = reverse("wbportfolio:tradeproposal-replay", args=[instance.id], request=request)
-        if instance.status == TradeProposal.Status.DRAFT:
-            res["reset"] = reverse("wbportfolio:tradeproposal-reset", args=[instance.id], request=request)
-            res["normalize"] = reverse("wbportfolio:tradeproposal-normalize", args=[instance.id], request=request)
-            res["deleteall"] = reverse("wbportfolio:tradeproposal-deleteall", args=[instance.id], request=request)
-        res["trades"] = reverse(
-            "wbportfolio:tradeproposal-trade-list",
-            args=[instance.id],
-            request=request,
-        )
-        return res
-
-    class Meta:
-        model = TradeProposal
-        only_fsm_transition_on_instance = True
-        fields = (
-            "id",
-            "trade_date",
-            "comment",
-            "status",
-            "portfolio",
-            "_rebalancing_model",
-            "rebalancing_model",
-            "target_portfolio",
-            "_target_portfolio",
-            "_additional_resources",
-        )
-
-
-class ReadOnlyTradeProposalModelSerializer(TradeProposalModelSerializer):
-    class Meta(TradeProposalModelSerializer.Meta):
-        read_only_fields = TradeProposalModelSerializer.Meta.fields

wbportfolio/serializers/transactions/transactions.py

@@ -1,85 +0,0 @@
-from wbcore import serializers as wb_serializers
-from wbcore.contrib.currency.serializers import CurrencyRepresentationSerializer
-from wbfdm.serializers import InvestableUniverseRepresentationSerializer
-
-from wbportfolio.models import Transaction
-from wbportfolio.serializers.portfolios import PortfolioRepresentationSerializer
-
-
-class TransactionRepresentationSerializer(wb_serializers.RepresentationSerializer):
-    _detail = wb_serializers.HyperlinkField(reverse_name="wbportfolio:transaction-detail")
-
-    class Meta:
-        model = Transaction
-        fields = ("id", "transaction_date", "total_value", "_detail")
-
-
-class TransactionModelSerializer(wb_serializers.ModelSerializer):
-    external_id = wb_serializers.CharField(required=False, read_only=True)
-    value_date = wb_serializers.DateField(required=False, read_only=True)
-    total_value_usd = wb_serializers.FloatField(default=0, read_only=True, label="Total Value ($)")
-    total_value_gross_usd = wb_serializers.FloatField(default=0, read_only=True, label="Total Value Gross ($)")
-    transaction_underlying_type = wb_serializers.CharField(read_only=True)
-    transaction_url_type = wb_serializers.SerializerMethodField()
-    _portfolio = PortfolioRepresentationSerializer(source="portfolio")
-    _underlying_instrument = InvestableUniverseRepresentationSerializer(source="underlying_instrument")
-    _currency = CurrencyRepresentationSerializer(source="currency")
-
-    total_value = wb_serializers.DecimalField(max_digits=14, decimal_places=2, read_only=True)
-    total_value_fx_portfolio = wb_serializers.DecimalField(max_digits=14, decimal_places=2, read_only=True)
-    total_value_gross = wb_serializers.DecimalField(max_digits=14, decimal_places=2, read_only=True)
-    total_value_gross_fx_portfolio = wb_serializers.DecimalField(max_digits=14, decimal_places=2, read_only=True)
-
-    def get_transaction_url_type(self, obj):
-        return obj.transaction_type.lower()
-
-    # def get_transaction_underlying_type(self, obj):
-    #     try:
-    #         casted_transaction = obj.get_casted_transaction()
-    #         return casted_transaction.Type[casted_transaction.transaction_subtype].label
-    #     except Exception as e:
-    #         return ""
-    class Meta:
-        model = Transaction
-        decorators = {
-            "total_value": wb_serializers.decorator(
-                decorator_type="text", position="left", value="{{_currency.symbol}}"
-            ),
-            "total_value_gross": wb_serializers.decorator(
-                decorator_type="text", position="left", value="{{_currency.symbol}}"
-            ),
-            "total_value_usd": wb_serializers.decorator(decorator_type="text", position="left", value="{{$}}"),
-            "total_value_gross_usd": wb_serializers.decorator(decorator_type="text", position="left", value="{{$}}"),
-            "total_value_fx_portfolio": wb_serializers.decorator(
-                position="left", value="{{_portfolio.currency_symbol}}"
-            ),
-            "total_value_gross_fx_portfolio": wb_serializers.decorator(
-                position="left", value="{{_portfolio.currency_symbol}}"
-            ),
-            # "total_value_fx_portfolio": wb_serializers.decorator(decorator_type="text", position="left", value="{{_portfolio.currency_symbol}}}"),
-            # "total_value_gross_fx_portfolio": wb_serializers.decorator(decorator_type="text", position="left", value="{{_portfolio.currency_symbol}}"),
-        }
-        fields = (
-            "id",
-            "transaction_type",
-            "transaction_url_type",
-            "transaction_underlying_type",
-            "portfolio",
-            "_portfolio",
-            "underlying_instrument",
-            "_underlying_instrument",
-            "transaction_date",
-            "book_date",
-            "value_date",
-            "currency",
-            "_currency",
-            "currency_fx_rate",
-            "total_value",
-            "total_value_fx_portfolio",
-            "total_value_gross",
-            "total_value_gross_fx_portfolio",
-            "external_id",
-            "comment",
-            "total_value_usd",
-            "total_value_gross_usd",
-        )