wbportfolio 1.44.4__py2.py3-none-any.whl → 1.45.0__py2.py3-none-any.whl

wbportfolio/tests/models/test_product_groups.py

@@ -3,6 +3,7 @@ from datetime import timedelta
 import pytest
 from faker import Faker
 from pandas.tseries.offsets import BDay
+
 from wbportfolio.models import Trade
 
 fake = Faker()

wbportfolio/tests/models/test_products.py

@@ -4,6 +4,7 @@ from decimal import Decimal
 import pytest
 from faker import Faker
 from wbfdm.models import Instrument
+
 from wbportfolio.models import Product, Trade
 
 from .utils import PortfolioTestMixin
@@ -48,9 +49,11 @@ class TestProductModel(PortfolioTestMixin):
         p3 = instrument_price_factory.create(
             instrument=Instrument.objects.get(id=product.id), date=t3.transaction_date
         )
-        assert product.total_value(p1.date) == pytest.approx(Decimal(0), rel=Decimal("1e-4"))
-        assert product.total_value(p2.date) == pytest.approx(Decimal(p2.net_value * (t1.shares)), rel=Decimal("1e-4"))
-        assert product.total_value(p3.date) == pytest.approx(
+        assert product.get_total_aum_usd(p1.date) == pytest.approx(Decimal(0), rel=Decimal("1e-4"))
+        assert product.get_total_aum_usd(p2.date) == pytest.approx(
+            Decimal(p2.net_value * (t1.shares)), rel=Decimal("1e-4")
+        )
+        assert product.get_total_aum_usd(p3.date) == pytest.approx(
             Decimal(p3.net_value * (t1.shares + t2.shares)), rel=Decimal("1e-4")
         )
 

wbportfolio/tests/models/test_roles.py

@@ -1,4 +1,5 @@
 import pytest
+
 from wbportfolio.factories import (
     ManagerPortfolioRoleFactory,
     ProductPortfolioRoleFactory,

wbportfolio/tests/models/test_splits.py

@@ -4,6 +4,7 @@ from unittest.mock import patch
 import pytest
 from faker import Faker
 from pandas.tseries.offsets import BDay
+
 from wbportfolio.factories import AdjustmentFactory
 from wbportfolio.models import Adjustment, PortfolioRole
 from wbportfolio.models.adjustments import post_adjustment_on_prices

wbportfolio/tests/models/transactions/test_claim.py

@@ -6,6 +6,7 @@ import pytest
 from django.contrib.auth import get_user_model
 from django.contrib.auth.models import Permission
 from faker import Faker
+
 from wbportfolio.models import Claim, Trade
 
 fake = Faker()

wbportfolio/tests/models/transactions/test_fees.py

@@ -4,6 +4,7 @@ from decimal import Decimal
 import pytest
 from wbfdm.factories import CashFactory
 from wbfdm.models import InstrumentPrice
+
 from wbportfolio.models import FeeCalculation, Fees, Product
 
 

wbportfolio/tests/models/transactions/test_rebalancing.py

@@ -0,0 +1,81 @@
+from datetime import date
+from decimal import Decimal
+
+import pandas as pd
+import pytest
+from django.core.exceptions import ValidationError
+from pandas._libs.tslibs.offsets import BDay
+
+from wbportfolio.models import AssetPosition, TradeProposal
+
+
+@pytest.mark.django_db
+class TestRebalancingModel:
+    def test_get_target_portfolio(self, rebalancing_model, portfolio, weekday, asset_position_factory):
+        with pytest.raises(ValidationError):  # trigger value error because rebalancing not valid (no position yet)
+            rebalancing_model.get_target_portfolio(portfolio, (weekday + BDay(1)).date(), weekday)
+        a1 = asset_position_factory(weighting=0.7, portfolio=portfolio, date=weekday)
+        a2 = asset_position_factory(weighting=0.3, portfolio=portfolio, date=weekday)
+        target_portfolio = rebalancing_model.get_target_portfolio(portfolio, (weekday + BDay(1)).date(), weekday)
+        target_positions = target_portfolio.positions_map
+        assert target_positions[a1.underlying_instrument.id].weighting == 0.5
+        assert target_positions[a2.underlying_instrument.id].weighting == 0.5
+
+
+@pytest.mark.django_db
+class TestRebalancer:
+    def test_activation_date(self, rebalancer_factory, asset_position):
+        r1 = rebalancer_factory.create(portfolio=asset_position.portfolio)
+        assert r1.activation_date == asset_position.date
+
+        r2 = rebalancer_factory.create()
+        r2.activation_date = date.today()
+
+    def test_is_valid(self, weekday, rebalancer_factory):
+        # default frequency is monthly
+
+        first_of_the_month = weekday.replace(day=1)
+        rebalancer = rebalancer_factory.create(frequency="RRULE:FREQ=MONTHLY;", activation_date=first_of_the_month)
+        assert rebalancer.is_valid(first_of_the_month)
+        if weekday.day != 1:
+            assert not rebalancer.is_valid(weekday)
+
+    def test_evaluate_rebalancing(
+        self, weekday, rebalancer_factory, asset_position_factory, instrument_factory, instrument_price_factory
+    ):
+        rebalancer = rebalancer_factory.create(approve_trade_proposal_automatically=True)
+        trade_date = (weekday + BDay(1)).date()
+
+        i1 = instrument_factory.create()
+        i2 = instrument_factory.create()
+        instrument_price_factory.create(instrument=i1, date=weekday)
+        instrument_price_factory.create(instrument=i1, date=trade_date)
+        instrument_price_factory.create(instrument=i2, date=weekday)
+        instrument_price_factory.create(instrument=i2, date=trade_date)
+
+        a1 = asset_position_factory.create(
+            portfolio=rebalancer.portfolio, date=weekday, weighting=0.7, underlying_instrument=i1
+        )
+        a2 = asset_position_factory.create(
+            portfolio=rebalancer.portfolio, date=weekday, weighting=0.3, underlying_instrument=i2
+        )
+        trade_proposal = rebalancer.evaluate_rebalancing(trade_date)
+        assert trade_proposal.trades.count() == 2
+        assert trade_proposal.status == TradeProposal.Status.APPROVED
+        assert AssetPosition.objects.get(
+            portfolio=rebalancer.portfolio, date=trade_date, underlying_quote=a1.underlying_instrument
+        ).weighting == Decimal(0.5)
+        assert AssetPosition.objects.get(
+            portfolio=rebalancer.portfolio, date=trade_date, underlying_quote=a2.underlying_instrument
+        ).weighting == Decimal(0.5)
+
+    def test_get_rrule(self, weekday, rebalancer_factory):
+        # default frequency is monthly
+
+        first_of_the_month = weekday.replace(day=1)
+        until = first_of_the_month.replace(year=first_of_the_month.year + 1)
+        rebalancer = rebalancer_factory.create(frequency="RRULE:FREQ=MONTHLY;", activation_date=first_of_the_month)
+
+        valid_dates = set(rebalancer.get_rrule(until))
+        assert valid_dates
+        assert set(valid_dates) == set(pd.date_range(start=first_of_the_month, end=until, freq="MS"))

wbportfolio/tests/models/transactions/test_trades.py

@@ -3,6 +3,7 @@ from decimal import Decimal
 
 import pytest
 from faker import Faker
+
 from wbportfolio.models import Product, Trade
 
 fake = Faker()

wbportfolio/tests/models/utils.py

@@ -2,6 +2,7 @@ from datetime import timedelta
 
 import pytest
 from faker import Faker
+
 from wbportfolio.factories import ProductFactory
 
 fake = Faker()

wbportfolio/tests/pms/test_analytics.py

@@ -0,0 +1,35 @@
+import pandas as pd
+
+from wbportfolio.pms.analytics.portfolio import Portfolio
+
+
+def test_get_next_weights():
+    w0 = 0.3
+    w1 = 0.5
+    w2 = 0.2
+    r0 = 0.1
+    r1 = 0.05
+    r2 = -0.23
+    weights = [w0, w1, w2]
+    returns = [r0, r1, r2]
+    portfolio = Portfolio(X=pd.DataFrame([returns]), weights=pd.Series(weights))
+    next_weights = portfolio.get_next_weights(pd.Series(returns))
+
+    assert next_weights[0] == w0 * (r0 + 1) / (w0 * (r0 + 1) + w1 * (r1 + 1) + w2 * (r2 + 1))
+    assert next_weights[1] == w1 * (r1 + 1) / (w0 * (r0 + 1) + w1 * (r1 + 1) + w2 * (r2 + 1))
+    assert next_weights[2] == w2 * (r2 + 1) / (w0 * (r0 + 1) + w1 * (r1 + 1) + w2 * (r2 + 1))
+
+
+def test_get_estimate_net_value():
+    w0 = 0.3
+    w1 = 0.5
+    w2 = 0.2
+    r0 = 0.1
+    r1 = 0.05
+    r2 = -0.23
+    weights = [w0, w1, w2]
+    returns = [r0, r1, r2]
+    portfolio = Portfolio(X=pd.DataFrame([returns]), weights=pd.Series(weights), previous_weights=pd.Series(weights))
+    current_price = 100
+    net_asset_value = portfolio.get_estimate_net_value(current_price)
+    return net_asset_value == current_price * (1.0 + w0 * r0 + w1 * r1 + w2 * r2)

wbportfolio/tests/rebalancing/test_models.py

@@ -0,0 +1,127 @@
+from decimal import Decimal
+
+import pytest
+from pandas._libs.tslibs.offsets import BDay
+
+from wbportfolio.factories import PortfolioFactory, TradeFactory, TradeProposalFactory
+from wbportfolio.models import PortfolioPortfolioThroughModel, Trade, TradeProposal
+
+
+@pytest.mark.django_db
+class TestEquallyWeightedRebalancing:
+    @pytest.fixture()
+    def model(self, portfolio, weekday):
+        from wbportfolio.rebalancing.models import EquallyWeightedRebalancing
+
+        return EquallyWeightedRebalancing(portfolio, (weekday + BDay(1)).date(), weekday)
+
+    def test_is_valid(self, portfolio, weekday, model, asset_position_factory):
+        assert not model.is_valid()
+        asset_position_factory.create(portfolio=model.portfolio, date=model.last_effective_date)
+        assert model.is_valid()
+
+    def test_get_target_portfolio(self, portfolio, weekday, model, asset_position_factory):
+        a1 = asset_position_factory(weighting=0.7, portfolio=portfolio, date=model.last_effective_date)
+        a2 = asset_position_factory(weighting=0.3, portfolio=portfolio, date=model.last_effective_date)
+        target_portfolio = model.get_target_portfolio()
+        target_positions = target_portfolio.positions_map
+        assert target_positions[a1.underlying_instrument.id].weighting == Decimal(0.5)
+        assert target_positions[a2.underlying_instrument.id].weighting == Decimal(0.5)
+
+
+@pytest.mark.django_db
+class TestModelPortfolioRebalancing:
+    @pytest.fixture()
+    def model(self, portfolio, weekday):
+        from wbportfolio.rebalancing.models import ModelPortfolioRebalancing
+
+        return ModelPortfolioRebalancing(portfolio, (weekday + BDay(1)).date(), weekday)
+
+    def test_is_valid(self, portfolio, weekday, model, asset_position_factory):
+        assert not model.is_valid()
+        asset_position_factory.create(portfolio=model.portfolio, date=model.last_effective_date)
+        assert not model.is_valid()
+        model_portfolio = PortfolioFactory.create()
+        PortfolioPortfolioThroughModel.objects.create(
+            portfolio=model.portfolio,
+            dependency_portfolio=model_portfolio,
+            type=PortfolioPortfolioThroughModel.Type.MODEL,
+        )
+        asset_position_factory.create(portfolio=model.model_portfolio, date=model.last_effective_date)
+        assert model.is_valid()
+
+    def test_get_target_portfolio(self, portfolio, weekday, model, asset_position_factory):
+        model_portfolio = PortfolioFactory.create()
+        PortfolioPortfolioThroughModel.objects.create(
+            portfolio=model.portfolio,
+            dependency_portfolio=model_portfolio,
+            type=PortfolioPortfolioThroughModel.Type.MODEL,
+        )
+        asset_position_factory(portfolio=portfolio, date=model.last_effective_date)  # noise
+        asset_position_factory(portfolio=portfolio, date=model.last_effective_date)  # noise
+        a1 = asset_position_factory(weighting=0.8, portfolio=portfolio.model_portfolio, date=model.last_effective_date)
+        a2 = asset_position_factory(weighting=0.2, portfolio=portfolio.model_portfolio, date=model.last_effective_date)
+        target_portfolio = model.get_target_portfolio()
+        target_positions = target_portfolio.positions_map
+        assert target_positions[a1.underlying_instrument.id].weighting == Decimal("0.800000")
+        assert target_positions[a2.underlying_instrument.id].weighting == Decimal("0.200000")
+
+
+@pytest.mark.django_db
+class TestCompositeRebalancing:
+    @pytest.fixture()
+    def model(self, portfolio, weekday):
+        from wbportfolio.rebalancing.models import CompositeRebalancing
+
+        return CompositeRebalancing(portfolio, (weekday + BDay(1)).date(), weekday)
+
+    def test_is_valid(self, portfolio, weekday, model, asset_position_factory):
+        assert not model.is_valid()
+
+        trade_proposal = TradeProposalFactory.create(
+            portfolio=model.portfolio, trade_date=model.trade_date, status=TradeProposal.Status.APPROVED
+        )
+        TradeFactory.create(
+            portfolio=model.portfolio,
+            transaction_date=model.trade_date,
+            transaction_subtype=Trade.Type.BUY,
+            trade_proposal=trade_proposal,
+            weighting=0.7,
+            status=Trade.Status.EXECUTED,
+        )
+        TradeFactory.create(
+            portfolio=model.portfolio,
+            transaction_date=model.trade_date,
+            transaction_subtype=Trade.Type.BUY,
+            trade_proposal=trade_proposal,
+            weighting=0.3,
+            status=Trade.Status.EXECUTED,
+        )
+        assert model.is_valid()
+
+    def test_get_target_portfolio(self, portfolio, weekday, model, asset_position_factory):
+        trade_proposal = TradeProposalFactory.create(
+            portfolio=model.portfolio, trade_date=model.trade_date, status=TradeProposal.Status.APPROVED
+        )
+        asset_position_factory(portfolio=portfolio, date=model.last_effective_date)  # noise
+        asset_position_factory(portfolio=portfolio, date=model.last_effective_date)  # noise
+        t1 = TradeFactory.create(
+            portfolio=model.portfolio,
+            transaction_date=model.trade_date,
+            transaction_subtype=Trade.Type.BUY,
+            trade_proposal=trade_proposal,
+            weighting=0.8,
+            status=Trade.Status.EXECUTED,
+        )
+        t2 = TradeFactory.create(
+            portfolio=model.portfolio,
+            transaction_date=model.trade_date,
+            transaction_subtype=Trade.Type.BUY,
+            trade_proposal=trade_proposal,
+            weighting=0.2,
+            status=Trade.Status.EXECUTED,
+        )
+        target_portfolio = model.get_target_portfolio()
+        target_positions = target_portfolio.positions_map
+        assert target_positions[t1.underlying_instrument.id].weighting == Decimal("0.800000")
+        assert target_positions[t2.underlying_instrument.id].weighting == Decimal("0.200000")

wbportfolio/tests/serializers/test_claims.py

@@ -1,4 +1,5 @@
 import pytest
+
 from wbportfolio.serializers import ClaimModelSerializer
 
 

wbportfolio/tests/signals.py

@@ -2,10 +2,10 @@ from django.dispatch import receiver
 from wbcore.contrib.currency.factories import CurrencyFXRatesFactory
 from wbcore.contrib.directory.factories import CompanyFactory
 from wbcore.test.signals import custom_update_kwargs, get_custom_factory
+
 from wbportfolio.factories import (
     CustomerTradeFactory,
     InstrumentPriceFactory,
-    ModelPortfolioFactory,
     ProductFactory,
     ProductPortfolioRoleFactory,
     TradeProposalFactory,
@@ -19,7 +19,6 @@ from wbportfolio.viewsets import (
     CustomerDistributionInstrumentChartViewSet,
     DistributionChartViewSet,
     DistributionTableViewSet,
-    ModelPortfolioModelViewSet,
     NominalProductChartView,
     PortfolioRoleInstrumentModelViewSet,
     ProductCustomerModelViewSet,
@@ -42,11 +41,6 @@ def receive_factory_subscription_redemption_instrument(sender, *args, **kwargs):
     return CustomerTradeFactory
 
 
-@receiver(get_custom_factory, sender=ModelPortfolioModelViewSet)
-def receive_factory_model_portfolio(sender, *args, **kwargs):
-    return ModelPortfolioFactory
-
-
 @receiver(get_custom_factory, sender=PortfolioRoleInstrumentModelViewSet)
 def receive_factory_product_portfolio_role(sender, *args, **kwargs):
     return ProductPortfolioRoleFactory

wbportfolio/tests/tests.py

@@ -17,6 +17,8 @@ for key, value in default_config.items():
                 "AccountReconciliationLineModelViewSet",
                 "AccountReconciliation",
                 "AccountReconciliationLine",
+                "TopDownPortfolioCompositionPandasAPIView",
+                "CompositionModelPortfolioPandasView",
                 # "ClaimModelViewSet",
                 # "ClaimModelSerializer",
             ],

wbportfolio/tests/viewsets/test_assets.py

@@ -2,6 +2,7 @@ import pytest
 from faker import Faker
 from pandas.tseries.offsets import BDay
 from rest_framework.test import APIRequestFactory
+
 from wbportfolio.viewsets.positions import AggregatedAssetPositionLiquidityPandasView
 
 fake = Faker()

wbportfolio/tests/viewsets/test_performances.py

@@ -6,6 +6,7 @@ from faker import Faker
 from pandas.tseries.offsets import BDay, BMonthEnd, BYearEnd
 from rest_framework.reverse import reverse
 from rest_framework.test import force_authenticate
+
 from wbportfolio.factories import InstrumentPriceFactory, ProductFactory
 from wbportfolio.viewsets.product_performance import PerformanceComparisonPandasView
 

wbportfolio/tests/viewsets/test_products.py

@@ -9,6 +9,7 @@ from psycopg.types.range import DateRange
 from rest_framework.reverse import reverse
 from rest_framework.test import force_authenticate
 from wbfdm.models import InstrumentPrice
+
 from wbportfolio.models import InstrumentPortfolioThroughModel, Product
 from wbportfolio.viewsets import ProductModelViewSet
 

wbportfolio/tests/viewsets/transactions/test_claims.py

@@ -8,6 +8,7 @@ from wbcore.contrib.directory.models import Entry
 from wbcore.utils.strings import format_number
 from wbcrm.factories.accounts import AccountFactory, AccountRoleFactory
 from wbcrm.models import Account
+
 from wbportfolio.factories.claim import ClaimFactory
 from wbportfolio.models.transactions.claim import Claim
 from wbportfolio.viewsets.transactions.claim import (

wbportfolio/urls.py

@@ -1,5 +1,6 @@
 from django.urls import include, path
 from wbcore.routers import WBCoreRouter
+
 from wbportfolio import viewsets
 
 router = WBCoreRouter()
@@ -21,22 +22,10 @@ router.register(r"portfolio", viewsets.PortfolioModelViewSet, basename="portfoli
 router.register(r"portfoliocashflow", viewsets.DailyPortfolioCashFlowModelViewSet, basename="portfoliocashflow")
 router.register(r"portfolioswingpricing", viewsets.PortfolioSwingPricingModelViewSet, basename="portfolioswingpricing")
 router.register(r"portfoliocashtarget", viewsets.PortfolioCashTargetModelViewSet, basename="portfoliocashtarget")
-router.register(r"modelportfolio", viewsets.ModelPortfolioModelViewSet, basename="modelportfolio")
 
 router.register(
     r"portfoliorepresentation", viewsets.PortfolioRepresentationViewSet, basename="portfoliorepresentation"
 )
-router.register(
-    r"portfoliosynchronizationrepresentation",
-    viewsets.PortfolioSynchronizationRepresentationViewSet,
-    basename="portfoliosynchronizationrepresentation",
-)
-router.register(
-    r"pricecomputationrepresentation",
-    viewsets.PriceComputationRepresentationViewSet,
-    basename="pricecomputationrepresentation",
-)
-
 
 router.register(r"portfoliorole", viewsets.PortfolioRoleModelViewSet, basename="portfoliorole")
 
@@ -52,6 +41,21 @@ router.register(r"traderepresentation", viewsets.TradeRepresentationViewSet, bas
 router.register(
     r"tradeproposalrepresentation", viewsets.TradeProposalRepresentationViewSet, basename="tradeproposalrepresentation"
 )
+router.register(
+    r"rebalancingmodelrepresentation",
+    viewsets.RebalancingModelRepresentationViewSet,
+    basename="rebalancingmodelrepresentation",
+)
+router.register(
+    r"rebalancerrepresentation",
+    viewsets.RebalancerRepresentationViewSet,
+    basename="rebalancerrepresentation",
+)
+router.register(
+    r"rebalancer",
+    viewsets.RebalancerModelViewSet,
+    basename="rebalancer",
+)
 router.register(
     r"feesproductperformance", viewsets.ProductPerformanceFeesModelViewSet, basename="feesproductperformance"
 )
@@ -115,6 +119,16 @@ portfolio_router.register(
     viewsets.ESGMetricAggregationPortfolioPandasViewSet,
     basename="portfolio-esgaggregation",
 )
+portfolio_router.register(
+    r"treegraphchart",
+    viewsets.PortfolioTreeGraphChartViewSet,
+    basename="portfolio-treegraphchart",
+)
+portfolio_router.register(
+    r"topdowncomposition",
+    viewsets.TopDownPortfolioCompositionPandasAPIView,
+    basename="portfolio-topdowncomposition",
+)
 
 router.register(r"register", viewsets.RegisterModelViewSet, basename="register")
 router.register(r"registerrepresentation", viewsets.RegisterRepresentationViewSet, basename="registerrepresentation")

wbportfolio/viewsets/__init__.py

@@ -11,10 +11,11 @@ from .charts import *
 from .custodians import CustodianModelViewSet, CustodianRepresentationViewSet
 from .portfolio_relationship import InstrumentPreferedClassificationThroughProductModelViewSet
 from .portfolios import (
-    ModelPortfolioModelViewSet,
     PortfolioModelViewSet,
     PortfolioPortfolioThroughModelViewSet,
     PortfolioRepresentationViewSet,
+    PortfolioTreeGraphChartViewSet,
+    TopDownPortfolioCompositionPandasAPIView
 )
 from .positions import (
     AggregatedAssetPositionLiquidityPandasView,
@@ -23,10 +24,6 @@ from .positions import (
 from .registers import RegisterModelViewSet, RegisterRepresentationViewSet
 from .roles import PortfolioRoleInstrumentModelViewSet, PortfolioRoleModelViewSet
 from .signals import *
-from .synchronization import (
-    PortfolioSynchronizationRepresentationViewSet,
-    PriceComputationRepresentationViewSet,
-)
 from .transactions import *
 from .adjustments import AdjustmentEquityModelViewSet, AdjustmentModelViewSet
 from .product_groups import ProductGroupModelViewSet, ProductGroupRepresentationViewSet

wbportfolio/viewsets/adjustments.py

@@ -1,5 +1,6 @@
 from wbcore import viewsets
 from wbcore.permissions.permissions import InternalUserPermissionMixin
+
 from wbportfolio.models import Adjustment
 from wbportfolio.serializers import AdjustmentModelSerializer