wbportfolio 2.2.1__py2.py3-none-any.whl

wbportfolio/serializers/assets.py

@@ -0,0 +1,166 @@
+from wbcore import serializers as wb_serializers
+from wbcore.contrib.currency.serializers import CurrencyRepresentationSerializer
+from wbfdm.serializers import InvestableInstrumentRepresentationSerializer
+from wbfdm.serializers.exchanges import ExchangeRepresentationSerializer
+from wbportfolio.models import AssetPosition, Portfolio
+
+from .portfolios import PortfolioRepresentationSerializer
+
+
+class AssetPositionModelSerializer(wb_serializers.ModelSerializer):
+    underlying_instrument_isin = wb_serializers.CharField(read_only=True)
+    underlying_instrument_ticker = wb_serializers.CharField(read_only=True)
+    underlying_instrument_name = wb_serializers.CharField(read_only=True)
+    _underlying_instrument = InvestableInstrumentRepresentationSerializer(
+        source="underlying_instrument", label_key="name"
+    )
+    _currency = CurrencyRepresentationSerializer(source="currency")
+    _portfolio = PortfolioRepresentationSerializer(source="portfolio")
+    _exchange = ExchangeRepresentationSerializer(source="exchange")
+    _portfolio_created = PortfolioRepresentationSerializer(source="portfolio_created")
+
+    shares = wb_serializers.DecimalField(read_only=True, decimal_places=4, max_digits=14)
+    total_value_fx_usd = wb_serializers.FloatField(read_only=True, precision=2)
+    liquidity = wb_serializers.FloatField(read_only=True, default=0, precision=2)
+    market_share = wb_serializers.FloatField(read_only=True, precision=6)
+    market_capitalization = wb_serializers.FloatField(read_only=True)
+    price = wb_serializers.DecimalField(read_only=True, decimal_places=4, max_digits=14)
+    currency_fx_rate = wb_serializers.FloatField(read_only=True)
+    price_fx_portfolio = wb_serializers.FloatField(read_only=True)
+    total_value = wb_serializers.FloatField(read_only=True)
+    total_value_fx_portfolio = wb_serializers.FloatField(read_only=True)
+
+    is_invested = wb_serializers.BooleanField(read_only=True, default=False)
+    currency_symbol = wb_serializers.CharField(read_only=True)
+    portfolio_currency_symbol = wb_serializers.CharField(read_only=True)
+
+    class Meta:
+        decorators = {
+            "total_value_fx_portfolio": wb_serializers.decorator(
+                decorator_type="text", position="left", value="{{portfolio_currency_symbol}}"
+            ),
+            "total_value": wb_serializers.decorator(
+                decorator_type="text", position="left", value="{{currency_symbol}}"
+            ),
+            "price": wb_serializers.decorator(decorator_type="text", position="left", value="{{currency_symbol}}"),
+            "total_value_fx_usd": wb_serializers.decorator(decorator_type="text", position="left", value="$"),
+        }
+        percent_fields = ["weighting", "market_share"]
+        model = AssetPosition
+        fields = (
+            "id",
+            "asset_valuation_date",
+            "exchange",
+            "price_denotation",
+            "date",
+            "shares",
+            "weighting",
+            "portfolio",
+            "portfolio_created",
+            "currency",
+            "_currency",
+            "currency_fx_rate",
+            "market_share",
+            "market_capitalization",
+            "currency_fx_rate",
+            "price",
+            "price_fx_portfolio",
+            "total_value",
+            "total_value_fx_usd",
+            "total_value_fx_portfolio",
+            "liquidity",
+            "is_estimated",
+            "underlying_instrument_name",
+            "underlying_instrument_isin",
+            "underlying_instrument_ticker",
+            "underlying_instrument",
+            "_underlying_instrument",
+            "_portfolio",
+            "_portfolio_created",
+            "_exchange",
+            "exchange",
+            "is_invested",
+            "_additional_resources",
+            "currency_symbol",
+            "portfolio_currency_symbol",
+        )
+
+
+class AssetPositionPortfolioModelSerializer(AssetPositionModelSerializer):
+    _portfolio = None
+
+    class Meta(AssetPositionModelSerializer.Meta):
+        fields = (
+            "id",
+            "is_estimated",
+            "underlying_instrument_name",
+            "underlying_instrument_isin",
+            "underlying_instrument_ticker",
+            "underlying_instrument",
+            "_underlying_instrument",
+            "currency",
+            "_currency",
+            "exchange",
+            "_exchange",
+            "price",
+            "shares",
+            "total_value",
+            "currency_fx_rate",
+            "total_value_fx_portfolio",
+            "total_value_fx_usd",
+            "weighting",
+            "portfolio_created",
+            "_portfolio_created",
+            "market_share",
+            "asset_valuation_date",
+            "liquidity",
+            "currency_symbol",
+            "portfolio_currency_symbol",
+        )
+        read_only_fields = fields
+
+
+class AssetPositionAggregatedPortfolioModelSerializer(AssetPositionPortfolioModelSerializer):
+    # If the aggregated serializer is used, we only show the related model representation for performance
+    currency = wb_serializers.CharField()
+
+    class Meta(AssetPositionModelSerializer.Meta):
+        fields = (
+            "id",
+            "is_estimated",
+            "underlying_instrument_isin",
+            "underlying_instrument_ticker",
+            "underlying_instrument_name",
+            "currency",
+            "price",
+            "shares",
+            "total_value",
+            "currency_fx_rate",
+            "total_value_fx_portfolio",
+            "total_value_fx_usd",
+            "weighting",
+            "market_share",
+            "asset_valuation_date",
+            "liquidity",
+            "currency_symbol",
+            "portfolio_currency_symbol",
+        )
+        read_only_fields = fields
+
+
+class AssetPositionInstrumentModelSerializer(AssetPositionModelSerializer):
+    class Meta(AssetPositionModelSerializer.Meta):
+        fields = AssetPositionModelSerializer.Meta.fields
+
+
+class CashPositionPortfolioModelSerializer(wb_serializers.ModelSerializer):
+    _portfolio = PortfolioRepresentationSerializer(source="portfolio")
+    sum_total_value_fx_usd = wb_serializers.FloatField(read_only=True)
+    portfolio = wb_serializers.PrimaryKeyRelatedField(queryset=Portfolio.objects.all())
+
+    class Meta:
+        decorators = {
+            "sum_total_value_fx_usd": wb_serializers.decorator(decorator_type="text", position="left", value="$")
+        }
+        model = AssetPosition
+        fields = ("id", "portfolio", "_portfolio", "sum_total_value_fx_usd", "date", "_additional_resources")

wbportfolio/serializers/custodians.py

@@ -0,0 +1,26 @@
+from rest_framework.reverse import reverse
+from wbcore import serializers as wb_serializers
+from wbportfolio.models import Custodian
+
+
+class CustodianRepresentationSerializer(wb_serializers.RepresentationSerializer):
+    _detail = wb_serializers.HyperlinkField(reverse_name="wbportfolio:custodian-detail")
+
+    class Meta:
+        model = Custodian
+        fields = ("id", "name", "_detail")
+
+
+class CustodianModelSerializer(wb_serializers.ModelSerializer):
+    @wb_serializers.register_resource()
+    def _addition_resources(self, instance, request, user):
+        res = {
+            "merge": reverse("wbportfolio:custodian-merge", args=[instance.id], request=request),
+        }
+        if len(instance.mapping) > 1:
+            res["split"] = reverse("wbportfolio:custodian-split", args=[instance.id], request=request)
+        return res
+
+    class Meta:
+        model = Custodian
+        fields = ("id", "name", "mapping", "_additional_resources")

wbportfolio/serializers/portfolio_cash_flow.py

@@ -0,0 +1,48 @@
+from datetime import date, timedelta
+
+from rest_framework.exceptions import ValidationError
+from wbcore import serializers
+from wbportfolio.models.portfolio_cash_flow import DailyPortfolioCashFlow
+from wbportfolio.serializers.portfolios import PortfolioRepresentationSerializer
+
+
+class DailyPortfolioCashFlowModelSerializer(serializers.ModelSerializer):
+    swing_pricing_indicator = serializers.CharField(read_only=True)
+    _portfolio = PortfolioRepresentationSerializer(source="portfolio")
+
+    def validate(self, data):
+        # We explictly forbit changing any data that is older than 1 week
+        if value_date := data.get("value_date", getattr(self.instance, "value_date", None)):
+            if value_date < (date.today() - timedelta(days=7)) and not self.context["request"].user.has_perm(
+                "administrate_dailyportfoliocashflow"
+            ):
+                raise ValidationError({"non_field_errors": ["Changing entries older than 1 week is prohibited."]})
+
+        return data
+
+    class Meta:
+        model = DailyPortfolioCashFlow
+        percent_fields = ["true_cash_pct", "cash_pct", "target_cash_pct", "cash_flow_asset_ratio"]
+        override_decimal_places = 0
+        fields = (
+            "id",
+            "value_date",
+            "portfolio",
+            "_portfolio",
+            "cash",
+            "cash_pct",
+            "cash_flow_forecast",
+            "total_assets",
+            "estimated_total_assets",
+            "cash_flow_asset_ratio",
+            "swing_pricing_indicator",
+            "true_cash",
+            "true_cash_pct",
+            "target_cash",
+            "target_cash_pct",
+            "excess_cash",
+            "proposed_rebalancing",
+            "rebalancing",
+            "pending",
+            "comment",
+        )

wbportfolio/serializers/portfolio_cash_targets.py

@@ -0,0 +1,20 @@
+from wbcore import serializers
+from wbportfolio.models.portfolio_cash_targets import PortfolioCashTarget
+from wbportfolio.serializers.portfolios import PortfolioRepresentationSerializer
+
+
+class PortfolioCashTargetModelSerializer(serializers.ModelSerializer):
+    _portfolio = PortfolioRepresentationSerializer(source="portfolio")
+
+    class Meta:
+        model = PortfolioCashTarget
+        fields = (
+            "id",
+            "portfolio",
+            "_portfolio",
+            "valid_date",
+            "min_target",
+            "target",
+            "max_target",
+            "comment",
+        )

wbportfolio/serializers/portfolio_relationship.py

@@ -0,0 +1,53 @@
+from wbcore import serializers as wb_serializers
+from wbfdm.serializers import (
+    ClassifiableInstrumentRepresentationSerializer,
+    ClassificationIsFavoriteZeroHeightRepresentationSerializer,
+    ManagedInstrumentRepresentationSerializer,
+)
+from wbfdm.serializers.instruments.classifications import (
+    ClassificationGroupRepresentationSerializer,
+)
+from wbportfolio.models.portfolio_relationship import (
+    InstrumentPortfolioThroughModel,
+    PortfolioInstrumentPreferredClassificationThroughModel,
+)
+
+from .portfolios import PortfolioRepresentationSerializer
+
+
+class InstrumentPortfolioThroughModelSerializer(wb_serializers.ModelSerializer):
+    _portfolio = PortfolioRepresentationSerializer(source="portfolio")
+    _instrument = ManagedInstrumentRepresentationSerializer(source="instrument")
+
+    class Meta:
+        model = InstrumentPortfolioThroughModel
+        fields = (
+            "id",
+            "_portfolio",
+            "portfolio",
+            "_instrument",
+            "instrument",
+        )
+
+
+class InstrumentPreferedClassificationThroughProductModelSerializer(wb_serializers.ModelSerializer):
+    _instrument = ClassifiableInstrumentRepresentationSerializer(source="instrument")
+    _classification = ClassificationIsFavoriteZeroHeightRepresentationSerializer(
+        source="classification", optional_get_parameters={"instrument": "instrument"}
+    )
+    _classification_group = ClassificationGroupRepresentationSerializer(source="classification_group")
+
+    class Meta:
+        model = PortfolioInstrumentPreferredClassificationThroughModel
+        dependency_map = {"classification": ["instrument"]}
+        fields = (
+            "id",
+            "portfolio",
+            "_instrument",
+            "instrument",
+            "_classification",
+            "classification",
+            "classification_group",
+            "_classification_group",
+            "_additional_resources",
+        )

wbportfolio/serializers/portfolio_swing_pricing.py

@@ -0,0 +1,20 @@
+from wbcore import serializers
+from wbportfolio.models.portfolio_swing_pricings import PortfolioSwingPricing
+from wbportfolio.serializers.portfolios import PortfolioRepresentationSerializer
+
+
+class PortfolioSwingPricingModelSerializer(serializers.ModelSerializer):
+    _portfolio = PortfolioRepresentationSerializer(source="portfolio")
+
+    class Meta:
+        model = PortfolioSwingPricing
+        fields = (
+            "id",
+            "portfolio",
+            "_portfolio",
+            "valid_date",
+            "negative_threshold",
+            "negative_swing_factor",
+            "positive_threshold",
+            "positive_threshold",
+        )

wbportfolio/serializers/portfolios.py

@@ -0,0 +1,143 @@
+from rest_framework.reverse import reverse
+from wbcore import serializers as wb_serializers
+from wbcore.contrib.currency.serializers import CurrencyRepresentationSerializer
+from wbcore.contrib.directory.models import BankingContact
+from wbportfolio.models import Portfolio, PortfolioPortfolioThroughModel
+from wbportfolio.serializers.synchronization import (
+    PortfolioSynchronizationRepresentationSerializer,
+)
+
+
+class PortfolioRepresentationSerializer(wb_serializers.RepresentationSerializer):
+    _detail = wb_serializers.HyperlinkField(reverse_name="wbportfolio:portfolio-detail")
+    _detail_preview = wb_serializers.HyperlinkField(reverse_name="wbportfolio:portfolio-detail")
+
+    class Meta:
+        model = Portfolio
+        fields = ("id", "name", "_detail", "_detail_preview")
+
+
+class PortfolioModelSerializer(wb_serializers.ModelSerializer):
+    _currency = CurrencyRepresentationSerializer(source="currency")
+    _depends_on = PortfolioRepresentationSerializer(source="depends_on", many=True)
+    _portfolio_synchronization = PortfolioSynchronizationRepresentationSerializer(source="portfolio_synchronization")
+    dependent_portfolios = wb_serializers.PrimaryKeyRelatedField(
+        many=True, read_only=True, label="Dependency Portfolios"
+    )
+    _dependent_portfolios = PortfolioSynchronizationRepresentationSerializer(many=True, source="dependent_portfolios")
+
+    @wb_serializers.register_only_instance_resource()
+    def cash_management(self, instance, request, user, **kwargs):
+        additional_resources = dict()
+        if instance.daily_cashflows.exists():
+            additional_resources["daily_cashflows"] = reverse(
+                "wbportfolio:portfolio-portfoliocashflow-list", args=[instance.id], request=request
+            )
+        b = BankingContact.objects.filter(wbportfolio_products__id__in=instance.instruments.all().values("id"))
+        if b.exists():
+            base_url = reverse("wbaccounting:futurecashflow-list", request=request)
+            additional_resources[
+                "cash_flow"
+            ] = f'{base_url}?banking_contact={",".join([str(i) for i in b.distinct("id").values_list("id", flat=True)])}'
+
+        return additional_resources
+
+    @wb_serializers.register_only_instance_resource()
+    def additional_resources(self, instance, request, user, **kwargs):
+        additional_resources = dict()
+        additional_resources["distribution_chart"] = reverse(
+            "wbportfolio:portfolio-distributionchart-list", args=[instance.id], request=request
+        )
+        additional_resources["distribution_table"] = reverse(
+            "wbportfolio:portfolio-distributiontable-list", args=[instance.id], request=request
+        )
+        if instance.assets.exists():
+            additional_resources["assets"] = reverse(
+                "wbportfolio:portfolio-asset-list", args=[instance.id], request=request
+            )
+            additional_resources["contributor"] = reverse(
+                "wbportfolio:portfolio-contributor-list",
+                args=[instance.id],
+                request=request,
+            )
+        if user.profile.is_internal:
+            additional_resources["instruments"] = reverse(
+                "wbportfolio:portfolio-instrument-list",
+                args=[instance.id],
+                request=request,
+            )
+
+        if instance.portfolio_synchronization:
+            additional_resources["resynchronize"] = reverse(
+                "wbportfolio:portfolio-resynchronize",
+                args=[instance.id],
+                request=request,
+            )
+        additional_resources["dependencyportfolios"] = reverse(
+            "wbportfolio:portfolio-dependencyportfolio-list",
+            args=[instance.id],
+            request=request,
+        )
+        additional_resources["trade_proposals"] = reverse(
+            "wbportfolio:portfolio-tradeproposal-list",
+            args=[instance.id],
+            request=request,
+        )
+
+        additional_resources["preferredclassification"] = reverse(
+            "wbportfolio:portfolio-preferredclassification-list",
+            args=[instance.id],
+            request=request,
+        )
+        additional_resources["modelcomposition"] = reverse(
+            "wbportfolio:portfolio-modelcompositionpandas-list",
+            args=[instance.id],
+            request=request,
+        )
+
+        return additional_resources
+
+    class Meta:
+        model = Portfolio
+        fields = (
+            "id",
+            "name",
+            "last_synchronization",
+            "_depends_on",
+            "_portfolio_synchronization",
+            "depends_on",
+            "portfolio_synchronization",
+            "_dependent_portfolios",
+            "dependent_portfolios",
+            "_currency",
+            "currency",
+            "_additional_resources",
+        )
+
+
+class ModelPortfolioModelSerializer(PortfolioModelSerializer):
+    @wb_serializers.register_only_instance_resource()
+    def rebalance(self, instance, request, user, **kwargs):
+        return {
+            "modelcomposition": reverse(
+                "wbportfolio:portfolio-modelcompositionpandas-list",
+                args=[instance.id],
+                request=request,
+            )
+        }
+
+
+class PortfolioPortfolioThroughModelSerializer(wb_serializers.ModelSerializer):
+    _portfolio = PortfolioRepresentationSerializer(source="portfolio")
+    _dependency_portfolio = PortfolioRepresentationSerializer(source="dependency_portfolio")
+
+    class Meta:
+        model = PortfolioPortfolioThroughModel
+        fields = (
+            "id",
+            "_portfolio",
+            "portfolio",
+            "_dependency_portfolio",
+            "dependency_portfolio",
+            "type",
+        )

wbportfolio/serializers/positions.py

@@ -0,0 +1,76 @@
+from wbcore import serializers as wb_serializers
+from wbportfolio.models import AssetPosition
+
+
+class AggregatedAssetPositionModelSerializer(wb_serializers.ModelSerializer):
+    id = wb_serializers.PrimaryKeyCharField()
+    aggregated_title = wb_serializers.CharField(read_only=True)
+
+    sum_total_value_start = wb_serializers.DecimalField(read_only=True, max_digits=16, decimal_places=4)
+    sum_total_value = wb_serializers.DecimalField(read_only=True, max_digits=16, decimal_places=4)
+    weighting = wb_serializers.DecimalField(
+        read_only=True,
+        max_digits=6,
+        decimal_places=4,
+        percent=True,
+        decorators=[{"position": "right", "value": "%"}],
+    )
+    performance = wb_serializers.DecimalField(
+        read_only=True,
+        max_digits=6,
+        decimal_places=4,
+        percent=True,
+        decorators=[{"position": "right", "value": "%"}],
+    )
+    performance_local = wb_serializers.DecimalField(
+        read_only=True,
+        max_digits=6,
+        decimal_places=4,
+        percent=True,
+        decorators=[{"position": "right", "value": "%"}],
+    )
+    contribution = wb_serializers.DecimalField(
+        read_only=True,
+        max_digits=6,
+        decimal_places=4,
+        percent=True,
+        decorators=[{"position": "right", "value": "%"}],
+    )
+    contribution_local = wb_serializers.DecimalField(
+        read_only=True,
+        max_digits=6,
+        decimal_places=4,
+        percent=True,
+        decorators=[{"position": "right", "value": "%"}],
+    )
+    difference_performance = wb_serializers.DecimalField(
+        read_only=True,
+        max_digits=6,
+        decimal_places=4,
+        percent=True,
+        decorators=[{"position": "right", "value": "%"}],
+    )
+    difference_contribution = wb_serializers.DecimalField(
+        read_only=True,
+        max_digits=6,
+        decimal_places=4,
+        percent=True,
+        decorators=[{"position": "right", "value": "%"}],
+    )
+
+    class Meta:
+        model = AssetPosition
+        fields = (
+            "id",
+            "aggregated_title",
+            "sum_total_value_start",
+            "sum_total_value",
+            "weighting",
+            "performance",
+            "performance_local",
+            "contribution",
+            "contribution_local",
+            "difference_performance",
+            "difference_contribution",
+            "_additional_resources",
+        )

wbportfolio/serializers/product_group.py

@@ -0,0 +1,88 @@
+from wbcore import serializers as wb_serializers
+from wbcore.contrib.directory.models import Company
+from wbcore.contrib.directory.serializers import CompanyRepresentationSerializer
+from wbcore.contrib.geography.serializers import GeographyRepresentationSerializer
+from wbfdm.serializers.instruments import InstrumentModelSerializer
+from wbportfolio.models import ProductGroup, ProductGroupRepresentant
+from wbportfolio.serializers.portfolios import PortfolioRepresentationSerializer
+
+
+class ProductGroupRepresentantRepresentationSerializer(wb_serializers.RepresentationSerializer):
+    _representant = CompanyRepresentationSerializer(source="representant")
+    _country = GeographyRepresentationSerializer(source="country", filter_params={"level": 1})
+
+    class Meta:
+        model = ProductGroupRepresentant
+        fields = (
+            "id",
+            "product_group",
+            "representant",
+            "_representant",
+            "country",
+            "_country",
+        )
+
+
+class ProductGroupRepresentationSerializer(wb_serializers.RepresentationSerializer):
+    _detail = wb_serializers.HyperlinkField(reverse_name="wbportfolio:product_group-detail")
+
+    class Meta:
+        model = ProductGroup
+        fields = ("id", "computed_str", "name_repr", "_detail")
+
+
+class ProductGroupModelSerializer(InstrumentModelSerializer):
+    id_repr = wb_serializers.CharField(source="id", read_only=True, label="ID")
+    _management_company = CompanyRepresentationSerializer(source="management_company")
+    management_company = wb_serializers.PrimaryKeyRelatedField(
+        queryset=Company.objects.all().select_related("entry_ptr")
+    )
+
+    _depositary = CompanyRepresentationSerializer(source="depositary")
+    depositary = wb_serializers.PrimaryKeyRelatedField(queryset=Company.objects.all().select_related("entry_ptr"))
+
+    _transfer_agent = CompanyRepresentationSerializer(source="transfer_agent")
+    transfer_agent = wb_serializers.PrimaryKeyRelatedField(queryset=Company.objects.all().select_related("entry_ptr"))
+
+    _administrator = CompanyRepresentationSerializer(source="administrator")
+    administrator = wb_serializers.PrimaryKeyRelatedField(queryset=Company.objects.all().select_related("entry_ptr"))
+
+    _investment_manager = CompanyRepresentationSerializer(source="investment_manager")
+    investment_manager = wb_serializers.PrimaryKeyRelatedField(
+        queryset=Company.objects.all().select_related("entry_ptr")
+    )
+
+    _auditor = CompanyRepresentationSerializer(source="auditor")
+    auditor = wb_serializers.PrimaryKeyRelatedField(queryset=Company.objects.all().select_related("entry_ptr"))
+
+    _paying_agent = CompanyRepresentationSerializer(source="paying_agent")
+    paying_agent = wb_serializers.PrimaryKeyRelatedField(queryset=Company.objects.all().select_related("entry_ptr"))
+
+    _portfolios = PortfolioRepresentationSerializer(source="portfolios", many=True)
+
+    class Meta(InstrumentModelSerializer.Meta):
+        model = ProductGroup
+        fields = (
+            "id_repr",
+            "type",
+            "category",
+            "umbrella",
+            "management_company",
+            "_management_company",
+            "depositary",
+            "_depositary",
+            "transfer_agent",
+            "_transfer_agent",
+            "administrator",
+            "_administrator",
+            "investment_manager",
+            "_investment_manager",
+            "auditor",
+            "_auditor",
+            "paying_agent",
+            "_paying_agent",
+            "representants",
+            # "_representants",
+            "_portfolios",
+            "portfolios",
+        ) + InstrumentModelSerializer.Meta.fields