wbportfolio 2.2.1__py2.py3-none-any.whl

wbportfolio/factories/portfolio_swing_pricings.py

@@ -0,0 +1,15 @@
+import factory
+from wbportfolio.factories.portfolios import PortfolioFactory
+from wbportfolio.models import PortfolioSwingPricing
+
+
+class PortfolioSwingPricingFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = PortfolioSwingPricing
+
+    valid_date = factory.Faker("date")
+    portfolio = factory.SubFactory(PortfolioFactory)
+    negative_threshold = factory.Faker("pydecimal", left_digits=0, right_digits=4, min_value=-0.99, max_value=-0.01)
+    negative_swing_factor = factory.Faker("pydecimal", left_digits=0, right_digits=4, min_value=-0.99, max_value=-0.01)
+    positive_threshold = factory.Faker("pydecimal", left_digits=0, right_digits=4, min_value=0.01, max_value=0.99)
+    positive_swing_factor = factory.Faker("pydecimal", left_digits=0, right_digits=4, min_value=0.01, max_value=0.99)

wbportfolio/factories/portfolios.py

@@ -0,0 +1,59 @@
+from datetime import date
+
+import factory
+from psycopg.types.range import DateRange
+from wbportfolio.models import (
+    InstrumentPortfolioThroughModel,
+    Portfolio,
+    PortfolioPortfolioThroughModel,
+)
+
+from .products import ProductFactory
+
+
+class PortfolioFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = Portfolio
+
+    name = factory.Sequence(lambda n: f"Portfolio {n}")
+    currency = factory.SubFactory("wbcore.contrib.currency.factories.CurrencyFactory")
+    is_manageable = True
+    invested_timespan = DateRange(date.min, date.max)
+
+    @factory.post_generation
+    def depends_on(self, create, extracted, **kwargs):
+        if not create:
+            return
+
+        if extracted:
+            for portfolio in extracted:
+                self.depends_on.add(portfolio)
+
+
+class ModelPortfolioFactory(PortfolioFactory):
+    @factory.post_generation
+    def dependant_portfolios(self, create, extracted, **kwargs):
+        PortfolioPortfolioThroughModel.objects.create(
+            portfolio=PortfolioFactory.create(),
+            dependency_portfolio=self,
+            type=PortfolioPortfolioThroughModel.Type.MODEL,
+        )
+
+
+class ModelPortfolioWithBaseProductFactory(ModelPortfolioFactory):
+    @factory.post_generation
+    def create_instrument(self, create, extracted, **kwargs):
+        if create:
+            instrument = ProductFactory.create()
+            InstrumentPortfolioThroughModel.objects.update_or_create(
+                instrument=instrument, defaults={"portfolio": self}
+            )
+
+
+class InstrumentPortfolioThroughModelFactory(factory.django.DjangoModelFactory):
+    instrument = factory.SubFactory("wbportfolio.factories.ProductFactory")
+    portfolio = factory.SubFactory("wbportfolio.factories.PortfolioFactory")
+
+    class Meta:
+        model = InstrumentPortfolioThroughModel
+        django_get_or_create = ("instrument",)

wbportfolio/factories/product_groups.py

@@ -0,0 +1,28 @@
+import factory
+from wbfdm.factories.instruments import InstrumentFactory
+from wbportfolio.models import ProductGroup, ProductGroupRepresentant
+
+
+class ProductGroupFactory(InstrumentFactory):
+    class Meta:
+        model = ProductGroup
+
+    type = factory.Faker("random_element", elements=[x[0] for x in ProductGroup.ProductGroupType.choices])
+    category = factory.Faker("random_element", elements=[x[0] for x in ProductGroup.ProductGroupCategory.choices])
+    umbrella = factory.Faker("company")
+    management_company = factory.SubFactory("wbcore.contrib.directory.factories.entries.CompanyFactory")
+    depositary = factory.SubFactory("wbcore.contrib.directory.factories.entries.CompanyFactory")
+    transfer_agent = factory.SubFactory("wbcore.contrib.directory.factories.entries.CompanyFactory")
+    administrator = factory.SubFactory("wbcore.contrib.directory.factories.entries.CompanyFactory")
+    investment_manager = factory.SubFactory("wbcore.contrib.directory.factories.entries.CompanyFactory")
+    auditor = factory.SubFactory("wbcore.contrib.directory.factories.entries.CompanyFactory")
+    paying_agent = factory.SubFactory("wbcore.contrib.directory.factories.entries.CompanyFactory")
+
+
+class ProductGroupRepresentantFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = ProductGroupRepresentant
+
+    product_group = factory.SubFactory(ProductGroupFactory)
+    representant = factory.SubFactory("wbcore.contrib.directory.factories.entries.CompanyFactory")
+    country = factory.SubFactory("wbcore.contrib.geography.factories.CountryFactory")

wbportfolio/factories/products.py

@@ -0,0 +1,56 @@
+import random
+
+import factory
+from wbcore.contrib.directory.factories.entries import CompanyFactory
+from wbfdm.factories.instruments import InstrumentFactory, InstrumentTypeFactory
+from wbportfolio.models.products import (
+    AssetClass,
+    InvestmentIndex,
+    LegalStructure,
+    Liquidy,
+    Product,
+    TypeOfReturn,
+)
+
+
+class ProductFactory(InstrumentFactory):
+    class Meta:
+        model = Product
+
+    share_price = 100
+    issue_price = factory.LazyAttribute(lambda o: random.randint(1, 1000))
+    bank = factory.SubFactory("wbcore.contrib.directory.factories.CompanyFactory")
+
+    type_of_return = factory.Faker("random_element", elements=[x[0] for x in TypeOfReturn.choices()])
+    asset_class = factory.Faker("random_element", elements=[x[0] for x in AssetClass.choices()])
+    legal_structure = factory.Faker("random_element", elements=[x[0] for x in LegalStructure.choices()])
+    investment_index = factory.Faker("random_element", elements=[x[0] for x in InvestmentIndex.choices()])
+    liquidity = factory.Faker("random_element", elements=[x[0] for x in Liquidy.choices()])
+    risk_scale = factory.LazyAttribute(lambda o: random.randint(1, 7))
+
+    dividend = factory.Faker("random_element", elements=[x[0] for x in Product.Dividend.choices])
+    minimum_subscription = factory.LazyAttribute(lambda o: random.randint(100, 200))
+
+    cut_off_time = factory.Faker("time_object")
+
+    external_webpage = factory.Faker("url")
+    instrument_type = factory.LazyAttribute(lambda o: InstrumentTypeFactory.create(name="Product", key="product"))
+
+    # wbportfolio = factory.SubFactory(PortfolioFactory)
+    # portfolio_computed = factory.SubFactory(PortfolioFactory)
+
+
+class WhiteLabelProductFactory(ProductFactory):
+    @factory.post_generation
+    def white_label_customers(self, create, extracted, **kwargs):
+        if not create:
+            return
+
+        num_of_wlc = extracted or 1
+
+        for _ in range(num_of_wlc):
+            self.white_label_customers.add(CompanyFactory.create())
+
+
+class IndexProductFactory(ProductFactory):
+    pass

wbportfolio/factories/pytest_utils.py

@@ -0,0 +1,121 @@
+from datetime import date
+
+import pandas as pd
+from django.utils import timezone
+from faker import Faker
+from pandas.tseries.offsets import BusinessMonthEnd
+from wbfdm.factories import (
+    CashFactory,
+    ClassificationFactory,
+    ClassificationGroupFactory,
+    EquityFactory,
+    InstrumentFactory,
+)
+from wbportfolio.factories import (
+    AssetPositionFactory,
+    InstrumentPriceFactory,
+    PortfolioFactory,
+    PortfolioSynchronizationFactory,
+    PriceComputationFactory,
+    ProductFactory,
+)
+from wbportfolio.models import (
+    InstrumentPortfolioThroughModel,
+    PortfolioPortfolioThroughModel,
+)
+
+fake = Faker()
+
+
+def setup_product(today):
+    product = ProductFactory.create()
+    product.related_instruments.add(InstrumentFactory.create())
+    primary_group = ClassificationGroupFactory.create(is_primary=True, max_depth=3)
+    classification_parent_1 = ClassificationFactory.create(group=primary_group)
+    classification_parent_2 = ClassificationFactory.create(group=primary_group)
+
+    i1 = EquityFactory.create(classifications=[classification_parent_1.children.first().children.first()])
+    i2 = EquityFactory.create(classifications=[classification_parent_2.children.first().children.first()])
+    i3 = CashFactory.create()
+    for _d in pd.date_range(
+        today - BusinessMonthEnd(1), today + BusinessMonthEnd(0), freq="B"
+    ):  # Build a complete factsheet month
+        _d = _d.date()
+        InstrumentPriceFactory.create(instrument=product, date=_d)
+        pos = [
+            AssetPositionFactory.create(
+                portfolio=product.portfolio,
+                date=_d,
+                underlying_instrument=i1,
+                underlying_instrument_price=InstrumentPriceFactory.create(instrument=i1, date=_d, calculated=False),
+            ),
+            AssetPositionFactory.create(
+                portfolio=product.portfolio,
+                date=_d,
+                underlying_instrument=i2,
+                underlying_instrument_price=InstrumentPriceFactory.create(instrument=i2, date=_d, calculated=False),
+            ),
+            AssetPositionFactory.create(
+                portfolio=product.portfolio,
+                date=_d,
+                underlying_instrument=i3,
+                underlying_instrument_price=InstrumentPriceFactory.create(instrument=i3, date=_d, calculated=False),
+            ),
+        ]
+        for p in pos:
+            InstrumentPriceFactory.create(instrument=p.underlying_instrument, date=_d)
+    return product
+
+
+class ValidTodayProductSetupMixin:
+    def setup_method(self, method=None):
+        product = setup_product(timezone.now().date())
+        self.product = product
+
+
+class ValidTodayMultiThematicProductSetupMixin:
+    def setup_method(self, method=None):
+        today = date.today()
+        main_product = ProductFactory.create(price_computation=PriceComputationFactory.create())
+        main_product.related_instruments.add(InstrumentFactory.create())
+
+        # Create two valid products that will span our portfolio
+        product1 = setup_product(today)
+        product2 = setup_product(today)
+
+        # Create a computed portfolio (model to allow automatic sync), linked throught he primary portfolio with a Thematic relationship
+        computed_portfolio = PortfolioFactory.create(
+            portfolio_synchronization=PortfolioSynchronizationFactory.create(),
+        )
+        PortfolioPortfolioThroughModel.objects.create(
+            portfolio=computed_portfolio, dependency_portfolio=main_product.primary_portfolio
+        )
+
+        InstrumentPortfolioThroughModel.objects.update_or_create(
+            instrument=main_product, defaults={"portfolio": computed_portfolio}
+        )
+
+        # Loop through the date range and create an equally weighted portfolio of products and synchronize the computed portfolio and compute the estimate NAV
+        for _d in pd.date_range(today - BusinessMonthEnd(1), today + BusinessMonthEnd(0), freq="B"):
+            _d = _d.date()
+            AssetPositionFactory.create(
+                portfolio=main_product.primary_portfolio,
+                underlying_instrument=product1,
+                date=_d,
+                weighting=0.5,
+                initial_price=product1.prices.get(date=_d).net_value,
+            )
+            AssetPositionFactory.create(
+                portfolio=main_product.primary_portfolio,
+                underlying_instrument=product2,
+                date=_d,
+                weighting=0.5,
+                initial_price=product2.prices.get(date=_d).net_value,
+            )
+            computed_portfolio.portfolio_synchronization.synchronize(
+                computed_portfolio, _d, override_execution_datetime_validity=True
+            )
+            main_product.price_computation.compute(main_product, _d, override_execution_datetime_validity=True)
+        main_product.prices.update(calculated=False)
+        self.product = main_product
+        self.theme_portfolio = main_product.primary_portfolio

wbportfolio/factories/reconciliations.py

@@ -0,0 +1,23 @@
+import factory
+from wbportfolio.models import AccountReconciliation, AccountReconciliationLine
+
+
+class AccountReconciliationFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = AccountReconciliation
+
+    account = factory.SubFactory("wbcrm.factories.AccountFactory")
+    creator = factory.SubFactory("wbcore.contrib.authentication.factories.UserFactory")
+    reconciliation_date = factory.Faker("date_this_year")
+
+
+class AccountReconciliationLineFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = AccountReconciliationLine
+
+    reconciliation = factory.SubFactory(AccountReconciliationFactory)
+    product = factory.SubFactory("wbportfolio.factories.ProductFactory")
+    price = factory.Faker("pydecimal", left_digits=4, right_digits=2)
+    price_date = factory.Faker("date_this_year")
+    shares = factory.Faker("pyint")
+    shares_external = factory.Faker("pyint")

wbportfolio/factories/roles.py

@@ -0,0 +1,20 @@
+import factory
+from wbportfolio.models import PortfolioRole
+
+
+class ProductPortfolioRoleFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = PortfolioRole
+
+    role_type = factory.Iterator([PortfolioRole.RoleType.PORTFOLIO_MANAGER, PortfolioRole.RoleType.ANALYST])
+    person = factory.SubFactory("wbcore.contrib.authentication.factories.users.AuthenticatedPersonFactory")
+    instrument = factory.SubFactory("wbportfolio.factories.ProductFactory")
+    weighting = factory.Faker("pyfloat", min_value=0.1, max_value=1)
+
+
+class ManagerPortfolioRoleFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = PortfolioRole
+
+    role_type = factory.Iterator([PortfolioRole.RoleType.RISK_MANAGER, PortfolioRole.RoleType.MANAGER])
+    person = factory.SubFactory("wbcore.contrib.directory.factories.entries.PersonFactory")

wbportfolio/factories/synchronization.py

@@ -0,0 +1,40 @@
+import factory
+from django_celery_beat.models import CrontabSchedule, PeriodicTask
+from wbportfolio.models import (
+    PortfolioSynchronization,
+    PriceComputation,
+    SynchronizationTask,
+)
+
+
+class CrontabScheduleFactory(factory.django.DjangoModelFactory):
+    hour = factory.Iterator(range(0, 24))
+    minute = factory.Iterator(range(0, 60))
+
+    class Meta:
+        model = CrontabSchedule
+
+
+class PeriodicTaskFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = PeriodicTask
+
+    name = factory.Sequence(lambda n: f"Synchronization Task {n}")
+    crontab = factory.SubFactory(CrontabScheduleFactory)
+
+
+class SynchronizationTaskFactory(PeriodicTaskFactory):
+    class Meta:
+        model = SynchronizationTask
+
+
+class PortfolioSynchronizationFactory(SynchronizationTaskFactory):
+    propagate_history = False
+
+    class Meta:
+        model = PortfolioSynchronization
+
+
+class PriceComputationFactory(SynchronizationTaskFactory):
+    class Meta:
+        model = PriceComputation

wbportfolio/factories/trades.py

@@ -0,0 +1,35 @@
+import random
+
+import factory
+from wbportfolio.models import Trade, TradeProposal
+
+from .transactions import TransactionFactory
+
+
+class TradeFactory(TransactionFactory):
+    class Meta:
+        model = Trade
+
+    bank = factory.Faker("company")
+    marked_for_deletion = False
+    shares = factory.Faker("pydecimal", min_value=10, max_value=1000, right_digits=4)
+    price = factory.LazyAttribute(lambda o: random.randint(10, 10000))
+    # trade_proposal = factory.SubFactory("wbportfolio.factories.TradeProposalFactory")
+
+
+class TradeProposalFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = TradeProposal
+
+    trade_date = factory.Faker("date_object")
+    comment = factory.Faker("paragraph")
+    portfolio = factory.SubFactory("wbportfolio.factories.PortfolioFactory")
+    creator = factory.SubFactory("wbcore.contrib.directory.factories.PersonFactory")
+
+
+class CustomerTradeFactory(TradeFactory):
+    transaction_subtype = factory.LazyAttribute(
+        lambda o: Trade.Type.REDEMPTION if o.shares < 0 else Trade.Type.SUBSCRIPTION
+    )
+    underlying_instrument = factory.SubFactory("wbportfolio.factories.ProductFactory")
+    portfolio = factory.LazyAttribute(lambda x: x.underlying_instrument.primary_portfolio)

wbportfolio/factories/transactions.py

@@ -0,0 +1,21 @@
+import random
+from datetime import timedelta
+
+import factory
+from wbportfolio.models import Transaction
+
+
+class TransactionFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = Transaction
+
+    currency_fx_rate = 1.0
+    portfolio = factory.SubFactory("wbportfolio.factories.PortfolioFactory")
+    underlying_instrument = factory.SubFactory("wbfdm.factories.InstrumentFactory")
+    transaction_date = factory.Faker("date_object")
+    value_date = factory.LazyAttribute(lambda o: o.transaction_date + timedelta(days=1))
+    currency = factory.SubFactory("wbcore.contrib.currency.factories.CurrencyFactory")
+    total_value = factory.LazyAttribute(lambda o: random.randint(1, 1000))
+    total_value_fx_portfolio = factory.LazyAttribute(lambda o: o.currency_fx_rate * o.total_value)
+    total_value_gross = factory.LazyAttribute(lambda o: random.randint(1, 1000))
+    total_value_gross_fx_portfolio = factory.LazyAttribute(lambda o: o.currency_fx_rate * o.total_value_gross)

wbportfolio/fdm/tasks.py

@@ -0,0 +1,12 @@
+from celery import shared_task
+from tqdm import tqdm
+from wbfdm.models import Controversy, Instrument
+from wbportfolio.models import AssetPosition
+
+
+@shared_task(queue="portfolio")
+def synchronize_portfolio_controversies():
+    qs = AssetPosition.objects.values("underlying_instrument").distinct("underlying_instrument")
+    for row in tqdm(qs, total=qs.count()):
+        for controversy in Instrument.objects.filter(id=row["underlying_instrument"]).dl.esg_controversies():
+            Controversy.sync_from_dataloader(controversy)

wbportfolio/filters/__init__.py

@@ -0,0 +1,32 @@
+from .assets import (  # ProductAllocationEquityFilter, AssetPositionAPIFilter, AssetPositionDateFilter, ContributionChartFilter, AssetPositionIndexFilter, AssetPositionInstrumentFilter, EquityCashPositionFilter,  AssetPositionEquityFilter
+    AssetPositionEquityGroupFilter,
+    AssetPositionFilter,
+    AssetPositionIndexGroupFilter,
+    AssetPositionInstrumentFilter,
+    AssetPositionPortfolioFilter,
+    AssetPositionProductGroupFilter,
+    AssetPositionUnderlyingInstrumentChartFilter,
+    CashPositionPortfolioFilterSet,
+    CompositionModelPortfolioPandasFilter,
+    ContributionChartFilter,
+    DistributionFilter,
+)
+from .custodians import CustodianFilterSet
+from .performances import (
+    PerformanceComparisonFilter,
+    PerformancePandasFilter,
+    ProductPerformanceNetNewMoneyFilter,
+)
+from .portfolios import PortfolioFilterSet
+from .positions import AggregatedAssetPositionLiquidityFilter, AssetPositionPandasFilter
+from .roles import PortfolioRoleFilterSet
+from .signals import *
+from .transactions import *
+from .products import (
+    BaseProductFilterSet,
+    ProductFilter,
+    ProductCustomerFilter,
+    ProductFeeFilter,
+)
+from .assets_and_net_new_money_progression import AssetsAndNetNewMoneyProgressionFilterSet
+from .esg import ESGMetricAggregationPortfolioPandasFilterSet