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

wbportfolio/tests/models/transactions/test_rebalancing.py

@@ -6,7 +6,7 @@ import pytest
 from django.core.exceptions import ValidationError
 from pandas._libs.tslibs.offsets import BDay
 
-from wbportfolio.models import AssetPosition, TradeProposal
+from wbportfolio.models import AssetPosition, OrderProposal
 
 
 @pytest.mark.django_db
@@ -47,7 +47,7 @@ class TestRebalancer:
     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)
+        rebalancer = rebalancer_factory.create(apply_order_proposal_automatically=True)
         trade_date = (weekday + BDay(1)).date()
 
         i1 = instrument_factory.create()
@@ -63,9 +63,9 @@ class TestRebalancer:
         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
+        order_proposal = rebalancer.evaluate_rebalancing(trade_date)
+        assert order_proposal.orders.count() == 2
+        assert order_proposal.status == OrderProposal.Status.CONFIRMED
         assert AssetPosition.objects.get(
             portfolio=rebalancer.portfolio, date=trade_date, underlying_quote=a1.underlying_instrument
         ).weighting == Decimal(0.5)

wbportfolio/tests/models/transactions/test_trades.py

@@ -3,7 +3,6 @@ from decimal import Decimal
 
 import pytest
 from faker import Faker
-from pandas._libs.tslibs.offsets import BDay
 
 from wbportfolio.models import Product, Trade
 
@@ -103,12 +102,6 @@ class TestTradeModel:
         assert customer_trade.claimed_shares == c2.shares
 
 
-@pytest.mark.django_db
-class TestTradeProposalModel:
-    def test_init(self, trade_proposal):
-        assert trade_proposal.id is not None
-
-
 @pytest.mark.django_db
 class TestTradeInstrumentPrice:
     def test_shares(self, portfolio, product_factory, trade_factory, instrument_price_factory):
@@ -204,16 +197,3 @@ class TestTradeInstrumentPrice:
         subscription_trade1.refresh_from_db()
         assert subscription_trade1.internal_trade == internal_trade
         assert subscription_trade1.marked_as_internal is True
-
-    def test_last_underlying_quote_price(self, weekday, trade_factory, instrument_price_factory):
-        trade = trade_factory.create(transaction_date=weekday, value_date=(weekday - BDay(1)).date())
-        assert trade.last_underlying_quote_price is None
-        del trade.last_underlying_quote_price
-
-        # test that underlying quote price returns any price found at transaction_date, or then at value_date (in that order)
-        p0 = instrument_price_factory.create(instrument=trade.underlying_instrument, date=trade.value_date)
-        assert trade.last_underlying_quote_price == p0
-        del trade.last_underlying_quote_price
-
-        p1 = instrument_price_factory.create(instrument=trade.underlying_instrument, date=trade.transaction_date)
-        assert trade.last_underlying_quote_price == p1

wbportfolio/tests/pms/test_analytics.py

@@ -1,4 +1,5 @@
 import pandas as pd
+import pytest
 
 from wbportfolio.pms.analytics.portfolio import Portfolio
 
@@ -15,9 +16,27 @@ def test_get_next_weights():
     portfolio = Portfolio(X=pd.DataFrame([returns]), weights=pd.Series(weights))
     next_weights = portfolio.get_next_weights()
 
-    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))
+    assert next_weights[0] == pytest.approx(w0 * (r0 + 1) / (w0 * (r0 + 1) + w1 * (r1 + 1) + w2 * (r2 + 1)), abs=10e-8)
+    assert next_weights[1] == pytest.approx(w1 * (r1 + 1) / (w0 * (r0 + 1) + w1 * (r1 + 1) + w2 * (r2 + 1)), abs=10e-8)
+    assert next_weights[2] == pytest.approx(w2 * (r2 + 1) / (w0 * (r0 + 1) + w1 * (r1 + 1) + w2 * (r2 + 1)), abs=10e-8)
+
+
+def test_get_next_weights_solve_quantization_error():
+    w0 = 0.33333334
+    w1 = 0.33333333
+    w2 = 0.33333333
+    weights = [w0, w1, w2]
+    returns = [1.0, 1.0, 1.0]  # no returns
+    portfolio = Portfolio(X=pd.DataFrame([returns]), weights=pd.Series(weights))
+    next_weights = portfolio.get_next_weights(round_precision=8)  # no rounding as number are all 8 decimals
+    assert sum(next_weights.values()) == 1.0
+    next_weights = portfolio.get_next_weights(
+        round_precision=7
+    )  # we expect the weight to be rounded to 6 decimals, which would lead to a total sum of 0.999999
+
+    assert next_weights[0] == 0.3333334
+    assert next_weights[1] == 0.3333333
+    assert next_weights[2] == 0.3333333
 
 
 def test_get_estimate_net_value():

wbportfolio/tests/rebalancing/test_models.py

@@ -4,28 +4,34 @@ import pytest
 from pandas._libs.tslibs.offsets import BDay
 from wbfdm.models import InstrumentPrice
 
-from wbportfolio.factories import PortfolioFactory, TradeFactory, TradeProposalFactory
-from wbportfolio.models import PortfolioPortfolioThroughModel, Trade, TradeProposal
+from wbportfolio.factories import OrderFactory, OrderProposalFactory, PortfolioFactory
+from wbportfolio.models import Order, OrderProposal, PortfolioPortfolioThroughModel
 
 
 @pytest.mark.django_db
 class TestEquallyWeightedRebalancing:
-    @pytest.fixture()
-    def model(self, portfolio, weekday):
+    def test_is_valid(self, portfolio, weekday, asset_position_factory, instrument_price_factory):
         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, instrument_price_factory):
+        trade_date = (weekday + BDay(1)).date()
+        model = EquallyWeightedRebalancing(portfolio, trade_date, weekday)
         assert not model.is_valid()
-        a = asset_position_factory.create(portfolio=model.portfolio, date=model.last_effective_date)
+
+        a = asset_position_factory.create(portfolio=portfolio, date=weekday)
+        model = EquallyWeightedRebalancing(portfolio, trade_date, weekday)
         assert not model.is_valid()
-        instrument_price_factory.create(instrument=a.underlying_quote, date=model.trade_date)
+
+        instrument_price_factory.create(instrument=a.underlying_quote, date=trade_date)
+        model = EquallyWeightedRebalancing(portfolio, trade_date, weekday)
         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)
+    def test_get_target_portfolio(self, portfolio, weekday, asset_position_factory):
+        from wbportfolio.rebalancing.models import EquallyWeightedRebalancing
+
+        a1 = asset_position_factory(weighting=0.7, portfolio=portfolio, date=weekday)
+        a2 = asset_position_factory(weighting=0.3, portfolio=portfolio, date=weekday)
+        model = EquallyWeightedRebalancing(portfolio, (weekday + BDay(1)).date(), weekday)
+
         target_portfolio = model.get_target_portfolio()
         target_positions = target_portfolio.positions_map
         assert target_positions[a1.underlying_instrument.id].weighting == Decimal(0.5)
@@ -38,30 +44,22 @@ class TestModelPortfolioRebalancing:
     def model(self, portfolio, weekday):
         from wbportfolio.rebalancing.models import ModelPortfolioRebalancing
 
+        PortfolioPortfolioThroughModel.objects.create(
+            portfolio=portfolio,
+            dependency_portfolio=PortfolioFactory.create(),
+            type=PortfolioPortfolioThroughModel.Type.MODEL,
+        )
         return ModelPortfolioRebalancing(portfolio, (weekday + BDay(1)).date(), weekday)
 
     def test_is_valid(self, portfolio, weekday, model, asset_position_factory, instrument_price_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,
-        )
-        a = asset_position_factory.create(portfolio=model.model_portfolio, date=model.last_effective_date)
-        assert not model.is_valid()
-        instrument_price_factory.create(instrument=a.underlying_quote, date=model.trade_date)
+
+        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)
@@ -83,50 +81,46 @@ class TestCompositeRebalancing:
     def test_is_valid(self, portfolio, weekday, model, asset_position_factory, instrument_price_factory):
         assert not model.is_valid()
 
-        trade_proposal = TradeProposalFactory.create(
-            portfolio=model.portfolio, trade_date=model.last_effective_date, status=TradeProposal.Status.APPROVED
+        order_proposal = OrderProposalFactory.create(
+            portfolio=model.portfolio, trade_date=model.last_effective_date, status=OrderProposal.Status.CONFIRMED
         )
-        t1 = TradeFactory.create(
+        t1 = OrderFactory.create(
             portfolio=model.portfolio,
-            transaction_date=model.last_effective_date,
-            transaction_subtype=Trade.Type.BUY,
-            trade_proposal=trade_proposal,
-            weighting=0.7,
-            status=Trade.Status.EXECUTED,
+            value_date=model.last_effective_date,
+            order_type=Order.Type.BUY,
+            order_proposal=order_proposal,
+            weighting=Decimal(0.7),
         )
-        TradeFactory.create(
+        OrderFactory.create(
             portfolio=model.portfolio,
-            transaction_date=model.last_effective_date,
-            transaction_subtype=Trade.Type.BUY,
-            trade_proposal=trade_proposal,
-            weighting=0.3,
-            status=Trade.Status.EXECUTED,
+            value_date=model.last_effective_date,
+            order_type=Order.Type.BUY,
+            order_proposal=order_proposal,
+            weighting=Decimal(0.3),
         )
         assert not model.is_valid()
         instrument_price_factory.create(instrument=t1.underlying_instrument, date=model.trade_date)
         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.last_effective_date, status=TradeProposal.Status.APPROVED
+        order_proposal = OrderProposalFactory.create(
+            portfolio=model.portfolio, trade_date=model.last_effective_date, status=OrderProposal.Status.CONFIRMED
         )
         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(
+        t1 = OrderFactory.create(
             portfolio=model.portfolio,
-            transaction_date=model.last_effective_date,
-            transaction_subtype=Trade.Type.BUY,
-            trade_proposal=trade_proposal,
-            weighting=0.8,
-            status=Trade.Status.EXECUTED,
+            value_date=model.last_effective_date,
+            order_type=Order.Type.BUY,
+            order_proposal=order_proposal,
+            weighting=Decimal(0.8),
         )
-        t2 = TradeFactory.create(
+        t2 = OrderFactory.create(
             portfolio=model.portfolio,
-            transaction_date=model.last_effective_date,
-            transaction_subtype=Trade.Type.BUY,
-            trade_proposal=trade_proposal,
-            weighting=0.2,
-            status=Trade.Status.EXECUTED,
+            value_date=model.last_effective_date,
+            order_type=Order.Type.BUY,
+            order_proposal=order_proposal,
+            weighting=Decimal(0.2),
         )
         target_portfolio = model.get_target_portfolio()
         target_positions = target_portfolio.positions_map
@@ -162,5 +156,5 @@ class TestMarketCapitalizationRebalancing:
 
         target_portfolio = model.get_target_portfolio()
         target_positions = target_portfolio.positions_map
-        assert target_positions[i1].weighting == mkt12 / (mkt12 + mkt21)
-        assert target_positions[i2].weighting == mkt21 / (mkt12 + mkt21)
+        assert target_positions[i1].weighting == pytest.approx(Decimal(mkt12 / (mkt12 + mkt21)), abs=Decimal(1e-8))
+        assert target_positions[i2].weighting == pytest.approx(Decimal(mkt21 / (mkt12 + mkt21)), abs=Decimal(1e-8))

wbportfolio/tests/signals.py

@@ -6,9 +6,9 @@ from wbfdm.factories import InstrumentPriceFactory
 
 from wbportfolio.factories import (
     CustomerTradeFactory,
+    OrderProposalFactory,
     ProductFactory,
     ProductPortfolioRoleFactory,
-    TradeProposalFactory,
 )
 from wbportfolio.viewsets import (
     AssetPositionInstrumentModelViewSet,
@@ -17,17 +17,15 @@ from wbportfolio.viewsets import (
     ClaimEntryModelViewSet,
     CustodianDistributionInstrumentChartViewSet,
     CustomerDistributionInstrumentChartViewSet,
-    DistributionChartViewSet,
-    DistributionTableViewSet,
     NominalProductChartView,
+    OrderOrderProposalModelViewSet,
+    OrderProposalPortfolioModelViewSet,
     PortfolioRoleInstrumentModelViewSet,
     ProductCustomerModelViewSet,
     ProductPerformanceFeesModelViewSet,
     SubscriptionRedemptionInstrumentModelViewSet,
     SubscriptionRedemptionModelViewSet,
     TradeInstrumentModelViewSet,
-    TradeProposalPortfolioModelViewSet,
-    TradeTradeProposalModelViewSet,
 )
 
 # =================================================================================================================
@@ -54,18 +52,18 @@ def receive_factory_product_portfolio_role(sender, *args, **kwargs):
 # =================================================================================================================
 #                                              UPDATE KWARGS
 # =================================================================================================================
-@receiver(custom_update_kwargs, sender=TradeTradeProposalModelViewSet)
-def receive_kwargs_trade_trade_proposal_product(sender, *args, **kwargs):
+@receiver(custom_update_kwargs, sender=OrderOrderProposalModelViewSet)
+def receive_kwargs_trade_order_proposal_product(sender, *args, **kwargs):
     if obj := kwargs.get("obj_factory"):
-        trade_proposal = TradeProposalFactory.create()
-        obj.trade_proposal = trade_proposal
+        order_proposal = OrderProposalFactory.create()
+        obj.order_proposal = order_proposal
         obj.save()
-        return {"trade_proposal_id": trade_proposal.id}
+        return {"order_proposal_id": order_proposal.id}
     return {}
 
 
-@receiver(custom_update_kwargs, sender=TradeProposalPortfolioModelViewSet)
-def receive_kwargs_trade_trade_proposal_portfolio(sender, *args, **kwargs):
+@receiver(custom_update_kwargs, sender=OrderProposalPortfolioModelViewSet)
+def receive_kwargs_trade_order_proposal_portfolio(sender, *args, **kwargs):
     if obj := kwargs.get("obj_factory"):
         return {"portfolio_id": obj.portfolio.id}
     return {}
@@ -96,14 +94,6 @@ def receive_kwargs_portfolio_role_instrument(sender, *args, **kwargs):
     return {}
 
 
-@receiver(custom_update_kwargs, sender=DistributionChartViewSet)
-@receiver(custom_update_kwargs, sender=DistributionTableViewSet)
-def receive_kwargs_distribution_chart_instrument_id(sender, *args, **kwargs):
-    if instrument_id := kwargs.get("underlying_instrument_id"):
-        return {"instrument_id": instrument_id}
-    return {}
-
-
 @receiver(custom_update_kwargs, sender=ProductPerformanceFeesModelViewSet)
 def receive_kwargs_product_performance_fees(sender, *args, **kwargs):
     CurrencyFXRatesFactory()

wbportfolio/tests/tests.py

@@ -9,7 +9,7 @@ for key, value in default_config.items():
             and x.__name__
             not in [
                 "AggregatedAssetPositionLiquidityPandasView",
-                "TradeTradeProposalModelViewSet",
+                "OrderOrderProposalModelViewSet",
                 "PortfolioSwingPricing",
                 "PortfolioCashTarget",
                 "PortfolioSwingPricingModelViewSet",
@@ -19,6 +19,8 @@ for key, value in default_config.items():
                 "AccountReconciliationLine",
                 "TopDownPortfolioCompositionPandasAPIView",
                 "CompositionModelPortfolioPandasView",
+                "DistributionChartViewSet",
+                "DistributionTableViewSet",
                 # "ClaimModelViewSet",
                 # "ClaimModelSerializer",
             ],

wbportfolio/tests/viewsets/test_products.py

@@ -23,6 +23,7 @@ class TestProductModelViewSet:
             portfolio_factory.create_batch(4, invested_timespan=DateRange(date.min, date.max))
             + portfolio_factory.create_batch(2, invested_timespan=DateRange(date.min, date.max)),
             product_factory.create_batch(6),
+            strict=False,
         ):
             InstrumentPortfolioThroughModel.objects.update_or_create(
                 instrument=product, defaults={"portfolio": portfolio}

wbportfolio/urls.py

@@ -30,7 +30,6 @@ router.register(
 router.register(r"portfoliorole", viewsets.PortfolioRoleModelViewSet, basename="portfoliorole")
 
 
-router.register(r"transaction", viewsets.TransactionModelViewSet, basename="transaction")
 router.register(r"fees", viewsets.FeesModelViewSet, basename="fees")
 router.register(r"trade", viewsets.TradeModelViewSet, basename="trade")
 router.register(
@@ -39,7 +38,7 @@ router.register(
 
 router.register(r"traderepresentation", viewsets.TradeRepresentationViewSet, basename="traderepresentation")
 router.register(
-    r"tradeproposalrepresentation", viewsets.TradeProposalRepresentationViewSet, basename="tradeproposalrepresentation"
+    r"orderproposalrepresentation", viewsets.OrderProposalRepresentationViewSet, basename="orderproposalrepresentation"
 )
 router.register(
     r"rebalancingmodelrepresentation",
@@ -63,7 +62,7 @@ router.register(r"aumchart", viewsets.InstrumentPriceAUMDataChartView, basename=
 
 router.register(r"custodian", viewsets.CustodianModelViewSet, basename="custodian")
 
-router.register(r"tradeproposal", viewsets.TradeProposalModelViewSet, basename="tradeproposal")
+router.register(r"orderproposal", viewsets.OrderProposalModelViewSet, basename="orderproposal")
 
 router.register(
     r"assetandnetnewmoneyprogression",
@@ -79,8 +78,6 @@ portfolio_router.register(
 )
 portfolio_router.register(r"asset", viewsets.AssetPositionPortfolioModelViewSet, basename="portfolio-asset")
 portfolio_router.register(r"contributor", viewsets.ContributorPortfolioChartView, basename="portfolio-contributor")
-portfolio_router.register(r"fees", viewsets.FeesPortfolioModelViewSet, basename="portfolio-fees")
-portfolio_router.register(r"transaction", viewsets.TransactionPortfolioModelViewSet, basename="portfolio-transaction")
 portfolio_router.register(r"trade", viewsets.TradePortfolioModelViewSet, basename="portfolio-trade")
 portfolio_router.register(
     r"instrument", viewsets.InstrumentPortfolioThroughPortfolioModelViewSet, basename="portfolio-instrument"
@@ -91,7 +88,7 @@ portfolio_router.register(
     basename="portfolio-preferredclassification",
 )
 portfolio_router.register(
-    r"tradeproposal", viewsets.TradeProposalPortfolioModelViewSet, basename="portfolio-tradeproposal"
+    r"orderproposal", viewsets.OrderProposalPortfolioModelViewSet, basename="portfolio-orderproposal"
 )
 portfolio_router.register(
     r"dependencyportfolio", viewsets.PortfolioPortfolioThroughModelViewSet, basename="portfolio-dependencyportfolio"
@@ -101,9 +98,7 @@ portfolio_router.register(
     viewsets.CompositionModelPortfolioPandasView,
     basename="portfolio-modelcompositionpandas",
 )
-portfolio_router.register(
-    r"feesaggregated", viewsets.FeesAggregatedPortfolioPandasView, basename="portfolio-feesaggregated"
-)
+
 portfolio_router.register(
     r"distributionchart",
     viewsets.DistributionChartViewSet,
@@ -139,10 +134,12 @@ product_router = WBCoreRouter()
 product_router.register(r"nominalchart", viewsets.NominalProductChartView, basename="product-nominalchart")
 product_router.register(r"aumchart", viewsets.AUMProductChartView, basename="product-aumchart")
 product_router.register(r"claim", viewsets.ClaimProductModelViewSet, basename="product-claim")
+product_router.register(r"feesaggregated", viewsets.FeesAggregatedProductPandasView, basename="product-feesaggregated")
+product_router.register(r"fees", viewsets.FeesProductModelViewSet, basename="product-fees")
 
-# Subrouter for Trade Proposal
-trade_proposal_router = WBCoreRouter()
-trade_proposal_router.register(r"trade", viewsets.TradeTradeProposalModelViewSet, basename="tradeproposal-trade")
+# Subrouter for Order Proposal
+order_proposal_router = WBCoreRouter()
+order_proposal_router.register(r"order", viewsets.OrderOrderProposalModelViewSet, basename="orderproposal-order")
 
 trade_router = WBCoreRouter()
 trade_router.register(r"claim", viewsets.ClaimTradeModelViewSet, basename="trade-claim")
@@ -253,7 +250,7 @@ urlpatterns = [
     path("product/<int:product_id>/", include(product_router.urls)),
     path("trade/<int:trade_id>/", include(trade_router.urls)),
     path("portfolio/<int:portfolio_id>/", include(portfolio_router.urls)),
-    path("tradeproposal/<int:trade_proposal_id>/", include(trade_proposal_router.urls)),
+    path("orderproposal/<int:order_proposal_id>/", include(order_proposal_router.urls)),
     path("instrument/<int:instrument_id>/", include(instrument_router.urls)),
     path("account/<int:account_id>/", include(account_router.urls)),
     path("entry/<int:entry_id>/", include(entry_router.urls)),

wbportfolio/viewsets/__init__.py

@@ -2,12 +2,16 @@ from .assets import (
     AssetPositionInstrumentModelViewSet,
     AssetPositionModelViewSet,
     AssetPositionPortfolioModelViewSet,
-    AssetPositionUnderlyingInstrumentChartViewSet,
     CashPositionPortfolioPandasAPIView,
     CompositionModelPortfolioPandasView,
-    ContributorPortfolioChartView,
 )
-from .charts import *
+from .charts import (
+    DistributionChartViewSet,
+    DistributionTableViewSet,
+    AssetPositionUnderlyingInstrumentChartViewSet,
+    ContributorPortfolioChartView
+
+)
 from .custodians import CustodianModelViewSet, CustodianRepresentationViewSet
 from .portfolio_relationship import InstrumentPreferedClassificationThroughProductModelViewSet
 from .portfolios import (
@@ -23,8 +27,9 @@ from .positions import (
 )
 from .registers import RegisterModelViewSet, RegisterRepresentationViewSet
 from .roles import PortfolioRoleInstrumentModelViewSet, PortfolioRoleModelViewSet
-from .signals import *
+from .rebalancing import RebalancingModelRepresentationViewSet, RebalancerRepresentationViewSet, RebalancerModelViewSet
 from .transactions import *
+from .orders import *
 from .adjustments import AdjustmentEquityModelViewSet, AdjustmentModelViewSet
 from .product_groups import ProductGroupModelViewSet, ProductGroupRepresentationViewSet
 from .product_performance import (