wbportfolio 1.54.14__py2.py3-none-any.whl → 1.54.15__py2.py3-none-any.whl

wbportfolio/tests/models/test_portfolios.py

@@ -1053,25 +1053,26 @@ class TestPortfolioModel(PortfolioTestMixin):
         asset_position_factory.create(date=weekday, portfolio=portfolio, underlying_instrument=i2, weighting=0.3)
 
         rebalancer_factory.create(portfolio=portfolio, frequency="RRULE:FREQ=DAILY;", activation_date=rebalancing_date)
-        positions, rebalancing_trade_proposal = portfolio.drift_weights(
+        positions, rebalancing_order_proposal = portfolio.drift_weights(
             weekday, (rebalancing_date + BDay(1)).date(), stop_at_rebalancing=True
         )
-        assert rebalancing_trade_proposal.trade_date == rebalancing_date
-        assert rebalancing_trade_proposal.status == "SUBMIT"
+        assert rebalancing_order_proposal.trade_date == rebalancing_date
+        assert rebalancing_order_proposal.status == "SUBMIT"
         assert set(positions.get_weights().keys()) == {
             middle_date,
         }, "Drifting weight with a non automatic rebalancer stops the iteration"
 
-        # we expect a equally rebalancing (default) so both trades needs to be created
-        t1 = rebalancing_trade_proposal.trades.get(transaction_date=rebalancing_date, underlying_instrument=i1)
-        t2 = rebalancing_trade_proposal.trades.get(transaction_date=rebalancing_date, underlying_instrument=i2)
+        # we expect a equally rebalancing (default) so both orders needs to be created
+        orders = rebalancing_order_proposal.get_orders()
+        t1 = orders.get(value_date=rebalancing_date, underlying_instrument=i1)
+        t2 = orders.get(value_date=rebalancing_date, underlying_instrument=i2)
         assert t1._target_weight == Decimal("0.5")
         assert t2._target_weight == Decimal("0.5")
 
-        # we approve the rebalancing trade proposal
-        assert rebalancing_trade_proposal.status == "SUBMIT"
-        rebalancing_trade_proposal.approve(replay=False)
-        rebalancing_trade_proposal.save()
+        # we approve the rebalancing order proposal
+        assert rebalancing_order_proposal.status == "SUBMIT"
+        rebalancing_order_proposal.approve(replay=False)
+        rebalancing_order_proposal.save()
 
         # check that the rebalancing was applied and position reflect that
         assert portfolio.assets.get(date=rebalancing_date, underlying_instrument=i1).weighting == Decimal("0.5")

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(approve_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.APPROVED
         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/rebalancing/test_models.py

@@ -4,8 +4,8 @@ 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
@@ -83,50 +83,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.APPROVED
         )
-        t1 = TradeFactory.create(
+        t1 = OrderFactory.create(
             portfolio=model.portfolio,
-            transaction_date=model.last_effective_date,
-            transaction_subtype=Trade.Type.BUY,
-            trade_proposal=trade_proposal,
+            value_date=model.last_effective_date,
+            order_type=Order.Type.BUY,
+            order_proposal=order_proposal,
             weighting=Decimal(0.7),
-            status=Trade.Status.EXECUTED,
         )
-        TradeFactory.create(
+        OrderFactory.create(
             portfolio=model.portfolio,
-            transaction_date=model.last_effective_date,
-            transaction_subtype=Trade.Type.BUY,
-            trade_proposal=trade_proposal,
+            value_date=model.last_effective_date,
+            order_type=Order.Type.BUY,
+            order_proposal=order_proposal,
             weighting=Decimal(0.3),
-            status=Trade.Status.EXECUTED,
         )
         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.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(
+        t1 = OrderFactory.create(
             portfolio=model.portfolio,
-            transaction_date=model.last_effective_date,
-            transaction_subtype=Trade.Type.BUY,
-            trade_proposal=trade_proposal,
+            value_date=model.last_effective_date,
+            order_type=Order.Type.BUY,
+            order_proposal=order_proposal,
             weighting=Decimal(0.8),
-            status=Trade.Status.EXECUTED,
         )
-        t2 = TradeFactory.create(
+        t2 = OrderFactory.create(
             portfolio=model.portfolio,
-            transaction_date=model.last_effective_date,
-            transaction_subtype=Trade.Type.BUY,
-            trade_proposal=trade_proposal,
+            value_date=model.last_effective_date,
+            order_type=Order.Type.BUY,
+            order_proposal=order_proposal,
             weighting=Decimal(0.2),
-            status=Trade.Status.EXECUTED,
         )
         target_portfolio = model.get_target_portfolio()
         target_positions = target_portfolio.positions_map
@@ -162,5 +158,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,
@@ -20,14 +20,14 @@ from wbportfolio.viewsets import (
     DistributionChartViewSet,
     DistributionTableViewSet,
     NominalProductChartView,
+    OrderOrderProposalModelViewSet,
+    OrderProposalPortfolioModelViewSet,
     PortfolioRoleInstrumentModelViewSet,
     ProductCustomerModelViewSet,
     ProductPerformanceFeesModelViewSet,
     SubscriptionRedemptionInstrumentModelViewSet,
     SubscriptionRedemptionModelViewSet,
     TradeInstrumentModelViewSet,
-    TradeProposalPortfolioModelViewSet,
-    TradeTradeProposalModelViewSet,
 )
 
 # =================================================================================================================
@@ -54,18 +54,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 {}

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",

wbportfolio/urls.py

@@ -38,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",
@@ -62,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",
@@ -88,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"
@@ -137,9 +137,9 @@ product_router.register(r"claim", viewsets.ClaimProductModelViewSet, basename="p
 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"trade", viewsets.OrderOrderProposalModelViewSet, basename="orderproposal-order")
 
 trade_router = WBCoreRouter()
 trade_router.register(r"claim", viewsets.ClaimTradeModelViewSet, basename="trade-claim")
@@ -250,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

@@ -24,7 +24,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 (

wbportfolio/viewsets/configs/buttons/__init__.py

@@ -15,9 +15,8 @@ from .products import ProductButtonConfig, ProductCustomerButtonConfig
 from .registers import RegisterButtonConfig
 from .trades import (
     TradeButtonConfig,
-    TradeInstrumentButtonConfig,
-    TradeTradeProposalButtonConfig
+    TradeInstrumentButtonConfig
 )
-from .trade_proposals import TradeProposalButtonConfig
+
 from .reconciliations import AccountReconciliationButtonViewConfig, AccountReconciliationLineButtonViewConfig
 from .signals import *

wbportfolio/viewsets/configs/buttons/trades.py

@@ -1,7 +1,6 @@
 from rest_framework.reverse import reverse
 from wbcore.contrib.icons import WBIcon
 from wbcore.metadata.configs import buttons as bt
-from wbcore.metadata.configs.buttons.enums import Button
 from wbcore.metadata.configs.buttons.view_config import ButtonViewConfig
 from wbfdm.models import Instrument
 
@@ -59,10 +58,3 @@ class TradeInstrumentButtonConfig(TradeButtonConfig):
                     )
                 )
         return res
-
-
-class TradeTradeProposalButtonConfig(ButtonViewConfig):
-    def get_create_buttons(self):
-        return {
-            Button.SAVE_AND_CLOSE.value,
-        }

wbportfolio/viewsets/configs/display/__init__.py

@@ -49,9 +49,7 @@ from .trades import (
     SubscriptionRedemptionDisplayConfig,
     TradeDisplayConfig,
     TradePortfolioDisplayConfig,
-    TradeTradeProposalDisplayConfig,
 )
-from .trade_proposals import TradeProposalDisplayConfig
 from .portfolio_relationship import (
     PortfolioInstrumentPreferredClassificationThroughDisplayConfig,
     InstrumentPortfolioThroughPortfolioModelDisplayConfig,

wbportfolio/viewsets/configs/display/portfolios.py

@@ -51,9 +51,9 @@ class PortfolioDisplayConfig(DisplayViewConfig):
                     key=None,
                     children=[
                         dp.Field(key="automatic_rebalancer", label="Automatic Rebalancer"),
-                        dp.Field(key="last_trade_proposal_date", label="Last Rebalance", width=Unit.PIXEL(250)),
+                        dp.Field(key="last_order_proposal_date", label="Last Rebalance", width=Unit.PIXEL(250)),
                         dp.Field(
-                            key="next_expected_trade_proposal_date",
+                            key="next_expected_order_proposal_date",
                             label="Next Rebalancing",
                             width=Unit.PIXEL(250),
                             show="open",
@@ -126,15 +126,15 @@ class PortfolioDisplayConfig(DisplayViewConfig):
                     },
                 ),
                 Page(
-                    title="Trade",
+                    title="Order",
                     layouts={
                         default(): dp.Layout(
                             grid_template_areas=[
-                                ["trade_proposals"],
+                                ["order_proposals"],
                             ],
                             grid_template_rows=["auto"],
                             inlines=[
-                                dp.Inline(key="trade_proposals", endpoint="trade_proposals"),
+                                dp.Inline(key="order_proposals", endpoint="order_proposals"),
                             ],
                         )
                     },

wbportfolio/viewsets/configs/display/rebalancing.py

@@ -11,7 +11,7 @@ class RebalancerDisplayConfig(DisplayViewConfig):
             fields=[
                 dp.Field(key="portfolio", label="Portfolio"),
                 dp.Field(key="rebalancing_model", label="Rebalancing Model"),
-                dp.Field(key="approve_trade_proposal_automatically", label="Approve automatically"),
+                dp.Field(key="approve_order_proposal_automatically", label="Approve automatically"),
                 dp.Field(key="frequency_repr", label="Frequency"),
                 dp.Field(key="activation_date", label="Activation Date"),
             ],
@@ -20,7 +20,7 @@ class RebalancerDisplayConfig(DisplayViewConfig):
     def get_instance_display(self) -> Display:
         return create_simple_display(
             [
-                ["rebalancing_model", "approve_trade_proposal_automatically"],
+                ["rebalancing_model", "approve_order_proposal_automatically"],
                 ["frequency", "activation_date"],
                 ["rebalancing_dates", "rebalancing_dates"],
             ]