wbportfolio 2.2.1__py2.py3-none-any.whl

wbportfolio/models/transactions/transactions.py

@@ -0,0 +1,211 @@
+from decimal import Decimal
+
+from django.apps import apps
+from django.db import models
+from django.dispatch import receiver
+from wbcore.contrib.io.mixins import ImportMixin
+from wbcore.signals import pre_merge
+from wbfdm.models.instruments.instruments import Instrument
+from wbfdm.signals import add_instrument_to_investable_universe
+
+
+class ShareMixin(models.Model):
+    shares = models.DecimalField(
+        max_digits=15,
+        decimal_places=4,
+        null=True,
+        blank=True,
+        help_text="The number of shares that were traded.",
+        verbose_name="Shares",
+    )
+    price = models.DecimalField(
+        max_digits=16,
+        decimal_places=4,
+        null=True,
+        blank=True,
+        help_text="The price per share.",
+        verbose_name="Price",
+    )
+
+    price_gross = models.DecimalField(
+        max_digits=16,
+        decimal_places=4,
+        null=True,
+        blank=True,
+        help_text="The gross price per share.",
+        verbose_name="Gross Price",
+    )
+
+    class Meta:
+        abstract = True
+
+
+class Transaction(ImportMixin, models.Model):
+    class Type(models.TextChoices):
+        # Standart Asset Types
+        TRADE = "Trade", "Trade"
+        DIVIDEND_TRANSACTION = "DividendTransaction", "Dividend Transaction"
+        EXPIRY = "Expiry", "Expiry"
+        FEES = "Fees", "Fees"
+
+    transaction_type = models.CharField(max_length=255, verbose_name="Type", choices=Type.choices, default=Type.TRADE)
+
+    portfolio = models.ForeignKey(
+        "wbportfolio.Portfolio", related_name="transactions", on_delete=models.PROTECT, verbose_name="Portfolio"
+    )
+
+    underlying_instrument = models.ForeignKey(
+        to="wbfdm.Instrument",
+        related_name="transactions",
+        limit_choices_to=models.Q(children__isnull=True),
+        on_delete=models.PROTECT,
+        verbose_name="Underlying Instrument",
+        help_text="The instrument that is this transaction.",
+    )
+
+    transaction_date = models.DateField(
+        verbose_name="Trade Date",
+        help_text="The date that this transaction was traded.",
+    )
+    book_date = models.DateField(
+        null=True,
+        blank=True,
+        verbose_name="Trade Date",
+        help_text="The date that this transaction was booked.",
+    )
+    value_date = models.DateField(
+        null=True,
+        blank=True,
+        verbose_name="Value Date",
+        help_text="The date that this transaction was valuated.",
+    )
+
+    currency = models.ForeignKey(
+        "currency.Currency",
+        related_name="transactions",
+        on_delete=models.PROTECT,
+        verbose_name="Currency",
+    )
+    currency_fx_rate = models.DecimalField(
+        max_digits=14, decimal_places=8, default=Decimal(1.0), verbose_name="FOREX rate"
+    )
+    total_value = models.DecimalField(
+        max_digits=20, decimal_places=4, null=True, blank=True, verbose_name="Total Value"
+    )
+    total_value_fx_portfolio = models.DecimalField(
+        max_digits=20, decimal_places=4, null=True, blank=True, verbose_name="Total Value Fx Portfolio"
+    )
+    total_value_gross = models.DecimalField(
+        max_digits=20, decimal_places=4, null=True, blank=True, verbose_name="Total Value Gross"
+    )
+    total_value_gross_fx_portfolio = models.DecimalField(
+        max_digits=20, decimal_places=4, null=True, blank=True, verbose_name="Total Value Gross Fx Portfolio"
+    )
+    external_id = models.CharField(
+        max_length=255,
+        null=True,
+        blank=True,
+        help_text="An external identifier that was supplied.",
+        verbose_name="External Identifier",
+    )
+    comment = models.TextField(default="", verbose_name="Comment", blank=True)
+
+    def save(self, *args, **kwargs):
+        if not getattr(self, "currency", None) and self.underlying_instrument:
+            self.currency = self.underlying_instrument.currency
+        if not self.currency_fx_rate:
+            self.currency_fx_rate = self.underlying_instrument.currency.convert(
+                self.transaction_date, self.portfolio.currency, exact_lookup=True
+            )
+        if not self.transaction_type:
+            self.transaction_type = self.__class__.__name__
+        if not self.value_date:
+            self.value_date = self.transaction_date
+            # try:
+            #     # we try to find the next valid date (i.e. the one with position on the underlying instrument"
+            #     self.value_date = (
+            #         self.underlying_instrument.valuations.filter(date__gt=self.transaction_date).earliest("date").date
+            #     )
+            # except ObjectDoesNotExist:
+            #     self.value_date = (self.transaction_date + BDay(1)).date()
+        if not self.book_date:
+            self.book_date = self.transaction_date
+        if (
+            self.total_value is not None
+            and self.currency_fx_rate is not None
+            and self.total_value_fx_portfolio is None
+        ):
+            self.total_value_fx_portfolio = self.total_value * self.currency_fx_rate
+
+        if self.total_value is not None and self.total_value_gross is None and self.total_value_gross is None:
+            self.total_value_gross = self.total_value
+
+        if (
+            self.currency_fx_rate is not None
+            and self.total_value_gross is not None
+            and self.total_value_gross_fx_portfolio is None
+        ):
+            self.total_value_gross_fx_portfolio = self.total_value_gross * self.currency_fx_rate
+
+        super().save(*args, **kwargs)
+
+    def __str__(self):
+        return f"{self.total_value} - {self.transaction_date:%d.%m.%Y} : {str(self.underlying_instrument)} (in {str(self.portfolio)})"
+
+    def get_casted_model(self):
+        return apps.get_model(app_label="wbportfolio", model_name=self.transaction_type)
+
+    def get_casted_transaction(self) -> models.Model:
+        """
+        Cast the asset into its child representative
+        """
+        model = self.get_casted_model()
+        return model.objects.get(pk=self.pk)
+
+    class Meta:
+        verbose_name = "Transaction"
+        verbose_name_plural = "Transactions"
+        indexes = [
+            models.Index(fields=["underlying_instrument", "transaction_date"]),
+            # models.Index(fields=["date", "underlying_instrument"]),
+        ]
+
+    objects = models.Manager()
+
+    @classmethod
+    def get_representation_value_key(cls):
+        return "id"
+
+    @classmethod
+    def get_representation_label_key(cls):
+        return "{{total_value}}{{transaction_date}}"
+
+    @classmethod
+    def get_endpoint_basename(cls):
+        return "wbportfolio:transaction"
+
+
+@receiver(pre_merge, sender="wbfdm.Instrument")
+def pre_merge_instrument(sender: models.Model, merged_object: "Instrument", main_object: "Instrument", **kwargs):
+    """
+    Simply reassign the transactions linked to the merged instrument to the main instrument
+    """
+    merged_object.transactions.update(underlying_instrument=main_object)
+
+
+@receiver(add_instrument_to_investable_universe, sender="wbfdm.Instrument")
+def add_instrument_to_investable_universe_from_transactions(sender: models.Model, **kwargs) -> list[int]:
+    """
+    register all instrument linked to assets as within the investible universe
+    """
+    return list(
+        (
+            Instrument.objects.annotate(
+                transaction_exists=models.Exists(
+                    Transaction.objects.filter(underlying_instrument=models.OuterRef("pk"))
+                )
+            ).filter(transaction_exists=True)
+        )
+        .distinct()
+        .values_list("id", flat=True)
+    )

wbportfolio/models/utils.py

@@ -0,0 +1,12 @@
+from wbfdm.models import Instrument
+from wbportfolio.models import Index, Product
+
+
+def get_casted_portfolio_instrument(instrument: Instrument) -> Product | Index | None:
+    try:
+        return Product.objects.get(id=instrument.id)
+    except Product.DoesNotExist:
+        try:
+            return Index.objects.get(id=instrument.id)
+        except Index.DoesNotExist:
+            return None

wbportfolio/permissions.py

@@ -0,0 +1,13 @@
+from wbportfolio.models import PortfolioRole
+
+
+def is_manager(request):
+    return PortfolioRole.is_manager(request.user.profile)
+
+
+def is_portfolio_manager(request):
+    return PortfolioRole.is_portfolio_manager(request.user.profile)
+
+
+def is_analyst(request):
+    return PortfolioRole.is_analyst(request.user.profile)

wbportfolio/pms/trading/__init__.py

@@ -0,0 +1 @@
+from .handler import TradingService

wbportfolio/pms/trading/handler.py

@@ -0,0 +1,164 @@
+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,
+    ):
+        if not target_portfolio and not trades_batch:
+            raise ValueError("Either target positions or trades needs to be provided")
+        self.total_value = total_value
+        self.trade_date = trade_date
+        # If effective portfoolio and trades batch is provided, we ensure the trade batch contains at least one trade for every position
+        if effective_portfolio and trades_batch:
+            trades_batch = self.build_trade_batch(effective_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 )
+        elif not trades_batch and effective_portfolio:
+            # If no trade batch is provided but effetive_portfolio is, we estimate the trade from the given portfolios
+            trades_batch = self.build_trade_batch(effective_portfolio, target_portfolio=target_portfolio)
+        # 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 | None = None,
+        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())
+        if target_portfolio:
+            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 = target_shares = 0
+            instrument_type = currency = None
+            if effective_pos := effective_portfolio.positions_map.get(instrument, None):
+                effective_weight = target_weight = effective_pos.weighting
+                effective_shares = target_shares = effective_pos.shares
+                instrument_type, currency = effective_pos.instrument_type, effective_pos.currency
+            if target_portfolio and (target_pos := target_portfolio.positions_map.get(instrument, None)):
+                target_weight = target_pos.weighting
+                target_shares = target_pos.shares
+            if trades_batch and (trade := trades_batch.trades_map.get(instrument, None)):
+                effective_weight, target_weight = trade.effective_weight, trade.target_weight
+                effective_shares, target_shares = trade.effective_shares, trade.target_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,
+                    target_shares=target_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/pms/typing.py

@@ -0,0 +1,194 @@
+from dataclasses import asdict, dataclass, field, fields
+from datetime import date as date_lib
+from decimal import Decimal
+
+import pandas as pd
+from django.core.exceptions import ValidationError
+from django.utils.functional import cached_property
+
+
+@dataclass(frozen=True)
+class Valuation:
+    instrument: int
+    net_value: Decimal
+    outstanding_shares: Decimal = Decimal(0)
+
+
+@dataclass(frozen=True)
+class Position:
+    underlying_instrument: int
+    instrument_type: int
+    weighting: Decimal
+    currency: int
+    date: date_lib
+
+    asset_valuation_date: date_lib | None = None
+    portfolio_created: int = None
+    exchange: int = None
+    is_estimated: bool = False
+    country: int = None
+    shares: Decimal | None = None
+    is_cash: bool = False
+    primary_classification: int = None
+    favorite_classification: int = None
+    market_capitalization_usd: float = None
+    currency_fx_rate: float = 1
+    market_share: float = None
+    daily_liquidity: float = None
+    volume_usd: float = None
+    price: float = None
+
+    def __add__(self, other):
+        return Position(
+            weighting=self.weighting + other.weighting,
+            shares=self.shares + other.shares if (self.shares is not None and other.shares is not None) else None,
+            **{f.name: getattr(self, f.name) for f in fields(Position) if f.name not in ["weighting", "shares"]},
+        )
+
+
+@dataclass(frozen=True)
+class Portfolio:
+    positions: tuple[Position]
+    positions_map: dict[Position] = field(init=False, repr=False)
+
+    def __post_init__(self):
+        positions_map = {}
+        for pos in self.positions:
+            if pos.underlying_instrument in positions_map:
+                positions_map[pos.underlying_instrument] += pos
+            else:
+                positions_map[pos.underlying_instrument] = pos
+        object.__setattr__(self, "positions_map", positions_map)
+
+    @cached_property
+    def total_weight(self):
+        return round(sum([pos.weighting for pos in self.positions]), 4)
+
+    @cached_property
+    def total_shares(self):
+        return sum([pos.target_shares for pos in self.positions if pos.target_shares is not None])
+
+    def to_df(self):
+        return pd.DataFrame([asdict(pos) for pos in self.positions])
+
+    def __len__(self):
+        return len(self.positions)
+
+
+@dataclass(frozen=True)
+class Trade:
+    underlying_instrument: int
+    instrument_type: str
+    currency: int
+    date: date_lib
+
+    effective_weight: Decimal
+    target_weight: Decimal
+    id: int | None = None
+    effective_shares: Decimal = None
+    target_shares: Decimal = None
+
+    def __add__(self, other):
+        return Trade(
+            underlying_instrument=self.underlying_instrument,
+            effective_weight=self.effective_weight + other.effective_weight,
+            target_weight=self.target_weight + other.target_weight,
+            target_shares=self.target_shares + other.target_shares
+            if (self.target_shares is not None and other.target_shares is not None)
+            else None,
+            effective_shares=self.effective_shares + other.effective_shares
+            if (self.effective_shares is not None and other.effective_shares is not None)
+            else None,
+            **{
+                f.name: getattr(self, f.name)
+                for f in fields(Trade)
+                if f.name
+                not in [
+                    "effective_weight",
+                    "target_weight",
+                    "target_shares",
+                    "effective_shares",
+                    "underlying_instrument",
+                ]
+            },
+        )
+
+    @cached_property
+    def delta_weight(self) -> Decimal:
+        return self.target_weight - self.effective_weight
+
+    def validate(self):
+        if self.effective_weight < 0 or self.effective_weight > 1.0:
+            raise ValidationError("Effective Weight needs to be in range [0, 1]")
+        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):
+        t = Trade(
+            target_weight=self.target_weight / total_target_weight if total_target_weight else self.target_weight,
+            target_shares=self.target_shares / total_target_weight
+            if (self.target_shares and total_target_weight)
+            else self.target_shares,
+            **{
+                f.name: getattr(self, f.name)
+                for f in fields(Trade)
+                if f.name not in ["target_weight", "target_shares"]
+            },
+        )
+        return t
+
+
+@dataclass(frozen=True)
+class TradeBatch:
+    trades: tuple[Trade]
+    trades_map: dict[Trade] = field(init=False, repr=False)
+
+    def __post_init__(self):
+        trade_map = {}
+        for trade in self.trades:
+            if trade.underlying_instrument in trade_map:
+                trade_map[trade.underlying_instrument] += trade
+            else:
+                trade_map[trade.underlying_instrument] = trade
+        object.__setattr__(self, "trades_map", trade_map)
+
+    @cached_property
+    def total_target_weight(self) -> Decimal:
+        return round(sum([trade.target_weight for trade in self.trades]), 4)
+
+    @cached_property
+    def total_effective_weight(self) -> Decimal:
+        return round(sum([trade.effective_weight for trade in self.trades]), 4)
+
+    @cached_property
+    def total_shares(self) -> Decimal:
+        return sum([trade.target_shares for trade in self.trades if trade.target_shares is not None]) or Decimal(0)
+
+    @cached_property
+    def totat_abs_delta_weight(self) -> Decimal:
+        return sum([abs(trade.delta_weight) for trade in self.trades])
+
+    def __add__(self, other):
+        return TradeBatch(tuple(self.trades + other.trades))
+
+    def __len__(self):
+        return len(self.trades)
+
+    def validate(self):
+        if float(self.total_target_weight) != 1.0:  # 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):
+        positions = []
+        for instrument, trade in self.trades_map.items():
+            positions.append(
+                Position(
+                    underlying_instrument=trade.underlying_instrument,
+                    instrument_type=trade.instrument_type,
+                    weighting=trade.target_weight,
+                    shares=trade.target_shares,
+                    currency=trade.currency,
+                    date=trade.date,
+                )
+            )
+        return Portfolio(tuple(positions))

wbportfolio/preferences.py

@@ -0,0 +1,6 @@
+from dynamic_preferences.registries import global_preferences_registry
+
+
+def get_monthly_nnm_target(*args, **kwargs):
+    global_preferences = global_preferences_registry.manager()
+    return global_preferences["wbportfolio__monthly_nnm_target"]

wbportfolio/reports/monthly_position_report.py

@@ -0,0 +1,74 @@
+from datetime import datetime
+from io import BytesIO
+from typing import TYPE_CHECKING, Any
+
+import pandas as pd
+from pandas.tseries.offsets import BMonthEnd
+from wbfdm.models import InstrumentList
+from wbreport.mixins import ReportMixin
+
+if TYPE_CHECKING:
+    from wbcore.contrib.authentication.models import User
+    from wbreport.models import Report, ReportVersion
+
+
+class ReportClass(ReportMixin):
+    @classmethod
+    def parse_parameters(cls, parameters: dict[str, str]) -> dict[str, Any]:
+        return {
+            "end": datetime.strptime(parameters["end"], "%Y-%m-%d").date(),
+        }
+
+    @classmethod
+    def get_next_parameters(cls, parameters: dict[str, Any]) -> dict[str, Any]:
+        parse_parameters = cls.parse_parameters(parameters)
+        return {
+            "end": datetime.strftime((parse_parameters["end"] + BMonthEnd(1)).date(), "%Y-%m-%d"),
+        }
+
+    @classmethod
+    def get_version_date(cls, parameters) -> datetime.date:
+        parameters = cls.parse_parameters(parameters)
+        return parameters["end"]
+
+    @classmethod
+    def get_version_title(cls, report_title: str, parameters: dict[str, Any]) -> str:
+        parameters = cls.parse_parameters(parameters)
+        return f"{report_title} - {parameters['end']:%b}"
+
+    @classmethod
+    def has_view_permission(cls, report: "Report", user: "User") -> bool:
+        return user.has_perms(["wbreport.view_report", "wbportfolio.view_assetposition"])
+
+    @classmethod
+    def get_context(cls, version: "ReportVersion") -> dict[str, Any]:
+        instrument_list: "InstrumentList" = version.report.content_object
+        end_date = version.parameters.get("end")
+        positions = []
+
+        for instrument in instrument_list.instruments.all():
+            if portfolio := instrument.primary_portfolio:
+                for position in portfolio.assets.filter(date=end_date):
+                    positions.append(
+                        {
+                            "portfolio": instrument.name,
+                            "isin": position.underlying_instrument.isin,
+                            "title": position.underlying_instrument.name_repr,
+                            "instrument_type": position.underlying_instrument.security_instrument_type.short_name,
+                            "weight": float(position.weighting),
+                            "date": position.date.strftime("%Y-%m-%d"),
+                        }
+                    )
+
+        return {"positions": positions}
+
+    @classmethod
+    def generate_file(cls, context: dict[str, Any]) -> BytesIO:
+        stream = BytesIO()
+        if positions := context.get("positions", None):
+            df = pd.DataFrame(positions).sort_values(by=["weight"], ascending=False)
+            writer = pd.ExcelWriter(stream, engine="xlsxwriter")
+            for portfolio, dff in df.groupby("portfolio"):
+                dff.to_excel(writer, sheet_name=portfolio[0:31], index=False)
+            writer.save()
+        return stream