wbfdm 2.2.1__py2.py3-none-any.whl

wbfdm/serializers/instruments/instrument_requests.py

@@ -0,0 +1,61 @@
+from wbcore import serializers as wb_serializers
+from wbcore.contrib.directory.serializers import PersonRepresentationSerializer
+from wbfdm.models.instruments import InstrumentRequest
+
+from .instruments import InstrumentModelSerializer, InstrumentRepresentationSerializer
+
+
+class InstrumentRequestRepresentationSerializer(wb_serializers.RepresentationSerializer):
+    _detail = wb_serializers.HyperlinkField(reverse_name="wbfdm:instrumentrequest-detail")
+
+    class Meta:
+        model = InstrumentRequest
+        fields = ("id", "status", "_detail")
+
+
+class InstrumentRequestModelSerializer(wb_serializers.ModelSerializer):
+    _requester = PersonRepresentationSerializer(source="requester")
+    _handler = PersonRepresentationSerializer(source="handler")
+    _created_instrument = InstrumentRepresentationSerializer(source="created_instrument")
+    notes = wb_serializers.CharField(required=False)
+
+    def validate(self, data):
+        if (not self.instance or not self.instance.requester) and (request := self.context.get("request")):
+            data["requester"] = request.user.profile
+        return super().validate(data)
+
+    class Meta:
+        model = InstrumentRequest
+        fields = (
+            "id",
+            "status",
+            "requester",
+            "_requester",
+            "_handler",
+            "handler",
+            "_created_instrument",
+            "created_instrument",
+            "notes",
+            "created",
+            "_additional_resources",
+        )
+        flatten_fields = {
+            "instrument_data": wb_serializers.JSONTableField(
+                serializer_class=InstrumentModelSerializer,
+                required=False,
+                flatten_field_names=[
+                    "name",
+                    "name_repr",
+                    "instrument_type",
+                    "refinitiv_identifier_code",
+                    "refinitiv_mnemonic_code",
+                    "isin",
+                    "ticker",
+                    "is_cash",
+                    "currency",
+                    "country",
+                    "tags",
+                    "classifications",
+                ],
+            )
+        }

wbfdm/serializers/instruments/instruments.py

@@ -0,0 +1,274 @@
+from typing import TYPE_CHECKING, Type
+
+from django.contrib.auth import get_user_model
+from rest_framework.reverse import reverse
+from wbcore import serializers
+from wbcore.contrib.currency.models import Currency
+from wbcore.contrib.currency.serializers import CurrencyRepresentationSerializer
+from wbcore.contrib.geography.models import Geography
+from wbcore.contrib.geography.serializers import CountryRepresentationSerializer
+from wbcore.contrib.tags.serializers import TagRepresentationSerializer
+from wbfdm.models import Instrument, InstrumentType
+
+from ..exchanges import ExchangeRepresentationSerializer
+from .classifications import ClassificationRepresentationSerializer
+from .mixins import InstrumentAdditionalResourcesMixin
+
+if TYPE_CHECKING:
+    User = Type[get_user_model()]
+
+
+class InstrumentTypeRepresentationSerializer(serializers.RepresentationSerializer):
+    class Meta:
+        model = InstrumentType
+        fields = ("id", "name", "key")
+
+
+class InstrumentRepresentationSerializer(serializers.RepresentationSerializer):
+    _detail = serializers.HyperlinkField(reverse_name="wbfdm:instrument-detail")
+
+    def get_filter_params(self, request):
+        filter_params = {}
+        if (view := request.parser_context.get("view", None)) and (
+            classification_id := view.kwargs.get("classification_id", None)
+        ):
+            filter_params["classifications_neq"] = classification_id
+
+        return filter_params
+
+    class Meta:
+        model = Instrument
+        fields = ("id", "name", "ticker", "isin", "computed_str", "_detail")
+
+
+class ClassifiableInstrumentRepresentationSerializer(InstrumentRepresentationSerializer):
+    def get_filter_params(self, request):
+        filter_params = super().get_filter_params(request)
+        filter_params["instrument_type__is_classifiable"] = True
+        filter_params["level"] = 0
+        return filter_params
+
+
+class SecurityRepresentationSerializer(InstrumentRepresentationSerializer):
+    def get_filter_params(self, request):
+        filter_params = super().get_filter_params(request)
+        filter_params["is_security"] = True
+        return filter_params
+
+
+class InvestableUniverseRepresentationSerializer(InstrumentRepresentationSerializer):
+    def get_filter_params(self, request):
+        filter_params = super().get_filter_params(request)
+        filter_params["is_investable_universe"] = True
+        return filter_params
+
+
+class InvestableInstrumentRepresentationSerializer(InstrumentRepresentationSerializer):
+    def get_filter_params(self, request):
+        filter_params = super().get_filter_params(request)
+        filter_params["is_investable"] = True
+        return filter_params
+
+
+class PrimaryInvestableInstrumentRepresentationSerializer(InvestableInstrumentRepresentationSerializer):
+    def get_filter_params(self, request):
+        filter_params = super().get_filter_params(request)
+        filter_params["is_primary"] = True
+        return filter_params
+
+
+class ManagedInstrumentRepresentationSerializer(InstrumentRepresentationSerializer):
+    def get_filter_params(self, request):
+        filter_params = super().get_filter_params(request)
+        filter_params["is_managed"] = True
+        return filter_params
+
+
+class EquityRepresentationSerializer(InstrumentRepresentationSerializer):
+    def get_filter_params(self, request):
+        filter_params = super().get_filter_params(request)
+        filter_params["investment_type__key"] = "equity"
+        return filter_params
+
+
+class ProductRepresentationSerializer(InstrumentRepresentationSerializer):
+    def get_filter_params(self, request):
+        filter_params = super().get_filter_params(request)
+        filter_params["investment_type__key"] = "product"
+        return filter_params
+
+
+class InstrumentModelListSerializer(
+    serializers.ModelSerializer,
+):
+    _currency = CurrencyRepresentationSerializer(source="currency")
+    currency = serializers.PrimaryKeyRelatedField(queryset=Currency.objects.all())
+    currency_symbol = serializers.CharField(read_only=True)
+    _exchange = ExchangeRepresentationSerializer(source="exchange")
+    country = serializers.PrimaryKeyRelatedField(queryset=Geography.countries.all())
+    _country = CountryRepresentationSerializer(source="country")
+    instrument_type = serializers.PrimaryKeyRelatedField(queryset=InstrumentType.objects.all())
+    _instrument_type = InstrumentTypeRepresentationSerializer(source="instrument_type")
+    _tags = TagRepresentationSerializer(many=True, source="tags")
+
+    _classifications = ClassificationRepresentationSerializer(
+        source="classifications", many=True, label_key="{{ name }}"
+    )
+    _parent = InstrumentRepresentationSerializer(source="parent")
+    is_active = serializers.BooleanField(default=True, read_only=True)
+    is_cash = serializers.BooleanField(default=False, read_only=True)
+    _group_key = serializers.CharField(read_only=True)
+
+    class Meta:
+        model = Instrument
+        read_only_fields = (
+            "name",
+            "exchange",
+            "computed_str",
+            "instrument_type",
+            "old_isins",
+            "inception_date",
+            "delisted_date",
+            "country",
+            "isin",
+            "refinitiv_identifier_code",
+            "ticker",
+            "is_active",
+            "parent",
+            "is_primary",
+            "is_investable_universe",
+            "is_security",
+            "is_managed",
+        )
+
+        fields = (
+            "id",
+            "name",
+            "name_repr",
+            "description",
+            "instrument_type",
+            "_instrument_type",
+            "inception_date",
+            "delisted_date",
+            "country",
+            "_country",
+            "currency",
+            "_currency",
+            "currency_symbol",
+            "isin",
+            "refinitiv_identifier_code",
+            "ticker",
+            "_classifications",
+            "classifications",
+            "_tags",
+            "tags",
+            "is_active",
+            "is_cash",
+            "_parent",
+            "parent",
+            "_additional_resources",
+            "_buttons",
+            "_group_key",
+            "exchange",
+            "_exchange",
+            "is_primary",
+            "is_investable_universe",
+            "is_security",
+            "is_managed",
+        )
+
+
+class InstrumentModelSerializer(InstrumentAdditionalResourcesMixin, InstrumentModelListSerializer):
+    _related_instruments = SecurityRepresentationSerializer(source="related_instruments", many=True)
+
+    @serializers.register_resource()
+    def load_resources(self, instance, request, user, **kwargs):
+        res = {
+            "prices": reverse("wbfdm:prices-list", args=[instance.id], request=request),
+            "financial-statistics": reverse(
+                "wbfdm:instrument-financialstatistics-list", args=[instance.id], request=request
+            ),
+        }
+        if not instance.is_managed:
+            res.update(
+                {
+                    "swe-income-statement": reverse(
+                        "wbfdm:statementwithestimates-list", args=[instance.id, "income"], request=request
+                    ),
+                    "swe-balance-sheet": reverse(
+                        "wbfdm:statementwithestimates-list", args=[instance.id, "balancesheet"], request=request
+                    ),
+                    "swe-cashflow-statement": reverse(
+                        "wbfdm:statementwithestimates-list", args=[instance.id, "cashflow"], request=request
+                    ),
+                    "swe-ratios": reverse(
+                        "wbfdm:statementwithestimates-list", args=[instance.id, "ratios"], request=request
+                    ),
+                    "swe-margins": reverse(
+                        "wbfdm:statementwithestimates-list", args=[instance.id, "margins"], request=request
+                    ),
+                    "swe-summary": reverse(
+                        "wbfdm:statementwithestimates-list", args=[instance.id, "summary"], request=request
+                    ),
+                    "swe-cashflow-ratios": reverse(
+                        "wbfdm:statementwithestimates-list", args=[instance.id, "cashflow-ratios"], request=request
+                    ),
+                    "swe-asset-turnover-ratios": reverse(
+                        "wbfdm:statementwithestimates-list",
+                        args=[instance.id, "asset-turnover-ratios"],
+                        request=request,
+                    ),
+                    "swe-credit": reverse(
+                        "wbfdm:statementwithestimates-list", args=[instance.id, "credit"], request=request
+                    ),
+                    "swe-long-term-solvency": reverse(
+                        "wbfdm:statementwithestimates-list", args=[instance.id, "long-term-solvency"], request=request
+                    ),
+                    "swe-short-term-liquidity": reverse(
+                        "wbfdm:statementwithestimates-list",
+                        args=[instance.id, "short-term-liquidity"],
+                        request=request,
+                    ),
+                    "valuation_ratios-new": reverse(
+                        "wbfdm:valuation_ratios-list", args=[instance.id], request=request
+                    ),
+                    "income-statement": reverse(
+                        "wbfdm:statement-list", args=[instance.id, "income-statement"], request=request
+                    ),
+                    "balance-sheet": reverse(
+                        "wbfdm:statement-list", args=[instance.id, "balance-sheet"], request=request
+                    ),
+                    "cash-flow-statement": reverse(
+                        "wbfdm:statement-list", args=[instance.id, "cash-flow-statement"], request=request
+                    ),
+                    "officers": reverse(viewname="wbfdm:officers-list", args=[instance.id], request=request),
+                    "controversies": reverse(viewname="wbfdm:controversies-list", args=[instance.id], request=request),
+                    "pai": reverse(viewname="wbfdm:pai-list", args=[instance.id], request=request),
+                }
+            )
+        return res
+
+    @serializers.register_only_instance_resource()
+    def register_children(self, instance, request, user, **kwargs):
+        return {"children": reverse("wbfdm:instrument-children-list", args=[instance.id], request=request)}
+
+    @serializers.register_resource()
+    def register_market_data(self, instance, request, user, **kwargs):
+        return {
+            "market_data": reverse("wbfdm:market_data-list", args=[instance.id], request=request),
+            "cumulativereturn": f'{reverse("wbfdm:market_data-list", args=[instance.id], request=request)}?chart_type=ret',
+            "drawdown": f'{reverse("wbfdm:market_data-list", args=[instance.id], request=request)}?chart_type=drawdown',
+            "performance_summary": reverse("wbfdm:performance_summary-list", args=[instance.id], request=request),
+            "monthly_performances": reverse("wbfdm:monthly_performances-list", args=[instance.id], request=request),
+        }
+
+    class Meta(InstrumentModelListSerializer.Meta):
+        fields = InstrumentModelListSerializer.Meta.fields + (
+            "refinitiv_mnemonic_code",
+            "identifier",
+            "base_color",
+            "old_isins",
+            "is_cash",
+            "related_instruments",
+            "_related_instruments",
+        )

wbfdm/serializers/instruments/mixins.py

@@ -0,0 +1,104 @@
+from rest_framework.reverse import reverse
+from wbcore import serializers as wb_serializers
+
+
+class InstrumentAdditionalResourcesMixin:
+    @wb_serializers.register_only_instance_resource()
+    def instrument_resources(self, instance, request, user, **kwargs):
+        additional_resources = dict()
+
+        if instance.prices.exists():
+            additional_resources["instrumentpricestatisticchart"] = reverse(
+                "wbfdm:instrument-pricestatisticchart-list",
+                args=[instance.id],
+                request=request,
+            )
+            additional_resources["instrumentprices"] = reverse(
+                "wbfdm:instrument-price-list",
+                args=[instance.id],
+                request=request,
+            )
+
+        additional_resources["distributionreturnschart"] = reverse(
+            "wbfdm:instrument-distributionreturnschart-list",
+            args=[instance.id],
+            request=request,
+        )
+        additional_resources["bestandworstreturns"] = reverse(
+            "wbfdm:instrument-bestandworstreturns-list",
+            args=[instance.id],
+            request=request,
+        )
+        additional_resources[
+            "price_and_volume"
+        ] = f'{reverse("wbfdm:market_data-list", args=[instance.id], request=request)}?chart_type=close&indicators=sma_50,sma_100&volume=true'
+
+        additional_resources["classifications_list"] = reverse(
+            "wbfdm:instrument-classification-list",
+            args=[instance.get_root().id],
+            request=request,
+        )
+        additional_resources["instrument_lists"] = reverse(
+            "wbfdm:instrument-instrumentlistthrough-list", args=[instance.id], request=request
+        )
+
+        return additional_resources
+
+    @wb_serializers.register_only_instance_resource()
+    def related_instruments(self, instance, request, user, **kwargs):
+        return {
+            "related_instruments": reverse(
+                "wbfdm:instrument-relatedinstrument-list", args=[instance.id], request=request
+            )
+        }
+
+    # @wb_serializers.register_only_instance_resource()
+    # def deprecated_financial_resources(self, instance, request, user, **kwargs):
+    #     additional_resources = dict()
+    #     additional_resources["summary_table"] = reverse(
+    #         "wbfdm:instrument-summarytablechart-list",
+    #         args=[instance.id],
+    #         request=request,
+    #     )
+    #     additional_resources["financials_graph"] = reverse(
+    #         "wbfdm:instrument-financialsgraphchart-list",
+    #         args=[instance.id],
+    #         request=request,
+    #     )
+    #     additional_resources["profitability_ratios"] = reverse(
+    #         "wbfdm:instrument-profitabilityratioschart-list",
+    #         args=[instance.id],
+    #         request=request,
+    #     )
+    #     additional_resources["cash_flow_analysis_table"] = reverse(
+    #         "wbfdm:instrument-cashflowanalysistablechart-list",
+    #         args=[instance.id],
+    #         request=request,
+    #     )
+    #     additional_resources["cash_flow_analysis_chart"] = reverse(
+    #         "wbfdm:instrument-cashflowanalysisbarchart-list",
+    #         args=[instance.id],
+    #         request=request,
+    #     )
+    #     additional_resources["net_debt_and_ebitda_chart"] = reverse(
+    #         "wbfdm:instrument-netdebtandebitdachart-list",
+    #         args=[instance.id],
+    #         request=request,
+    #     )
+    #     earnings_base_url = reverse(
+    #         "wbfdm:instrument-earningschart-list",
+    #         args=[instance.id],
+    #         request=request,
+    #     )
+    #     additional_resources["earnings_chart"] = earnings_base_url
+    #     additional_resources["earnings_chart_ttm"] = f"{earnings_base_url}?period=TTM"
+    #     additional_resources["earnings_chart_ntm"] = f"{earnings_base_url}?period=FTM"
+    #     valuation_ratios_base_url = reverse(
+    #         "wbfdm:instrument-valuationratios-list",
+    #         args=[instance.id],
+    #         request=request,
+    #     )
+    #     additional_resources["valuation_ratios-old"] = valuation_ratios_base_url
+    #     additional_resources["valuation_ratios_ranges"] = f"{valuation_ratios_base_url}?ranges=true"
+    #     additional_resources["valuation_ratios_related"] = f"{valuation_ratios_base_url}?vs_related=true"
+    #     return additional_resources

wbfdm/serializers/officers.py

@@ -0,0 +1,20 @@
+from wbcore import serializers
+
+
+class OfficerSerializer(serializers.Serializer):
+    id = serializers.PrimaryKeyCharField()
+    position = serializers.CharField()
+    name = serializers.CharField()
+    age = serializers.IntegerField()
+    sex = serializers.CharField()
+    start = serializers.DateField()
+
+    class Meta:
+        fields = (
+            "id",
+            "position",
+            "name",
+            "age",
+            "sex",
+            "start",
+        )

wbfdm/signals.py

@@ -0,0 +1,7 @@
+from django.db.models.signals import ModelSignal
+
+# this signal is triggered by the investable universe manager in order to gather what instrument are considered within the investable universe.
+add_instrument_to_investable_universe = ModelSignal(use_caching=False)
+
+# this signal is triggered whenever prices are stored in the system and action needs to be considered
+instrument_price_imported = ModelSignal(use_caching=False)

wbfdm/sync/abstract.py

@@ -0,0 +1,31 @@
+from abc import ABC, abstractmethod
+from typing import Generic, TypeVar
+
+T = TypeVar("T")
+
+
+class Sync(Generic[T], ABC):
+    @abstractmethod
+    def update(self):
+        """Updates all items"""
+        ...
+
+    @abstractmethod
+    def update_or_create_item(self, external_id: int) -> T:
+        """Updates or creates a single item from an external id and returns it"""
+        ...
+
+    @abstractmethod
+    def update_item(self, item: T) -> T:
+        """Updates a single item and returns it"""
+        ...
+
+    @abstractmethod
+    def get_item(self, external_id: int) -> dict:
+        """Retrieves a dictionairy representation of the item"""
+        ...
+
+    @abstractmethod
+    def trigger_partial_update(self):
+        """Figures out if an update is necessary and then tries to update the entire database in the most efficiant way"""
+        ...

wbfdm/sync/runner.py

@@ -0,0 +1,22 @@
+from django.conf import settings
+from django.utils.module_loading import import_string
+
+
+def initialize_instruments():
+    for sync in map(import_string, getattr(settings, "INSTRUMENT_SYNC", [])):
+        sync().update()
+
+
+def initialize_exchanges():
+    for sync in map(import_string, getattr(settings, "EXCHANGE_SYNC", [])):
+        sync().update()
+
+
+def synchronize_instruments():
+    for sync in map(import_string, getattr(settings, "INSTRUMENT_SYNC", [])):
+        sync().trigger_partial_update()
+
+
+def synchronize_exchanges():
+    for sync in map(import_string, getattr(settings, "EXCHANGE_SYNC", [])):
+        sync().trigger_partial_update()

wbfdm/tasks.py

@@ -0,0 +1,69 @@
+from datetime import date
+
+from celery import shared_task
+from django.db import transaction
+from django.db.models import Q
+from pandas.tseries.offsets import BDay
+from tqdm import tqdm
+from wbfdm.models import Instrument
+from wbfdm.sync.runner import (  # noqa: F401
+    initialize_exchanges,
+    initialize_instruments,
+    synchronize_exchanges,
+    synchronize_instruments,
+)
+
+
+@shared_task(queue="portfolio")
+def update_of_investable_universe_data(start: date | None = None, end: date | None = None, clear: bool = False):
+    """
+    Update the investable universe data on a daily basis.
+
+    Parameters:
+    - start (date | None): The start date for updating data. If None, defaults to three business days before 'end'.
+    - end (date | None): The end date for updating data. If None, defaults to the current date.
+
+    Notes:
+    - The function resets the investable universe by marking all instruments as not in the investable universe.
+    - It then updates all instruments marked as part of the investable universe.
+    - If 'end' is not provided, it defaults to the current date.
+    - If 'start' is not provided, it defaults to three business days before 'end'.
+
+    Returns:
+    None
+    """
+    if not end:
+        end = (
+            date.today() - BDay(1)
+        ).date()  # we don't import today price in case the dataloader returns duplicates (e.g. DSWS)
+    if not start:
+        start = (end - BDay(3)).date()  # override three last day by default
+
+    Instrument.investable_universe.update(
+        is_investable_universe=True
+    )  # ensure all the investable universe is marked as such
+
+    instruments = Instrument.active_objects.filter(is_investable_universe=True, delisted_date__isnull=True).exclude(
+        Q(is_managed=True)
+        | Q(dl_parameters__market_data__path="wbfdm.contrib.internal.dataloaders.market_data.MarketDataDataloader")
+    )  # we exclude product and index managed to avoid circular import
+    for instrument in tqdm(instruments, total=instruments.count()):
+        instrument.import_prices(start=start, end=end, clear=clear)
+
+
+@shared_task(queue="portfolio")
+def synchronize_instruments_as_task():
+    synchronize_instruments()
+
+
+@shared_task(queue="portfolio")
+def synchronize_exchanges_as_task():
+    synchronize_exchanges()
+
+
+@shared_task(queue="portfolio")
+def full_synchronization_as_task():
+    initialize_exchanges()
+    initialize_instruments()
+    with transaction.atomic():
+        Instrument.objects.rebuild()  # rebuild MPTT tree