wbportfolio 2.2.1__py2.py3-none-any.whl

wbportfolio/serializers/transactions/trades.py

@@ -0,0 +1,315 @@
+from datetime import timedelta
+from decimal import Decimal
+
+from rest_framework import serializers
+from rest_framework.reverse import reverse
+from wbcore import serializers as wb_serializers
+from wbportfolio.models import Portfolio, PortfolioRole, Trade, TradeProposal
+from wbportfolio.models.transactions.claim import Claim
+from wbportfolio.serializers.custodians import CustodianRepresentationSerializer
+from wbportfolio.serializers.portfolios import PortfolioRepresentationSerializer
+from wbportfolio.serializers.registers import RegisterRepresentationSerializer
+
+from .transactions import (
+    TransactionModelSerializer,
+    TransactionRepresentationSerializer,
+)
+
+
+class CopyClaimRepresentationSerializer(wb_serializers.RepresentationSerializer):
+    claimant = wb_serializers.StringRelatedField()
+    product = wb_serializers.StringRelatedField()
+    account = wb_serializers.StringRelatedField()
+    _detail = wb_serializers.HyperlinkField(reverse_name="wbportfolio:claim-detail")
+
+    class Meta:
+        model = Claim
+        fields = (
+            "id",
+            "shares",
+            "claimant",
+            "bank",
+            "product",
+            "account",
+            "_detail",
+        )
+
+
+class TradeProposalRepresentationSerializer(wb_serializers.RepresentationSerializer):
+    _detail = wb_serializers.HyperlinkField(reverse_name="wbportfolio:tradeproposal-detail")
+
+    class Meta:
+        model = TradeProposal
+        fields = ("id", "trade_date", "status", "_detail")
+
+
+class TradeRepresentationSerializer(TransactionRepresentationSerializer):
+    _detail = wb_serializers.HyperlinkField(reverse_name="wbportfolio:trade-detail")
+
+    diff_shares = wb_serializers.SerializerMethodField()
+
+    def get_diff_shares(self, obj):
+        return obj._diff_shares
+
+    class Meta:
+        model = Trade
+        fields = ("claimed_shares", "diff_shares", "bank", "shares") + TransactionRepresentationSerializer.Meta.fields
+
+
+class TradeClaimRepresentationSerializer(TradeRepresentationSerializer):
+    def get_filter_params(self, request):
+        claim_id = request.parser_context["view"].kwargs.get("pk", None)
+        arg = {"marked_for_deletion": False}
+        if claim_id:
+            claim = Claim.objects.get(id=claim_id)
+            arg.update(
+                {
+                    "underlying_instrument": claim.product.id,
+                    "transaction_date__gte": claim.date - timedelta(days=Trade.TRADE_WINDOW_INTERVAL),
+                    "transaction_date__lte": claim.date + timedelta(days=Trade.TRADE_WINDOW_INTERVAL),
+                }
+            )
+            if claim.shares:
+                if claim.shares > 0:
+                    arg["shares__gte"] = claim.shares
+                else:
+                    arg["shares__lte"] = claim.shares
+            return arg
+        return {}
+
+
+class TradeModelSerializer(TransactionModelSerializer):
+    marked_for_deletion = wb_serializers.BooleanField(required=False, read_only=True)
+    marked_as_internal = wb_serializers.BooleanField()
+
+    approved_claimed_shares = wb_serializers.DecimalField(
+        max_digits=10, decimal_places=2, required=False, read_only=True, default=Decimal(0.0)
+    )
+    pending_claimed_shares = wb_serializers.DecimalField(
+        max_digits=10, decimal_places=2, required=False, read_only=True, default=Decimal(0.0)
+    )
+    completely_claimed = wb_serializers.BooleanField(required=False, read_only=True, default=Decimal(0.0))
+    completely_claimed_if_approved = wb_serializers.BooleanField(required=False, read_only=True, default=Decimal(0.0))
+
+    # We commented it because people needs to filter with lookup equals onto these fields
+    # shares = wb_serializers.DecimalField(max_digits=16, decimal_places=2)
+    # price = wb_serializers.DecimalField(max_digits=16, decimal_places=2)
+
+    _register = RegisterRepresentationSerializer(source="register")
+    claims = wb_serializers.PrimaryKeyRelatedField(queryset=Claim.objects.all(), label="Claims", many=True)
+    _claims = CopyClaimRepresentationSerializer(source="claims", many=True)
+    _custodian = CustodianRepresentationSerializer(source="custodian")
+    _internal_trade = TradeRepresentationSerializer(
+        source="internal_trade",
+        filter_params={"only_internal_trade": True},
+        optional_get_parameters={"underlying_instrument": "underlying_instrument", "transaction_date": "pivot_date"},
+        depends_on=[{"field": "marked_as_internal", "options": {"activates_on": [True]}}],
+    )
+
+    @wb_serializers.register_only_instance_resource()
+    def import_source_file_url(self, instance, request, user, *args, **kwargs):
+        if PortfolioRole.is_portfolio_manager(user.profile, instance.underlying_instrument):
+            if instance.import_source:
+                return {"import_source": instance.import_source.file.url}
+        return {}
+
+    @wb_serializers.register_resource()
+    def claims_list(self, instance, request, user):
+        if instance.is_claimable:
+            return {
+                "claims": reverse(
+                    "wbportfolio:trade-claim-list",
+                    args=[instance.id],
+                    request=request,
+                )
+            }
+        return {}
+
+    class Meta:
+        model = Trade
+        decorators = TransactionModelSerializer.Meta.decorators
+        read_only_fields = (
+            "id",
+            "shares",
+            "price",
+            "transaction_subtype",
+            "approved_claimed_shares",
+            "pending_claimed_shares",
+            "claimed_shares",
+            "completely_claimed",
+            "completely_claimed_if_approved",
+            "register",
+            "_register",
+            "pending",
+            "bank",
+            "marked_for_deletion",
+            "_claims",
+            "claims",
+            "transaction_type",
+            "transaction_url_type",
+            "transaction_underlying_type",
+            "portfolio",
+            "_portfolio",
+            "underlying_instrument",
+            "_underlying_instrument",
+            "transaction_date",
+            "book_date",
+            "value_date",
+            "currency",
+            "_currency",
+            "currency_fx_rate",
+            "total_value",
+            "total_value_fx_portfolio",
+            "total_value_gross",
+            "total_value_gross_fx_portfolio",
+            "external_id",
+            "total_value_usd",
+            "total_value_gross_usd",
+            "_additional_resources",
+        )
+
+        fields = (
+            "id",
+            "shares",
+            "price",
+            "transaction_subtype",
+            "approved_claimed_shares",
+            "pending_claimed_shares",
+            "claimed_shares",
+            "completely_claimed",
+            "completely_claimed_if_approved",
+            "register",
+            "_register",
+            "pending",
+            "bank",
+            "marked_for_deletion",
+            "_claims",
+            "claims",
+            "transaction_type",
+            "transaction_url_type",
+            "transaction_underlying_type",
+            "portfolio",
+            "_portfolio",
+            "underlying_instrument",
+            "_underlying_instrument",
+            "transaction_date",
+            "book_date",
+            "value_date",
+            "currency",
+            "_currency",
+            "currency_fx_rate",
+            "total_value",
+            "total_value_fx_portfolio",
+            "total_value_gross",
+            "total_value_gross_fx_portfolio",
+            "external_id",
+            "comment",
+            "total_value_usd",
+            "total_value_gross_usd",
+            "_custodian",
+            "custodian",
+            "marked_as_internal",
+            "internal_trade",
+            "_internal_trade",
+            "_additional_resources",
+        )
+
+
+class TradeTradeProposalModelSerializer(TradeModelSerializer):
+    status = wb_serializers.ChoiceField(default=Trade.Status.DRAFT, choices=Trade.Status.choices)
+    target_weight = wb_serializers.DecimalField(max_digits=16, decimal_places=6, required=False, default=0)
+    effective_weight = wb_serializers.DecimalField(read_only=True, max_digits=16, decimal_places=6, default=0)
+
+    def validate(self, data):
+        if self.instance and "underlying_instrument" in data:
+            raise serializers.ValidationError(
+                {
+                    "underlying_instrument": "You cannot modify the underlying instrument other than creating a new entry"
+                }
+            )
+        effective_weight = self.instance._effective_weight if self.instance else Decimal(0.0)
+        if (target_weight := data.pop("target_weight", None)) is not None:
+            data["weighting"] = target_weight - effective_weight
+        if data["weighting"] >= 0:
+            data["transaction_subtype"] = "BUY"
+        else:
+            data["transaction_subtype"] = "SELL"
+        return data
+
+    class Meta:
+        model = Trade
+        percent_fields = ["effective_weight", "target_weight", "weighting"]
+        read_only_fields = (
+            "transaction_subtype",
+            "shares"
+            # "underlying_instrument",
+            # "_underlying_instrument",
+        )
+        fields = (
+            "id",
+            "shares",
+            "underlying_instrument",
+            "_underlying_instrument",
+            "transaction_subtype",
+            "status",
+            # "total_value",
+            # "total_value_fx_portfolio",
+            # "total_value_gross",
+            # "total_value_gross_fx_portfolio",
+            "comment",
+            # "total_value_usd",
+            # "total_value_gross_usd",
+            "effective_weight",
+            "target_weight",
+            "weighting",
+            "trade_proposal",
+            "order",
+        )
+
+
+class ReadOnlyTradeTradeProposalModelSerializer(TradeTradeProposalModelSerializer):
+    class Meta(TradeTradeProposalModelSerializer.Meta):
+        read_only_fields = TradeTradeProposalModelSerializer.Meta.fields
+
+
+class TradeProposalModelSerializer(wb_serializers.ModelSerializer):
+    _model_portfolio = PortfolioRepresentationSerializer(source="model_portfolio")
+    model_portfolio = wb_serializers.PrimaryKeyRelatedField(
+        queryset=Portfolio.objects.all(),
+        default=wb_serializers.DefaultFromKwargs("portfolio_id"),
+        read_only=lambda view: not view.new_mode,
+    )
+    trade_date = wb_serializers.DateField(read_only=lambda view: not view.new_mode)
+
+    def create(self, validated_data):
+        if request := self.context.get("request"):
+            validated_data["creator"] = request.user.profile
+        return super().create(validated_data)
+
+    @wb_serializers.register_only_instance_resource()
+    def additional_resources(self, instance, request, user, **kwargs):
+        res = {}
+        if instance.status == TradeProposal.Status.APPROVED:
+            res["replay"] = reverse("wbportfolio:tradeproposal-replay", args=[instance.id], request=request)
+        if instance.model_portfolio:
+            res["reset"] = reverse("wbportfolio:tradeproposal-reset", args=[instance.id], request=request)
+        res["trades"] = reverse(
+            "wbportfolio:tradeproposal-trade-list",
+            args=[instance.id],
+            request=request,
+        )
+        return res
+
+    class Meta:
+        model = TradeProposal
+        only_fsm_transition_on_instance = True
+        fields = (
+            "id",
+            "trade_date",
+            "comment",
+            "status",
+            "portfolio",
+            "_model_portfolio",
+            "model_portfolio",
+            "_additional_resources",
+        )

wbportfolio/serializers/transactions/transactions.py

@@ -0,0 +1,84 @@
+from wbcore import serializers as wb_serializers
+from wbcore.contrib.currency.serializers import CurrencyRepresentationSerializer
+from wbfdm.serializers.instruments import InvestableInstrumentRepresentationSerializer
+from wbportfolio.models import Transaction
+from wbportfolio.serializers.portfolios import PortfolioRepresentationSerializer
+
+
+class TransactionRepresentationSerializer(wb_serializers.RepresentationSerializer):
+    _detail = wb_serializers.HyperlinkField(reverse_name="wbportfolio:transaction-detail")
+
+    class Meta:
+        model = Transaction
+        fields = ("id", "transaction_date", "total_value", "_detail")
+
+
+class TransactionModelSerializer(wb_serializers.ModelSerializer):
+    external_id = wb_serializers.CharField(required=False, read_only=True)
+    value_date = wb_serializers.DateField(required=False, read_only=True)
+    total_value_usd = wb_serializers.FloatField(default=0, read_only=True, label="Total Value ($)")
+    total_value_gross_usd = wb_serializers.FloatField(default=0, read_only=True, label="Total Value Gross ($)")
+    transaction_underlying_type = wb_serializers.CharField(read_only=True)
+    transaction_url_type = wb_serializers.SerializerMethodField()
+    _portfolio = PortfolioRepresentationSerializer(source="portfolio")
+    _underlying_instrument = InvestableInstrumentRepresentationSerializer(source="underlying_instrument")
+    _currency = CurrencyRepresentationSerializer(source="currency")
+
+    total_value = wb_serializers.DecimalField(max_digits=14, decimal_places=2, read_only=True)
+    total_value_fx_portfolio = wb_serializers.DecimalField(max_digits=14, decimal_places=2, read_only=True)
+    total_value_gross = wb_serializers.DecimalField(max_digits=14, decimal_places=2, read_only=True)
+    total_value_gross_fx_portfolio = wb_serializers.DecimalField(max_digits=14, decimal_places=2, read_only=True)
+
+    def get_transaction_url_type(self, obj):
+        return obj.transaction_type.lower()
+
+    # def get_transaction_underlying_type(self, obj):
+    #     try:
+    #         casted_transaction = obj.get_casted_transaction()
+    #         return casted_transaction.Type[casted_transaction.transaction_subtype].label
+    #     except Exception as e:
+    #         return ""
+    class Meta:
+        model = Transaction
+        decorators = {
+            "total_value": wb_serializers.decorator(
+                decorator_type="text", position="left", value="{{_currency.symbol}}"
+            ),
+            "total_value_gross": wb_serializers.decorator(
+                decorator_type="text", position="left", value="{{_currency.symbol}}"
+            ),
+            "total_value_usd": wb_serializers.decorator(decorator_type="text", position="left", value="{{$}}"),
+            "total_value_gross_usd": wb_serializers.decorator(decorator_type="text", position="left", value="{{$}}"),
+            "total_value_fx_portfolio": wb_serializers.decorator(
+                position="left", value="{{_portfolio.currency_symbol}}"
+            ),
+            "total_value_gross_fx_portfolio": wb_serializers.decorator(
+                position="left", value="{{_portfolio.currency_symbol}}"
+            )
+            # "total_value_fx_portfolio": wb_serializers.decorator(decorator_type="text", position="left", value="{{_portfolio.currency_symbol}}}"),
+            # "total_value_gross_fx_portfolio": wb_serializers.decorator(decorator_type="text", position="left", value="{{_portfolio.currency_symbol}}"),
+        }
+        fields = (
+            "id",
+            "transaction_type",
+            "transaction_url_type",
+            "transaction_underlying_type",
+            "portfolio",
+            "_portfolio",
+            "underlying_instrument",
+            "_underlying_instrument",
+            "transaction_date",
+            "book_date",
+            "value_date",
+            "currency",
+            "_currency",
+            "currency_fx_rate",
+            "total_value",
+            "total_value_fx_portfolio",
+            "total_value_gross",
+            "total_value_gross_fx_portfolio",
+            "external_id",
+            "comment",
+            "total_value_usd",
+            "total_value_gross_usd",
+        )

wbportfolio/tasks.py

@@ -0,0 +1,125 @@
+from contextlib import suppress
+from datetime import date, timedelta
+
+from celery import chain, chord
+from django.db.models import ProtectedError, Q
+from pandas.tseries.offsets import BDay
+from tqdm import tqdm
+from wbfdm.models import InstrumentPrice
+from wbportfolio.models import Portfolio, Trade
+from wbportfolio.models.portfolio import propagate_or_update_portfolio_assets_as_task
+from wbportfolio.models.products import Product, update_outstanding_shares_as_task
+
+from .fdm.tasks import *  # noqa
+
+
+@shared_task()
+def dummy_task():
+    return True
+
+
+@shared_task(queue="portfolio")
+def periodically_update_outstanding_shares_for_active_products():
+    qs = Product.active_objects.all()
+    for product in tqdm(qs, total=qs.count()):
+        update_outstanding_shares_as_task(product.id)
+
+
+@shared_task(queue="portfolio")
+def periodically_clean_marked_for_deletion_trades(max_allowed_iterations: int = 5):
+    # Get all trade marked for deletion or pending and older than 7 days (i.e. After 7 days, we consider the pending trade obselete)
+    qs = Trade.objects.filter(
+        Q(marked_for_deletion=True) | (Q(pending=True) & Q(transaction_date__lt=date.today() - timedelta(days=7)))
+    )
+    i = 0
+
+    # We try several times in case the trades deletion mechanism shifts the marked for deletion tag forwards
+    while i < max_allowed_iterations and qs.exists():
+        for t in qs:
+            with suppress(ProtectedError):
+                t.delete()
+        qs = Trade.objects.filter(marked_for_deletion=True)
+        i += 1
+
+
+# Daily synchronization tasks.
+# This tasks needs to be ran at maximum once a day in order to guarantee data consitency in
+# case of change in change (e.g. reimport).
+@shared_task(queue="portfolio")
+def daily_instrument_price_statistics_synchronization(today: date = None, day_periods: int = 7):
+    if not today:
+        today = date.today()
+
+    # We query for the last 7 days unsynch instrument prices.
+    prices = (
+        InstrumentPrice.objects.filter(
+            date__gte=today - timedelta(days=day_periods), instrument__related_instruments__isnull=False
+        )
+        .filter(Q(sharpe_ratio__isnull=True) | Q(correlation__isnull=True) | Q(beta__isnull=True))
+        .distinct()
+    )
+    objs = []
+    for p in prices.iterator():
+        p.compute_and_update_statistics()
+        objs.append(p)
+    InstrumentPrice.objects.bulk_update(objs, fields=["sharpe_ratio", "correlation", "beta"])
+
+
+# A Task to run every day to update automatically the preferred classification
+# per instrument of each wbportfolio containing assets.
+@shared_task(queue="portfolio")
+def update_preferred_classification_per_instrument_and_portfolio_as_task():
+    for portfolio in Portfolio.tracked_objects.all():
+        portfolio.update_preferred_classification_per_instrument()
+
+
+# This task needs to run at fix interval. It will trigger the basic wbportfolio synchronization update:
+# - Fetch for stainly price at t-1
+# - propagate (or update) t-2 asset positions into t-1
+# - Synchronize wbportfolio at t-1
+# - Compute Instrument Price estimate at t-1
+
+
+@shared_task(queue="portfolio")
+def general_portfolio_synchronization_and_update(task_date=None):
+    if not task_date:
+        task_date = date.today()
+    t_1 = (task_date - BDay(1)).date()
+    t_2 = (t_1 - BDay(1)).date()
+
+    # We propagate or update assets position from t-2 to t-1 (Needs stainly t-1 prices)
+    subroutines_propagate_or_update_portfolio_assets = list()
+    for portfolio in Portfolio.tracked_objects.all():
+        if (
+            portfolio.assets.filter(date=t_2).exists()
+            and not portfolio.assets.filter(date=t_1, is_estimated=False).exists()
+        ):
+            subroutines_propagate_or_update_portfolio_assets.append(
+                propagate_or_update_portfolio_assets_as_task.si(portfolio.id, t_2, t_1)
+            )
+
+    # # Synchronize wbportfolio at t-1 (needs propagated data)
+    # subroutines_synchronize_computed_positions = list()
+    # for method in PortfolioSynchronization.objects.all():
+    #     for portfolio in method.portfolios.all():
+    #         subroutines_synchronize_computed_positions.append(
+    #             synchronize_portfolio_as_task.si(portfolio.id, t_1, synchronization_method_id=method.id)
+    #         )
+    #
+    # # Compute price estimate at t-1 (needs synchronized wbportfolio)
+    # subroutines_compute_price = list()
+    # for method in PriceComputation.objects.all():
+    #     for instrument in method.instruments.all():
+    #         subroutines_compute_price.append(
+    #             compute_price_as_task.si(instrument.id, t_1, price_computation_method_id=method.id)
+    #         )
+
+    subroutines_propagate_or_update_portfolio_assets_group = chord(
+        subroutines_propagate_or_update_portfolio_assets, dummy_task.si()
+    )
+
+    chain(
+        subroutines_propagate_or_update_portfolio_assets_group,
+        # subroutines_synchronize_computed_positions_group,
+        # subroutines_compute_price_group
+    ).apply_async()

wbportfolio/tests/conftest.py

@@ -0,0 +1,164 @@
+from datetime import date
+
+from faker import Faker
+from pandas.tseries.offsets import BDay
+from wbcompliance.factories.risk_management import (
+    RiskRuleFactory,
+    RuleBackendFactory,
+    RuleThresholdFactory,
+)
+from wbcore.contrib.authentication.factories import (
+    InternalUserFactory,
+    SuperUserFactory,
+)
+from wbcore.contrib.currency.factories import CurrencyFactory, CurrencyFXRatesFactory
+from wbcore.contrib.directory.factories.entries import (
+    CompanyFactory,
+    CompanyTypeFactory,
+    CustomerStatusFactory,
+    EntryFactory,
+    PersonFactory,
+)
+from wbcore.contrib.geography.factories import CityFactory, CountryFactory, StateFactory
+from wbcore.contrib.io.factories import (
+    DataBackendFactory,
+    ImportSourceFactory,
+    ParserHandlerFactory,
+    ProviderFactory,
+    SourceFactory,
+)
+from wbcrm.factories import AccountFactory, AccountRoleFactory, AccountWithOwnerFactory
+from wbfdm.factories import (
+    CashFactory,
+    ClassificationFactory,
+    ClassificationGroupFactory,
+    EquityFactory,
+    ExchangeFactory,
+    InstrumentFactory,
+    InstrumentListFactory,
+    InstrumentPriceFactory,
+    InstrumentTypeFactory,
+)
+from wbportfolio.factories import (
+    AccountReconciliationFactory,
+    AccountReconciliationLineFactory,
+    AdjustmentFactory,
+    AssetPositionFactory,
+    ClaimFactory,
+    CustodianFactory,
+    CustomerTradeFactory,
+    DailyPortfolioCashFlowFactory,
+    DividendTransactionsFactory,
+    FeesFactory,
+    IndexFactory,
+    IndexProductFactory,
+    InstrumentPortfolioThroughModelFactory,
+    ManagerPortfolioRoleFactory,
+    ModelPortfolioFactory,
+    ModelPortfolioWithBaseProductFactory,
+    NegativeClaimFactory,
+    PortfolioCashTargetFactory,
+    PortfolioFactory,
+    PortfolioSwingPricingFactory,
+    ProductFactory,
+    ProductGroupFactory,
+    ProductGroupRepresentantFactory,
+    ProductPortfolioRoleFactory,
+    TradeFactory,
+    TradeProposalFactory,
+    WhiteLabelProductFactory,
+)
+from wbportfolio.factories.synchronization import (
+    CrontabScheduleFactory,
+    PeriodicTaskFactory,
+    PortfolioSynchronizationFactory,
+    PriceComputationFactory,
+    SynchronizationTaskFactory,
+)
+
+from wbcore.tests.conftest import *  # isort:skip
+
+
+fake = Faker()
+
+register(AccountFactory)
+register(AccountWithOwnerFactory)
+register(AccountRoleFactory)
+
+register(ImportSourceFactory)
+register(DataBackendFactory)
+register(ProviderFactory)
+register(SourceFactory)
+register(ParserHandlerFactory)
+
+register(AssetPositionFactory)
+register(ProductFactory)
+register(ProductGroupFactory)
+register(ProductGroupRepresentantFactory)
+register(PortfolioFactory)
+register(InstrumentPortfolioThroughModelFactory)
+register(ModelPortfolioFactory)
+register(ModelPortfolioWithBaseProductFactory, "model_portfolio_with_base_product")
+register(TradeFactory)
+register(CustomerTradeFactory)
+register(TradeProposalFactory)
+register(DividendTransactionsFactory)
+register(FeesFactory)
+register(WhiteLabelProductFactory, "white_label_product")
+register(InstrumentPriceFactory)
+register(IndexProductFactory, "index_product")
+register(CurrencyFXRatesFactory)
+register(ProductPortfolioRoleFactory, "product_portfolio_role")
+register(ManagerPortfolioRoleFactory, "manager_portfolio_role")
+
+register(CurrencyFactory)
+register(CityFactory)
+register(StateFactory)
+register(CountryFactory)
+register(ContinentFactory)
+
+register(CompanyFactory)
+register(PersonFactory)
+register(InternalUserFactory)
+register(EntryFactory)
+register(CustomerStatusFactory)
+register(CompanyTypeFactory)
+
+register(UserFactory)
+register(SuperUserFactory, "superuser")
+register(CustodianFactory)
+
+register(CrontabScheduleFactory)
+register(PeriodicTaskFactory)
+register(SynchronizationTaskFactory)
+register(PortfolioSynchronizationFactory)
+register(PriceComputationFactory)
+register(AdjustmentFactory)
+register(IndexFactory)
+
+
+register(RuleThresholdFactory)
+register(RiskRuleFactory)
+register(RuleBackendFactory)
+
+register(ClaimFactory)
+register(NegativeClaimFactory, "negative_claim")
+
+register(InstrumentFactory)
+register(InstrumentTypeFactory)
+register(EquityFactory, "equity")
+register(CashFactory, "cash")
+register(InstrumentListFactory)
+register(ExchangeFactory)
+register(ClassificationFactory)
+register(ClassificationGroupFactory)
+register(PortfolioSwingPricingFactory)
+register(PortfolioCashTargetFactory)
+register(DailyPortfolioCashFlowFactory)
+
+register(AccountReconciliationFactory)
+register(AccountReconciliationLineFactory)
+
+
+pre_migrate.connect(app_pre_migration, sender=apps.get_app_config("wbportfolio"))
+from .signals import *  # noqa: F401