wbfdm 2.2.1__py2.py3-none-any.whl

wbfdm/models/instruments/utils.py

@@ -0,0 +1,41 @@
+import re
+from functools import lru_cache
+
+from wbcore.contrib.currency.models import Currency
+from wbcore.contrib.geography.models import Geography
+from wbfdm.preferences import get_non_ticker_words
+
+START_DELIMITER = r"(?:^|(?<=[(\s\.\-<]))"
+END_DELIMITER = r"(?=[\s\.)\-\>'’,]|$)"
+
+
+@lru_cache()
+def non_ticker_words():
+    return (
+        list(Geography.countries.values_list("code_2", flat=True))
+        + list(Geography.countries.values_list("code_3", flat=True))
+        + list(Currency.objects.values_list("key", flat=True))
+        + get_non_ticker_words()
+    )
+
+
+def re_ric(input: str):
+    # [(\s<]([A-Z]{2}[A-Za-z0-9_.-]+\.[A-Za-z]+)[(\s>] led to too many false positive (e.g. end of sentence when whitespace are missing. We refined by considering only uppercase code
+    return set(re.findall(START_DELIMITER + r"([A-Z0-9]{2}[A-Z0-9_.-]+\.[A-Z]+)" + END_DELIMITER, input))
+
+
+def re_bloomberg(input: str):
+    return set(
+        filter(
+            lambda x: x not in non_ticker_words(),
+            re.findall(START_DELIMITER + r"([A-Z]{2,5}(?:\-[A-Z]{2})?)" + END_DELIMITER, input),
+        )
+    )
+
+
+def re_isin(input: str):
+    return set(re.findall(START_DELIMITER + r"([A-Z]{2}[A-Z0-9]{9}[0-9])" + END_DELIMITER, input))
+
+
+def re_mnemonic(input: str):
+    return set(re.findall(START_DELIMITER + r"([A-Z]+:[A-Z]+)" + END_DELIMITER, input))

wbfdm/preferences.py

@@ -0,0 +1,21 @@
+from contextlib import suppress
+
+from django.db.utils import ProgrammingError
+from dynamic_preferences.registries import global_preferences_registry
+
+
+def get_default_classification_group(*args, **kwargs):
+    from wbfdm.models.instruments.classifications import ClassificationGroup
+
+    with suppress(RuntimeError, ProgrammingError):
+        global_preferences = global_preferences_registry.manager()
+        if group_id := global_preferences["wbfdm__default_classification_group"]:
+            with suppress(ClassificationGroup.DoesNotExist):
+                return ClassificationGroup.objects.get(id=group_id)
+        return ClassificationGroup.objects.get_or_create(is_primary=True, defaults={"name": "Default"})[0]
+
+
+def get_non_ticker_words(*args, **kwargs) -> list[str]:
+    global_preferences = global_preferences_registry.manager()
+    return global_preferences["wbfdm__non_ticker_words"].split(",")
+    return list()

wbfdm/serializers/__init__.py

@@ -0,0 +1,4 @@
+from .esg import InstrumentControversySerializer
+from .instruments import *
+from .officers import OfficerSerializer
+from .exchanges import ExchangeModelSerializer, ExchangeRepresentationSerializer

wbfdm/serializers/esg.py

@@ -0,0 +1,36 @@
+from wbcore import serializers
+from wbfdm.enums import (
+    ESGControveryFlag,
+    ESGControverySeverity,
+    ESGControveryStatus,
+    ESGControveryType,
+)
+
+
+class InstrumentControversySerializer(serializers.Serializer):
+    id = serializers.PrimaryKeyCharField()
+    headline = serializers.TextField()
+    narrative = serializers.TextField()
+    source = serializers.CharField()
+    status = serializers.ChoiceField(choices=ESGControveryStatus.choices)
+    type = serializers.ChoiceField(choices=ESGControveryType.choices)
+    assessment = serializers.ChoiceField(choices=ESGControverySeverity.choices)
+    response = serializers.TextField()
+    review = serializers.DateField()
+    initiated = serializers.DateField()
+    flag = serializers.ChoiceField(choices=ESGControveryFlag.choices)
+
+    class Meta:
+        fields = (
+            "id",
+            "headline",
+            "narrative",
+            "source",
+            "status",
+            "type",
+            "assessment",
+            "response",
+            "review",
+            "initiated",
+            "flag",
+        )

wbfdm/serializers/exchanges.py

@@ -0,0 +1,39 @@
+from wbcore import serializers as wb_serializers
+from wbcore.contrib.geography.serializers import GeographyRepresentationSerializer
+from wbfdm.models import Exchange
+
+
+class ExchangeRepresentationSerializer(wb_serializers.RepresentationSerializer):
+    _detail = wb_serializers.HyperlinkField(reverse_name="wbfdm:exchange-detail")
+
+    class Meta:
+        model = Exchange
+        fields = ("id", "name", "mic_code", "_detail")
+
+
+class ExchangeModelSerializer(wb_serializers.ModelSerializer):
+    _country = GeographyRepresentationSerializer(source="country")
+    _city = GeographyRepresentationSerializer(source="city")
+
+    class Meta:
+        model = Exchange
+        fields = (
+            "id",
+            "name",
+            "mic_code",
+            "operating_mic_code",
+            "bbg_exchange_codes",
+            "bbg_composite_primary",
+            "bbg_composite",
+            "refinitiv_identifier_code",
+            "refinitiv_mnemonic",
+            "country",
+            "_country",
+            "city",
+            "website",
+            "opening_time",
+            "closing_time",
+            "_city",
+            "city",
+            "comments",
+        )

wbfdm/serializers/instruments/__init__.py

@@ -0,0 +1,37 @@
+from .instruments import (
+    InstrumentModelListSerializer,
+    InstrumentModelSerializer,
+    InstrumentRepresentationSerializer,
+    InstrumentTypeRepresentationSerializer,
+    InvestableUniverseRepresentationSerializer,
+    ClassifiableInstrumentRepresentationSerializer,
+    SecurityRepresentationSerializer,
+    InvestableInstrumentRepresentationSerializer,
+    PrimaryInvestableInstrumentRepresentationSerializer,
+    EquityRepresentationSerializer,
+    ProductRepresentationSerializer,
+    ManagedInstrumentRepresentationSerializer,
+)
+from .instrument_prices import InstrumentPriceModelSerializer, InstrumentPriceInstrumentModelSerializer
+from .instrument_relationships import (
+    InstrumentClassificationRelatedInstrumentModelSerializer,
+    InstrumentClassificationRelatedInstrumentRepresentationSerializer,
+    RelatedInstrumentThroughInstrumentModelSerializer,
+    InstrumentFavoriteGroupRepresentationSerializer,
+    InstrumentFavoriteGroupModelSerializer,
+    InstrumentClassificationThroughModelSerializer,
+)
+from .instrument_requests import InstrumentRequestRepresentationSerializer, InstrumentRequestModelSerializer
+from .classifications import (
+    ClassificationRepresentationSerializer,
+    ClassificationZeroHeightRepresentationSerializer,
+    ClassificationIsFavoriteZeroHeightRepresentationSerializer,
+    ClassificationGroupRepresentationSerializer,
+    ClassificationModelSerializer,
+    ClassificationGroupModelSerializer,
+)
+from .instrument_lists import (
+    InstrumentListModelSerializer,
+    InstrumentListRepresentationSerializer,
+    InstrumentListThroughModelSerializer,
+)

wbfdm/serializers/instruments/classifications.py

@@ -0,0 +1,139 @@
+from rest_framework import serializers as rf_serializers
+from rest_framework.reverse import reverse
+from wbcore import serializers as wb_serializers
+from wbcore.serializers import DefaultAttributeFromRemoteField
+from wbfdm.models.instruments import Classification, ClassificationGroup
+from wbfdm.preferences import get_default_classification_group
+
+
+class ClassificationRepresentationSerializer(wb_serializers.RepresentationSerializer):
+    _detail = wb_serializers.HyperlinkField(reverse_name="wbfdm:classification-detail")
+
+    class Meta:
+        model = Classification
+        fields = (
+            "id",
+            "name",
+            "computed_str",
+            "level",
+            "height",
+            "code_aggregated",
+            "_detail",
+        )
+
+
+class ClassificationZeroHeightRepresentationSerializer(ClassificationRepresentationSerializer):
+    def get_filter_params(self, request):
+        filter_params = {"height": 0}
+        if (view := request.parser_context.get("view", None)) and (
+            instrument_id := view.kwargs.get("instrument_id", None)
+        ):
+            filter_params["instruments_neq"] = instrument_id
+        return filter_params
+
+
+class ClassificationIsFavoriteZeroHeightRepresentationSerializer(ClassificationRepresentationSerializer):
+    def get_filter_params(self, request):
+        filter_params = {
+            "height": 0,
+            "instruments_through__is_favorite": True,
+        }
+        if group := get_default_classification_group():
+            filter_params["group"] = group.id
+        return filter_params
+
+
+class ClassificationGroupRepresentationSerializer(wb_serializers.RepresentationSerializer):
+    max_depth = wb_serializers.IntegerField(read_only=True)
+    _detail = wb_serializers.HyperlinkField(reverse_name="wbfdm:classificationgroup-detail")
+
+    class Meta:
+        model = ClassificationGroup
+        fields = ("id", "name", "is_primary", "max_depth", "_detail")
+
+
+class ClassificationModelSerializer(wb_serializers.ModelSerializer):
+    parent = wb_serializers.PrimaryKeyRelatedField(
+        queryset=Classification.objects.all(), default=DefaultAttributeFromRemoteField("parent_id", Classification)
+    )
+    _parent = ClassificationRepresentationSerializer(source="parent")
+    group = wb_serializers.PrimaryKeyRelatedField(
+        queryset=ClassificationGroup.objects.all(),
+        default=DefaultAttributeFromRemoteField("parent_id", Classification, source="group"),
+    )
+    _group = ClassificationGroupRepresentationSerializer(source="group")
+    code_aggregated = wb_serializers.CharField(required=False, default="")
+    level_representation = wb_serializers.CharField(required=False, default="")
+    description = wb_serializers.TextAreaField(label="Description", allow_null=True, allow_blank=True, required=False)
+
+    @wb_serializers.register_only_instance_resource()
+    def additional_resources(self, instance, request, user, **kwargs):
+        resources = {
+            "childs": reverse("wbfdm:classificationparent-classification-list", args=[instance.id], request=request),
+        }
+        if instance.children.exists():
+            resources[
+                "iciclechart"
+            ] = f'{reverse("wbfdm:classificationgroup-iciclechart-list", args=[instance.group.id], request=request)}?top_classification={instance.id}'
+            resources[
+                "treechart"
+            ] = f'{reverse("wbfdm:classificationgroup-treechart-list", args=[instance.group.id], request=request)}?top_classification={instance.id}'
+
+        resources["instruments"] = reverse("wbfdm:classification-instrument-list", args=[instance.id], request=request)
+
+        return resources
+
+    def validate(self, data):
+        errors = {}
+        if parent := data.get("parent", None):
+            data["level"] = parent.level + 1
+            data["group"] = parent.group
+        if (
+            (investable := data.get("investable", None))
+            and self.instance
+            and investable is True
+            and self.instance.get_ancestors().filter(investable=False).exists()
+        ):
+            errors["investable"] = "This classification cannot be investable as long as its parent is non investable."
+        if len(errors.keys()) > 0:
+            raise rf_serializers.ValidationError(errors)
+        return data
+
+    class Meta:
+        model = Classification
+        fields = (
+            "id",
+            "parent",
+            "_parent",
+            "height",
+            "group",
+            "_group",
+            "level",
+            "level_representation",
+            "name",
+            "code_aggregated",
+            "investable",
+            "description",
+            "_additional_resources",
+        )
+
+
+class ClassificationGroupModelSerializer(wb_serializers.ModelSerializer):
+    @wb_serializers.register_resource()
+    def additional_resources(self, instance, request, user):
+        if instance.classifications.exists():
+            return {
+                "classifications": reverse(
+                    "wbfdm:classificationgroup-classification-list", args=[instance.id], request=request
+                ),
+                "treechart": reverse("wbfdm:classificationgroup-treechart-list", args=[instance.id], request=request),
+                "iciclechart": reverse(
+                    "wbfdm:classificationgroup-iciclechart-list", args=[instance.id], request=request
+                ),
+            }
+
+        return {}
+
+    class Meta:
+        model = ClassificationGroup
+        fields = ("id", "name", "is_primary", "max_depth", "code_level_digits", "_additional_resources")

wbfdm/serializers/instruments/instrument_lists.py

@@ -0,0 +1,61 @@
+from rest_framework.reverse import reverse
+from wbcore import serializers as wb_serializers
+from wbfdm.models.instruments.instrument_lists import (
+    InstrumentList,
+    InstrumentListThroughModel,
+)
+from wbfdm.serializers.instruments import SecurityRepresentationSerializer
+
+
+class InstrumentListRepresentationSerializer(wb_serializers.RepresentationSerializer):
+    _detail = wb_serializers.HyperlinkField(reverse_name="wbfdm:instrumentlist-detail")
+
+    class Meta:
+        model = InstrumentList
+        fields = (
+            "id",
+            "name",
+            "_detail",
+        )
+
+
+class InstrumentListModelSerializer(wb_serializers.ModelSerializer):
+    @wb_serializers.register_only_instance_resource()
+    def instruments(self, instance, request, user, **kwargs):
+        if instance:
+            base_url = reverse("wbfdm:instrumentlist-instrumentlistthrough-list", args=[instance.id], request=request)
+            return {"instruments": base_url}
+        return {}
+
+    class Meta:
+        model = InstrumentList
+        read_only_fields = ("id", "identifier")
+        fields = (
+            "id",
+            "name",
+            "identifier",
+            "instrument_list_type",
+            "_additional_resources",
+        )
+
+
+class InstrumentListThroughModelSerializer(wb_serializers.ModelSerializer):
+    _instrument = SecurityRepresentationSerializer(source="instrument")
+    _instrument_list = InstrumentListRepresentationSerializer(source="instrument_list")
+
+    class Meta:
+        model = InstrumentListThroughModel
+        read_only_fields = ("instrument_str",)
+        fields = (
+            "id",
+            "instrument_str",
+            "instrument",
+            "_instrument",
+            "instrument_list",
+            "_instrument_list",
+            "from_date",
+            "to_date",
+            "comment",
+            "validated",
+            "_additional_resources",
+        )

wbfdm/serializers/instruments/instrument_prices.py

@@ -0,0 +1,73 @@
+from wbcore import serializers as wb_serializers
+from wbfdm.models import InstrumentPrice
+from wbfdm.serializers.instruments.instruments import (
+    InvestableInstrumentRepresentationSerializer,
+)
+
+
+class InstrumentPriceModelSerializer(wb_serializers.ModelSerializer):
+    _instrument = InvestableInstrumentRepresentationSerializer(source="instrument")
+    currency_symbol = wb_serializers.CharField(read_only=True)
+    net_value = wb_serializers.DecimalField(max_digits=16, decimal_places=2, default=0)
+    net_value_usd = wb_serializers.DecimalField(max_digits=16, decimal_places=2, default=0)
+    gross_value = wb_serializers.DecimalField(max_digits=16, decimal_places=2, default=0)
+    daily_diff_net_value = wb_serializers.FloatField(required=False, read_only=True, default=0, precision=4)
+    daily_diff_gross_value = wb_serializers.FloatField(required=False, read_only=True, default=0, precision=4)
+    real_price_exists = wb_serializers.BooleanField(default=False, read_only=True)
+
+    class Meta:
+        model = InstrumentPrice
+        percent_fields = [
+            "daily_diff_net_value",
+            "daily_diff_gross_value",
+        ]
+        decorators = {
+            "market_capitalization": wb_serializers.decorator(
+                decorator_type="text", position="left", value="{{currency_symbol}}"
+            ),
+        }
+        fields = (
+            "id",
+            "date",
+            "net_value",
+            "net_value_usd",
+            "gross_value",
+            "calculated",
+            "real_price_exists",
+            "sharpe_ratio",
+            "correlation",
+            "beta",
+            "daily_diff_net_value",
+            "daily_diff_gross_value",
+            "instrument",
+            "_instrument",
+            "volume",
+            "volume_50d",
+            "volume_200d",
+            "currency_symbol",
+            "outstanding_shares_consolidated",
+            "market_capitalization",
+        )
+
+
+class InstrumentPriceInstrumentModelSerializer(InstrumentPriceModelSerializer):
+    class Meta(InstrumentPriceModelSerializer.Meta):
+        fields = (
+            "id",
+            "date",
+            "net_value",
+            "net_value_usd",
+            "gross_value",
+            "sharpe_ratio",
+            "calculated",
+            "correlation",
+            "beta",
+            "daily_diff_net_value",
+            "daily_diff_gross_value",
+            "volume",
+            "volume_50d",
+            "volume_200d",
+            "currency_symbol",
+            "outstanding_shares_consolidated",
+            "market_capitalization",
+        )

wbfdm/serializers/instruments/instrument_relationships.py

@@ -0,0 +1,170 @@
+from rest_framework import serializers
+from rest_framework.reverse import reverse
+from wbcore import serializers as wb_serializers
+from wbcore.contrib.directory.models import Person
+from wbcore.contrib.directory.serializers import PersonRepresentationSerializer
+from wbcore.contrib.tags.serializers import TagSerializerMixin
+from wbfdm.models import (
+    Classification,
+    Instrument,
+    InstrumentClassificationRelatedInstrument,
+    InstrumentClassificationThroughModel,
+    InstrumentFavoriteGroup,
+    RelatedInstrumentThroughModel,
+)
+
+from .classifications import ClassificationZeroHeightRepresentationSerializer
+from .instruments import (
+    ClassifiableInstrumentRepresentationSerializer,
+    InvestableInstrumentRepresentationSerializer,
+    PrimaryInvestableInstrumentRepresentationSerializer,
+)
+
+
+class InstrumentFavoriteGroupRepresentationSerializer(wb_serializers.RepresentationSerializer):
+    _detail = wb_serializers.HyperlinkField(reverse_name="wbfdm:favoritegroup-detail")
+
+    class Meta:
+        model = InstrumentFavoriteGroup
+        fields = ("id", "name", "owner", "public", "_detail")
+
+
+class InstrumentFavoriteGroupModelSerializer(wb_serializers.ModelSerializer):
+    _instruments = PrimaryInvestableInstrumentRepresentationSerializer(source="instruments", many=True)
+    owner = wb_serializers.PrimaryKeyRelatedField(
+        queryset=lambda: Person.objects.filter_only_internal(),
+        default=wb_serializers.CurrentUserDefault("profile"),
+        read_only=lambda view: not view.request.user.is_superuser,
+    )
+    _owner = PersonRepresentationSerializer(source="owner")
+    public = wb_serializers.BooleanField(read_only=True)
+
+    # @wb_serializers.register_only_instance_resource()
+    # def instruments(self, instance, request, user, **kwargs):
+    #     if instance.instruments.exists():
+    #         return {"instruments": reverse("wbfdm:favoritegroup-instrument-list", args=[instance.id], request=request)}
+    #     return dict()
+
+    def validate(self, data):
+        if not data.get("owner", None):
+            data["owner"] = self.context["request"].user.profile if self.context.get("request") else None
+        return data
+
+    class Meta:
+        model = InstrumentFavoriteGroup
+        fields = (
+            "id",
+            "name",
+            "owner",
+            "_owner",
+            "public",
+            "primary",
+            "instruments",
+            "_instruments",
+            "_additional_resources",
+        )
+
+
+class RelatedInstrumentThroughInstrumentModelSerializer(wb_serializers.ModelSerializer):
+    _related_instrument = InvestableInstrumentRepresentationSerializer(source="related_instrument")
+    _instrument = InvestableInstrumentRepresentationSerializer(source="instrument")
+
+    class Meta:
+        model = RelatedInstrumentThroughModel
+        fields = (
+            "id",
+            "_related_instrument",
+            "related_instrument",
+            "_instrument",
+            "instrument",
+            "related_type",
+            "is_primary",
+        )
+
+
+class InstrumentClassificationThroughModelSerializer(TagSerializerMixin, wb_serializers.ModelSerializer):
+    instrument = wb_serializers.PrimaryKeyRelatedField(
+        queryset=Instrument.objects.all(), default=wb_serializers.DefaultFromKwargs("instrument_id")
+    )
+    _instrument = ClassifiableInstrumentRepresentationSerializer(source="instrument")
+    classification = wb_serializers.PrimaryKeyRelatedField(
+        queryset=Classification.objects.all(), default=wb_serializers.DefaultFromKwargs("classification_id")
+    )
+    _classification = ClassificationZeroHeightRepresentationSerializer(source="classification")
+    reason = wb_serializers.TextAreaField(label="Reason", allow_null=True, allow_blank=True, required=False)
+    _related_instruments = ClassifiableInstrumentRepresentationSerializer(source="related_instruments", many=True)
+
+    @wb_serializers.register_resource()
+    def related_instrument_list(self, instance, request, user):
+        return {"related_instruments": reverse("wbfdm:related_instrument-list", args=[instance.id], request=request)}
+
+    def validate(self, data):
+        instrument = data.get("instrument", self.instance.instrument if self.instance else None)
+        classification = data.get("classification", self.instance.classification if self.instance else None)
+        if not instrument:
+            raise serializers.ValidationError({"instrument": "Instrument cannot be null"})
+        if not classification:
+            raise serializers.ValidationError({"classification": "Classification cannot be null"})
+
+        if (
+            not self.instance
+            and InstrumentClassificationThroughModel.objects.filter(
+                classification=classification, instrument=instrument
+            ).exists()
+        ):
+            if hasattr(data, "instrument"):
+                raise serializers.ValidationError(
+                    {
+                        "instrument": f"A relationship already exists between {instrument} and {classification}",
+                    }
+                )
+            else:
+                raise serializers.ValidationError(
+                    {
+                        "classification": f"A relationship already exists between {instrument} and {classification}",
+                    }
+                )
+
+        return data
+
+    class Meta:
+        model = InstrumentClassificationThroughModel
+        fields = (
+            "id",
+            "instrument",
+            "classification",
+            "_instrument",
+            "_classification",
+            "related_instruments",
+            "_related_instruments",
+            "is_favorite",
+            "reason",
+            "pure_player",
+            "top_player",
+            "percent_of_revenue",
+            "tags",
+            "_tags",
+            "_additional_resources",
+        )
+        percent_fields = ["percent_of_revenue"]
+
+
+class InstrumentClassificationRelatedInstrumentRepresentationSerializer(wb_serializers.ModelSerializer):
+    class Meta:
+        model = InstrumentClassificationRelatedInstrument
+        fields = ("id", "related_instrument")
+
+
+class InstrumentClassificationRelatedInstrumentModelSerializer(wb_serializers.ModelSerializer):
+    _related_instrument = ClassifiableInstrumentRepresentationSerializer(source="related_instrument")
+
+    class Meta:
+        model = InstrumentClassificationRelatedInstrument
+        fields = (
+            "id",
+            "classified_instrument",
+            # "_classified_instrument",
+            "related_instrument",
+            "_related_instrument",
+            "related_instrument_type",
+        )