wbportfolio 2.2.1__py2.py3-none-any.whl

wbportfolio/risk_management/tests/test_controversy_portfolio.py

@@ -0,0 +1,33 @@
+import pytest
+from faker import Faker
+from wbfdm.enums import ESGControveryFlag
+from wbportfolio.risk_management.backends.controversy_portfolio import (
+    RuleBackend as ControversyPortfolio,
+)
+from wbportfolio.tests.models.utils import PortfolioTestMixin
+
+fake = Faker()
+
+
+@pytest.mark.django_db
+class TestControversyPortfolioRUle(PortfolioTestMixin):
+    @pytest.mark.parametrize("flag", ESGControveryFlag.values)
+    def test_check_rule_exclude(
+        self, weekday, portfolio, asset_position_factory, controversy_factory, rule_threshold, flag
+    ):
+        rule_backend = ControversyPortfolio(
+            weekday, portfolio, thresholds=[rule_threshold], json_parameters={"flags": [flag]}
+        )
+        a1 = asset_position_factory.create(portfolio=portfolio, date=weekday)
+        asset_position_factory.create(portfolio=portfolio, date=weekday)  # noise position
+
+        # No controversy yet, so this shouldn't trigger the rule
+        res = list(rule_backend.check_rule())
+        assert len(res) == 0
+
+        controversy = controversy_factory.create(flag=flag, instrument=a1.underlying_instrument)  # noqa
+
+        res = list(rule_backend.check_rule())[0]
+        assert res.breached_object == a1.underlying_instrument
+        assert res.breached_object_repr == str(a1.underlying_instrument)
+        assert res.severity == rule_threshold.severity

wbportfolio/risk_management/tests/test_exposure_portfolio.py

@@ -0,0 +1,94 @@
+import random
+
+import pytest
+from faker import Faker
+from psycopg.types.range import NumericRange
+from wbcompliance.factories.risk_management import RuleThresholdFactory
+from wbportfolio.risk_management.backends.exposure_portfolio import (
+    RuleBackend as ExposurePortfolioRuleBackend,
+)
+from wbportfolio.tests.models.utils import PortfolioTestMixin
+
+fake = Faker()
+
+
+@pytest.mark.django_db
+class TestExposurePortfolioRuleModel(PortfolioTestMixin):
+    @pytest.mark.parametrize(
+        "group_by",
+        [groupby for groupby in ExposurePortfolioRuleBackend.GroupbyChoices.values],
+    )
+    def test_check_rule_groupby_weighting(
+        self,
+        weekday,
+        group_by,
+        instrument_factory,
+        cash_factory,
+        asset_position_factory,
+        instrument_price_factory,
+        country_factory,
+        currency_factory,
+        instrument_type_factory,
+        portfolio,
+        classification,
+    ):
+        only_type = instrument_type_factory.create()
+        only_country = country_factory.create()
+        only_currency = currency_factory.create()
+        parameters = {
+            "group_by": group_by,
+            "field": ExposurePortfolioRuleBackend.Field.WEIGHTING.value,
+            "asset_classes": [only_type.id],
+            "countries": [only_country.id],
+            "currencies": [only_currency.id],
+            "classifications": [classification.id],
+        }
+
+        lower = random.random()
+        upper = random.uniform(lower, 1)
+        exposure_portfolio_backend = ExposurePortfolioRuleBackend(
+            weekday,
+            portfolio,
+            parameters,
+            [RuleThresholdFactory.create(range=NumericRange(lower=lower, upper=upper))],  # type: ignore
+        )
+
+        i1 = instrument_factory.create(
+            country=only_country, currency=only_currency, instrument_type=only_type, classifications=[classification]
+        )
+
+        threshold = exposure_portfolio_backend.thresholds[0]
+        instrument_price_factory.create(instrument=i1, date=weekday)
+        asset_position_factory.create(
+            date=weekday,
+            weighting=random.uniform(threshold.range.lower, threshold.range.upper),
+            underlying_instrument=i1,
+            portfolio=portfolio,
+        )  # Breached position
+
+        asset_position_factory.create(
+            date=weekday,
+            weighting=random.uniform(threshold.range.lower, threshold.range.upper),
+            portfolio=portfolio,
+        )  # Breached position but filtered out
+
+        i2 = cash_factory.create()
+        instrument_price_factory.create(instrument=i2, date=weekday)
+        asset_position_factory.create(
+            date=weekday,
+            weighting=random.uniform(0, threshold.range.lower),
+            underlying_instrument=i2,
+            portfolio=portfolio,
+        )  # None breached position
+
+        incidents = list(exposure_portfolio_backend.check_rule())
+        assert len(incidents) == 1
+        if group_by == ExposurePortfolioRuleBackend.GroupbyChoices.CURRENCY:
+            assert incidents[0].breached_object == only_currency
+        elif group_by == ExposurePortfolioRuleBackend.GroupbyChoices.COUNTRY:
+            assert incidents[0].breached_object == only_country
+        elif group_by in [
+            ExposurePortfolioRuleBackend.GroupbyChoices.PRIMARY_CLASSIFICATION,
+            ExposurePortfolioRuleBackend.GroupbyChoices.FAVORITE_CLASSIFICATION,
+        ]:
+            assert incidents[0].breached_object == classification

wbportfolio/risk_management/tests/test_instrument_list_portfolio.py

@@ -0,0 +1,60 @@
+import pytest
+from faker import Faker
+from wbfdm.models.instruments.instrument_lists import InstrumentListThroughModel
+from wbportfolio.risk_management.backends.instrument_list_portfolio import (
+    RuleBackend as InstrumentListPortfolio,
+)
+from wbportfolio.tests.models.utils import PortfolioTestMixin
+
+fake = Faker()
+
+
+@pytest.mark.django_db
+class TestInstrumentListPortfolio(PortfolioTestMixin):
+    def test_check_rule_exclude(self, weekday, portfolio, asset_position_factory, instrument_list, rule_threshold):
+        rule_backend = InstrumentListPortfolio(
+            weekday, portfolio, json_parameters={"instrument_lists": [instrument_list.id]}, thresholds=[rule_threshold]
+        )
+        a1 = asset_position_factory.create(portfolio=portfolio, date=weekday)
+        asset_position_factory.create(portfolio=portfolio, date=weekday)  # noise position
+
+        rel = InstrumentListThroughModel.objects.create(
+            instrument=a1.underlying_instrument, instrument_list=instrument_list, validated=False
+        )
+        # we check that even though the insturment is in the list, it's still not validated, so this shouldn't trigger the rule
+        res = list(rule_backend.check_rule())
+        assert len(res) == 0
+
+        rel.validated = True
+        rel.save()
+        res = list(rule_backend.check_rule())[0]
+        assert res.breached_object == a1.underlying_instrument
+        assert res.breached_object_repr == str(a1.underlying_instrument)
+        assert res.severity == rule_threshold.severity
+
+    def test_check_rule_include(self, weekday, portfolio, asset_position_factory, instrument_list, rule_threshold):
+        rule_backend = InstrumentListPortfolio(
+            weekday,
+            portfolio,
+            json_parameters={"exclude": False, "instrument_lists": [instrument_list.id]},
+            thresholds=[rule_threshold],
+        )
+        a1 = asset_position_factory.create(portfolio=portfolio, date=weekday)
+        a2 = asset_position_factory.create(portfolio=portfolio, date=weekday)
+
+        InstrumentListThroughModel.objects.create(
+            instrument=a1.underlying_instrument, instrument_list=instrument_list, validated=True
+        )
+        InstrumentListThroughModel.objects.create(
+            instrument=a2.underlying_instrument, instrument_list=instrument_list, validated=True
+        )
+        # ground truth
+        res = list(rule_backend.check_rule())
+        assert len(res) == 0
+
+        a3 = asset_position_factory.create(portfolio=portfolio, date=weekday)
+
+        res = list(rule_backend.check_rule())[0]
+        assert res.breached_object == a3.underlying_instrument
+        assert res.breached_object_repr == str(a3.underlying_instrument)
+        assert res.severity == rule_threshold.severity

wbportfolio/risk_management/tests/test_liquidity_risk.py

@@ -0,0 +1,47 @@
+import pytest
+from faker import Faker
+from psycopg.types.range import NumericRange
+from wbcompliance.factories.risk_management import RuleThresholdFactory
+from wbportfolio.risk_management.backends.liquidity_risk import (
+    RuleBackend as LiquidityRiskRuleBackend,
+)
+
+fake = Faker()
+
+
+@pytest.mark.django_db
+class TestProductRuleModel:
+    @pytest.fixture
+    def liquidity_risk_backend(
+        self,
+        weekday,
+        instrument,
+    ):
+        return LiquidityRiskRuleBackend(
+            weekday,
+            instrument,
+            json_parameters={"liquidation_factor": 3, "redemption_pct": 0.80},
+            thresholds=[
+                RuleThresholdFactory.create(range=NumericRange(lower=5, upper=None)),
+            ],
+        )
+
+    def test_check_rule_product_liquidity(
+        self, weekday, instrument, instrument_price_factory, asset_position_factory, liquidity_risk_backend
+    ):
+        res = list(liquidity_risk_backend.check_rule())  # no position, no risk incident
+        assert len(res) == 0
+
+        shares = 100
+
+        volume_50d = (shares * liquidity_risk_backend.redemption_pct * liquidity_risk_backend.liquidation_factor) / 6
+        instrument_price_factory.create(date=weekday, instrument=instrument, volume_50d=volume_50d, calculated=False)
+        asset_position_factory.create(
+            date=weekday, underlying_instrument=instrument, is_estimated=False, initial_shares=shares
+        )
+
+        res = list(liquidity_risk_backend.check_rule())  # no position, no risk incident
+        assert len(res) == 1
+        incident = res[0]
+        assert incident.report_details["Total Shares"] == shares
+        assert incident.report_details["Volume 50D"] == volume_50d

wbportfolio/risk_management/tests/test_product_integrity.py

@@ -0,0 +1,55 @@
+import pytest
+from faker import Faker
+from pandas.tseries.offsets import BDay
+from psycopg.types.range import NumericRange
+from wbcompliance.factories.risk_management import RuleThresholdFactory
+from wbportfolio.risk_management.backends.product_integrity import (
+    RuleBackend as ProductRuleBackend,
+)
+
+fake = Faker()
+
+
+@pytest.mark.django_db
+class TestProductRuleModel:
+    @pytest.fixture
+    def product_backend(
+        self,
+        weekday,
+        product,
+    ):
+        return ProductRuleBackend(
+            weekday,
+            product,
+            thresholds=[
+                RuleThresholdFactory.create(range=NumericRange(lower=1, upper=2), severity__name="LOW"),
+                RuleThresholdFactory.create(range=NumericRange(lower=2, upper=None), severity__name="HIGH"),
+            ],  # detect any -20% perf
+        )
+
+    def test_check_rule_product_data_integrity(
+        self, weekday, product, instrument_price_factory, asset_position_factory, product_backend
+    ):
+        asset_position_factory.create(date=weekday - BDay(2), portfolio=product.portfolio, is_estimated=False)
+        instrument_price_factory.create(date=weekday - BDay(1), instrument=product, calculated=False)
+
+        res = list(product_backend.check_rule())
+        low_severity = list(filter(lambda x: x.severity.name == "LOW", res))[0]
+        high_severity = list(filter(lambda x: x.severity.name == "HIGH", res))[0]
+
+        assert high_severity.report_details["Data Type"] == "Asset Position"
+        assert low_severity.report_details["Data Type"] == "Valuation"
+        assert high_severity.report_details["Last Datapoint"] == f"{(weekday - BDay(2)).date():%d.%m.%Y}"
+        assert low_severity.report_details["Last Datapoint"] == f"{(weekday - BDay(1)).date():%d.%m.%Y}"
+
+        instrument_price_factory.create(date=weekday, instrument=product, calculated=False)
+        asset_position_factory.create(date=weekday - BDay(1), portfolio=product.portfolio, is_estimated=False)
+
+        res = list(product_backend.check_rule())
+        assert len(res) == 1
+        assert res[0].report_details["Data Type"] == "Asset Position"
+        assert res[0].report_details["Last Datapoint"] == f"{(weekday - BDay(1)).date():%d.%m.%Y}"
+
+        asset_position_factory.create(date=weekday, portfolio=product.portfolio, is_estimated=False)
+        res = list(product_backend.check_rule())
+        assert len(res) == 0

wbportfolio/risk_management/tests/test_stop_loss_instrument.py

@@ -0,0 +1,110 @@
+import random
+from decimal import Decimal
+
+import pytest
+from faker import Faker
+from psycopg.types.range import NumericRange
+from wbcompliance.factories.risk_management import RuleThresholdFactory
+from wbfdm.models import RelatedInstrumentThroughModel
+from wbportfolio.risk_management.backends.stop_loss_instrument import (
+    RuleBackend as StopLossInstrumentRuleBackend,
+)
+from wbportfolio.tests.models.utils import PortfolioTestMixin
+
+fake = Faker()
+
+
+@pytest.mark.django_db
+class TestStopLossInstrumentRuleModel(PortfolioTestMixin):
+    @pytest.fixture
+    def stop_loss_instrument_backend(self, weekday, date_interval_option, freq, product):
+        parameters = {"freq": freq, "date_interval_option": date_interval_option}
+        lower = random.random()
+        upper = random.uniform(lower, 1)
+        return StopLossInstrumentRuleBackend(
+            weekday,
+            product,
+            parameters,
+            [RuleThresholdFactory.create(range=NumericRange(lower=lower, upper=upper))],  # type: ignore
+        )
+
+    @pytest.mark.parametrize(
+        "date_interval_option, freq",
+        [
+            ("ROLLING_WINDOWS", StopLossInstrumentRuleBackend.FreqChoices.BUSINESS_DAY),
+            *[("FREQUENCY", option) for option in StopLossInstrumentRuleBackend.FreqChoices.values],
+        ],
+    )
+    def test_check_rule_frequency(
+        self,
+        weekday,
+        date_interval_option,
+        freq,
+        product,
+        instrument_price_factory,
+        stop_loss_instrument_backend,
+    ):
+        d1 = stop_loss_instrument_backend._get_start_interval()
+        threshold = stop_loss_instrument_backend.thresholds[0]
+
+        breach_perf = random.uniform(threshold.range.lower, threshold.range.upper)
+
+        i1 = instrument_price_factory.create(date=d1, net_value=100, calculated=False, instrument=product)
+        instrument_price_factory.create(
+            date=weekday, net_value=Decimal(breach_perf + 1) * i1.net_value, calculated=False, instrument=product
+        )
+
+        res = list(stop_loss_instrument_backend.check_rule())
+        assert len(res) == 1
+        assert res[0].breached_object.id == product.id
+
+    @pytest.mark.parametrize(
+        "date_interval_option, freq",
+        [
+            ("FREQUENCY", StopLossInstrumentRuleBackend.FreqChoices.WEEKLY_FRIDAY),
+            ("ROLLING_WINDOWS", StopLossInstrumentRuleBackend.FreqChoices.WEEKLY_FRIDAY),
+        ],
+    )
+    def test_check_rule_frequency_with_benchmark(
+        self,
+        weekday,
+        date_interval_option,
+        freq,
+        product,
+        instrument_factory,
+        instrument_price_factory,
+        stop_loss_instrument_backend,
+    ):
+        benchmark = instrument_factory.create()
+
+        threshold = stop_loss_instrument_backend.thresholds[0]
+        threshold.range = NumericRange(upper=-0.5, lower=None)  # type: ignore
+        threshold.save()
+
+        d1 = stop_loss_instrument_backend._get_start_interval()
+
+        instrument_price_factory.create(date=d1, net_value=100, calculated=False, instrument=product)
+        instrument_price_factory.create(date=weekday, net_value=100, calculated=False, instrument=product)
+
+        instrument_price_factory.create(date=d1, net_value=500, calculated=False, instrument=benchmark)
+        benchmark_price_2 = instrument_price_factory.create(
+            date=weekday, net_value=500, calculated=False, instrument=benchmark
+        )
+        RelatedInstrumentThroughModel.objects.create(instrument=product, related_instrument=benchmark, is_primary=True)
+        setattr(stop_loss_instrument_backend, "dynamic_benchmark_type", "PRIMARY_BENCHMARK")
+
+        res = list(stop_loss_instrument_backend.check_rule())
+        assert len(res) == 0
+
+        # artificially
+        benchmark_price_2.net_value = 1000
+        benchmark_price_2.save()
+
+        res = list(stop_loss_instrument_backend.check_rule())
+        assert len(res) == 1
+        assert res[0].breached_object.id == product.id
+
+        setattr(stop_loss_instrument_backend, "static_benchmark", benchmark)
+        res = list(stop_loss_instrument_backend.check_rule())
+        assert len(res) == 1
+        assert res[0].breached_object.id == product.id

wbportfolio/risk_management/tests/test_stop_loss_portfolio.py

@@ -0,0 +1,119 @@
+import random
+from decimal import Decimal
+
+import pytest
+from faker import Faker
+from psycopg.types.range import NumericRange
+from wbcompliance.factories.risk_management import RuleThresholdFactory
+from wbportfolio.risk_management.backends.stop_loss_instrument import (
+    RuleBackend as StopLossInstrumentRuleBackend,
+)
+from wbportfolio.tests.models.utils import PortfolioTestMixin
+
+fake = Faker()
+
+
+@pytest.mark.django_db
+class TestStopLossPortfolioRuleModel(PortfolioTestMixin):
+    @pytest.fixture
+    def stop_loss_portfolio_backend(self, weekday, date_interval_option, freq, product):
+        parameters = {"freq": freq, "date_interval_option": date_interval_option}
+        lower = random.random()
+        upper = random.uniform(lower, 1)
+        return StopLossInstrumentRuleBackend(
+            weekday,
+            product,
+            parameters,
+            [RuleThresholdFactory.create(range=NumericRange(lower=lower, upper=upper))],  # type: ignore
+        )
+
+    @pytest.mark.parametrize(
+        "date_interval_option, freq",
+        [
+            ("ROLLING_WINDOWS", StopLossInstrumentRuleBackend.FreqChoices.BUSINESS_DAY),
+            *[("FREQUENCY", option) for option in StopLossInstrumentRuleBackend.FreqChoices.values],
+        ],
+    )
+    def test_check_rule_frequency(
+        self,
+        weekday,
+        date_interval_option,
+        freq,
+        product,
+        portfolio,
+        instrument_price_factory,
+        asset_position_factory,
+        stop_loss_portfolio_backend,
+        instrument_portfolio_through_model_factory,
+    ):
+        instrument_portfolio_through_model_factory.create(
+            instrument=product,
+            portfolio=portfolio,
+            primary_portfolio=True,
+        )
+
+        d1 = stop_loss_portfolio_backend._get_start_interval()
+
+        threshold = stop_loss_portfolio_backend.thresholds[0]
+        breach_perf = random.uniform(threshold.range.lower, threshold.range.upper)
+
+        i1 = instrument_price_factory.create(date=d1, net_value=100, calculated=False, instrument=product)
+        instrument_price_factory.create(
+            date=weekday, net_value=Decimal(breach_perf + 1) * i1.net_value, calculated=False, instrument=product
+        )
+
+        asset_position_factory.create(date=weekday, underlying_instrument=product, portfolio=portfolio)
+        asset_position_factory.create(date=weekday, underlying_instrument=product, portfolio=portfolio)
+
+        res = list(stop_loss_portfolio_backend.check_rule())
+        assert len(res) == 1
+        assert res[0].breached_object.id == product.id
+
+    @pytest.mark.parametrize(
+        "date_interval_option, freq",
+        [
+            ("ROLLING_WINDOWS", StopLossInstrumentRuleBackend.FreqChoices.BUSINESS_DAY),
+            *[("FREQUENCY", option) for option in StopLossInstrumentRuleBackend.FreqChoices.values],
+        ],
+    )
+    def test_check_rule_frequency_2(
+        self,
+        weekday,
+        date_interval_option,
+        freq,
+        product,
+        portfolio,
+        instrument_price_factory,
+        asset_position_factory,
+        instrument_factory,
+        stop_loss_portfolio_backend,
+        instrument_portfolio_through_model_factory,
+    ):
+        instrument_portfolio_through_model_factory.create(
+            instrument=product,
+            portfolio=portfolio,
+            primary_portfolio=True,
+        )
+        d1 = stop_loss_portfolio_backend._get_start_interval()
+        benchmark = instrument_factory.create()
+
+        threshold = stop_loss_portfolio_backend.thresholds[0]
+        threshold.range = NumericRange(upper=-0.5, lower=None)  # type: ignore
+        threshold.save()
+
+        instrument_price_factory.create(date=d1, net_value=100, calculated=False, instrument=product)
+        instrument_price_factory.create(date=weekday, net_value=100, calculated=False, instrument=product)
+
+        instrument_price_factory.create(date=d1, net_value=100, calculated=False, instrument=benchmark)
+        instrument_price_factory.create(date=weekday, net_value=300, calculated=False, instrument=benchmark)
+
+        asset_position_factory.create(date=weekday, underlying_instrument=product, portfolio=portfolio)
+        asset_position_factory.create(date=weekday, underlying_instrument=product, portfolio=portfolio)
+
+        res = list(stop_loss_portfolio_backend.check_rule())
+        assert len(res) == 0
+
+        setattr(stop_loss_portfolio_backend, "static_benchmark", benchmark)
+        res = list(stop_loss_portfolio_backend.check_rule())
+        assert len(res) == 1
+        assert res[0].breached_object.id == product.id

wbportfolio/risk_management/tests/test_ucits_portfolio.py

@@ -0,0 +1,39 @@
+import pytest
+from faker import Faker
+from wbportfolio.risk_management.backends.ucits_portfolio import (
+    RuleBackend as UCITPortfolioRuleBackend,
+)
+from wbportfolio.tests.models.utils import PortfolioTestMixin
+
+fake = Faker()
+
+
+@pytest.mark.django_db
+class TestUcitsRuleModel(PortfolioTestMixin):
+    @pytest.fixture
+    def ucits_backend(self, weekday, portfolio):
+        return UCITPortfolioRuleBackend(weekday, portfolio, [])
+
+    def testcheck_rule_1(self, weekday, portfolio, asset_position_factory, ucits_backend):
+        #  Check No single asset can represent more than 10% of the fund's assets;
+        asset_position_factory.create(date=weekday, weighting=0.05, portfolio=portfolio)
+        asset_position_factory.create(date=weekday, weighting=0.05, portfolio=portfolio)
+        a3 = asset_position_factory.create(date=weekday, weighting=0.90, portfolio=portfolio)
+
+        res = list(ucits_backend.check_rule())
+        assert len(res) == 1
+        assert res[0].breached_object == a3.underlying_instrument
+
+    def testcheck_rule_2(self, weekday, portfolio, asset_position_factory, ucits_backend):
+        # Check that stock below 5% don't trigger rule
+        asset_position_factory.create_batch(4, date=weekday, weighting=0.05, portfolio=portfolio)
+        asset_position_factory.create_batch(20, date=weekday, weighting=0.04, portfolio=portfolio)
+
+        res = list(ucits_backend.check_rule())
+        assert len(res) == 0
+
+    def testcheck_rule_3(self, weekday, portfolio, asset_position_factory, ucits_backend):
+        # Check holdings of more than 5% cannot in aggregate exceed 40% of the fund's assets
+        asset_position_factory.create_batch(20, date=weekday, weighting=0.05, portfolio=portfolio)
+        res = list(ucits_backend.check_rule())
+        assert len(res) == 20

wbportfolio/serializers/__init__.py

@@ -0,0 +1,42 @@
+from .assets import (
+    AssetPositionInstrumentModelSerializer,
+    AssetPositionModelSerializer,
+    AssetPositionPortfolioModelSerializer,
+    AssetPositionAggregatedPortfolioModelSerializer,
+    CashPositionPortfolioModelSerializer,
+)
+from .custodians import CustodianModelSerializer, CustodianRepresentationSerializer
+from .portfolio_relationship import (
+    InstrumentPreferedClassificationThroughProductModelSerializer,
+    InstrumentPortfolioThroughModelSerializer,
+)
+from .portfolios import (
+    ModelPortfolioModelSerializer,
+    PortfolioModelSerializer,
+    PortfolioPortfolioThroughModelSerializer,
+    PortfolioRepresentationSerializer,
+)
+from .portfolio_swing_pricing import PortfolioSwingPricingModelSerializer
+from .portfolio_cash_targets import PortfolioCashTargetModelSerializer
+from .positions import AggregatedAssetPositionModelSerializer
+from .registers import RegisterModelSerializer, RegisterRepresentationSerializer
+from .roles import PortfolioRoleModelSerializer, PortfolioRoleProjectModelSerializer
+from .signals import *
+from .synchronization import (
+    PortfolioSynchronizationRepresentationSerializer,
+    PriceComputationRepresentationSerializer,
+)
+from .transactions import *
+from .products import (
+    ProductRepresentationSerializer,
+    ProductCustomerRepresentationSerializer,
+    ProductUnlinkedRepresentationSerializer,
+    ProductListModelSerializer,
+    ProductModelSerializer,
+    ProductCustomerModelSerializer,
+    ProductFeesModelSerializer,
+)
+from .adjustments import AdjustmentModelSerializer
+from .product_group import ProductGroupModelSerializer, ProductGroupRepresentationSerializer
+from .portfolio_cash_flow import DailyPortfolioCashFlowModelSerializer
+from .reconciliations import AccountReconciliationModelSerializer, AccountReconciliationLineModelSerializer

wbportfolio/serializers/adjustments.py

@@ -0,0 +1,24 @@
+from wbcore import serializers as wb_serializers
+from wbcore.contrib.directory.serializers import PersonRepresentationSerializer
+from wbfdm.serializers import SecurityRepresentationSerializer
+from wbportfolio.models import Adjustment
+
+
+class AdjustmentModelSerializer(wb_serializers.ModelSerializer):
+    _instrument = SecurityRepresentationSerializer(source="instrument")
+    _last_handler = PersonRepresentationSerializer(source="last_handler")
+
+    class Meta:
+        model = Adjustment
+        fields = (
+            "id",
+            "date",
+            "instrument",
+            "_instrument",
+            "status",
+            "factor",
+            "cumulative_factor",
+            "_last_handler",
+            "last_handler",
+            "_additional_resources",
+        )