wbfdm 2.2.1__py2.py3-none-any.whl

wbfdm/models/fk_fields.py

@@ -0,0 +1,403 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+import logging
+from collections import OrderedDict
+from functools import wraps
+
+from django.core import checks
+from django.core.exceptions import FieldDoesNotExist
+from django.db.models import ForeignObjectRel
+from django.db.models.fields.related import ForeignObject
+from django.db.models.fields.related_descriptors import (
+    ForwardManyToOneDescriptor,
+    ReverseOneToOneDescriptor,
+)
+from django.db.models.sql.where import AND, WhereNode
+
+
+def get_cached_value(instance, descriptor, default=None):
+    return descriptor.field.get_cached_value(instance, default=default)
+
+
+def set_cached_value_by_descriptor(instance, descriptor, value):
+    descriptor.field.set_cached_value(instance, value)
+
+
+def set_cached_value_by_field(instance, field, value):
+    field.set_cached_value(instance, value)
+
+
+logger = logging.getLogger(__name__)
+
+
+# TODO: Figure out if nullable fields is a proper error
+class CompositeForwardManyToOneDescriptor(ForwardManyToOneDescriptor):
+    def __set__(self, instance, value):
+        if value is not None or not self.field.nullable_fields:
+            super().__set__(instance, value)
+        else:
+            # we set only the asked fields to None, not all field as the default ForwardManyToOneDescriptor will
+
+            # ### taken from original ForwardManyToOneDescriptor
+            # Look up the previously-related object, which may still be available
+            # since we've not yet cleared out the related field.
+            # Use the cache directly, instead of the accessor; if we haven't
+            # populated the cache, then we don't care - we're only accessing
+            # the object to invalidate the accessor cache, so there's no
+            # need to populate the cache just to expire it again.
+            related = get_cached_value(instance, self, None)
+
+            # If we've got an old related object, we need to clear out its
+            # cache. This cache also might not exist if the related object
+            # hasn't been accessed yet.
+            if related is not None:
+                related_field = self.field.remote_field
+                set_cached_value_by_field(related, related_field, None)
+
+            # ##### only original part
+            for lh_field_name, none_value in self.field.nullable_fields.items():
+                setattr(instance, lh_field_name, none_value)
+
+            # Set the related instance cache used by __get__ to avoid a SQL query
+            # when accessing the attribute we just set.
+            set_cached_value_by_descriptor(instance, self, None)
+
+
+class CompositeForeignKey(ForeignObject):
+    requires_unique_target = False
+    auto_created = False
+    empty_strings_allowed = False
+
+    many_to_many = False
+    many_to_one = False
+    one_to_many = True
+    one_to_one = False
+
+    rel_class = ForeignObjectRel
+
+    def __init__(self, to, **kwargs):
+        """
+        create the ForeignObject, but use the to_fields as a dict which will later used as form_fields and to_fields
+        """
+        to_fields = kwargs["to_fields"]
+        self.null_if_equal = kwargs.pop("null_if_equal", [])
+        nullable_fields = kwargs.pop("nullable_fields", {})
+        if not isinstance(nullable_fields, dict):
+            nullable_fields = {v: None for v in nullable_fields}
+        self.nullable_fields = nullable_fields
+
+        # a list of tuple : (fieldnaem, value) . if fielname = value, then the field react as if fieldnaem_id = None
+        self._raw_fields = self.compute_to_fields(to_fields)
+        # hiro nakamura should have said «very bad guy. you are vilain»
+        if "on_delete" in kwargs:
+            kwargs["on_delete"] = self.override_on_delete(kwargs["on_delete"])
+
+        kwargs["to_fields"], kwargs["from_fields"] = zip(
+            *((k, v.value) for k, v in self._raw_fields.items() if v.is_local_field)
+        )
+        super().__init__(to, **kwargs)
+
+    def override_on_delete(self, original):
+        @wraps(original)
+        def wrapper(collector, field, sub_objs, using):
+            res = original(collector, field, sub_objs, using)
+            # we make something nasty : we update the collector to
+            # skip the local field which does not have a dbcolumn
+            try:
+                del collector.field_updates[self.model][(self, None)]
+            except KeyError:
+                pass
+            return res
+
+        wrapper._original_fn = original
+
+        return wrapper
+
+    def check(self, **kwargs):
+        errors = super().check(**kwargs)
+        errors.extend(self._check_null_with_nullifequal())
+        errors.extend(self._check_nullifequal_fields_exists())
+        errors.extend(self._check_to_fields_local_valide())
+        errors.extend(self._check_to_fields_remote_valide())
+        errors.extend(self._check_recursion_field_dependecy())
+        errors.extend(self._check_bad_order_fields())
+        return errors
+
+    def _check_bad_order_fields(self):
+        res = []
+        try:
+            dependents = list(self.local_related_fields)
+        except FieldDoesNotExist:
+            return []  # the errors shall be raised befor by _check_recursion_field_dependecy
+
+        for field in self.model._meta.get_fields():
+            try:
+                dependents.remove(field)
+            except ValueError:
+                pass
+            if field == self:
+                if dependents:
+                    # we met the current fields, but all dependent fields is not
+                    # passed befor : we will have a problem in the init of some objects
+                    # where the rest of dependents fields will override the
+                    # values set by the current one (see Model.__init__)
+                    res.append(
+                        checks.Error(
+                            "the field %s depend on the fields %s which is defined after. define them befor %s"
+                            % (self.name, ",".join(f.name for f in dependents), self.name),
+                            hint=None,
+                            obj=self,
+                            id="compositefk.E006",
+                        )
+                    )
+                break
+        return res
+
+    def _check_recursion_field_dependecy(self):
+        res = []
+        for local_field in self._raw_fields.values():
+            try:
+                f = self.model._meta.get_field(local_field.value)
+                if isinstance(f, CompositeForeignKey):
+                    res.append(
+                        checks.Error(
+                            "the field %s depend on the field %s which is another CompositeForeignKey"
+                            % (self.name, local_field),
+                            hint=None,
+                            obj=self,
+                            id="compositefk.E005",
+                        )
+                    )
+            except FieldDoesNotExist:
+                pass  # _check_to_fields_local_valide already raise errors for this
+        return res
+
+    def _check_to_fields_local_valide(self):
+        res = []
+        for local_field in self._raw_fields.values():
+            if isinstance(local_field, LocalFieldValue):
+                try:
+                    self.model._meta.get_field(local_field.value)
+                except FieldDoesNotExist:
+                    res.append(
+                        checks.Error(
+                            "the field %s does not exists on the model %s" % (local_field, self.model),
+                            hint=None,
+                            obj=self,
+                            id="compositefk.E003",
+                        )
+                    )
+        return res
+
+    def _check_to_fields_remote_valide(self):
+        res = []
+        for remote_field in self._raw_fields.keys():
+            try:
+                self.related_model._meta.get_field(remote_field)
+            except FieldDoesNotExist:
+                res.append(
+                    checks.Error(
+                        "the field %s does not exists on the model %s" % (remote_field, self.model),
+                        hint=None,
+                        obj=self,
+                        id="compositefk.E004",
+                    )
+                )
+        return res
+
+    def _check_null_with_nullifequal(self):
+        if self.null_if_equal and not self.null:
+            return [
+                checks.Error(
+                    "you must set null=True to field %s.%s if null_if_equal is given"
+                    % (self.model.__class__.__name__, self.name),
+                    hint=None,
+                    obj=self,
+                    id="compositefk.E001",
+                )
+            ]
+        return []
+
+    def _check_nullifequal_fields_exists(self):
+        res = []
+        for field_name, value in self.null_if_equal:
+            try:
+                self.model._meta.get_field(field_name)
+            except FieldDoesNotExist:
+                res.append(
+                    checks.Error(
+                        "the field %s does not exists on the model %s" % (field_name, self.model),
+                        hint=None,
+                        obj=self,
+                        id="compositefk.E002",
+                    )
+                )
+        return res
+
+    def deconstruct(self):
+        name, path, args, kwargs = super(CompositeForeignKey, self).deconstruct()
+        del kwargs["from_fields"]
+        if "on_delete" in kwargs:
+            kwargs["on_delete"] = kwargs["on_delete"]._original_fn
+        kwargs["to_fields"] = self._raw_fields
+        kwargs["null_if_equal"] = self.null_if_equal
+        return name, path, args, kwargs
+
+    def get_extra_descriptor_filter(self, instance):
+        return {k: v.value for k, v in self._raw_fields.items() if isinstance(v, RawFieldValue)}
+
+    def get_extra_restriction(self, alias, related_alias):
+        constraint = WhereNode(connector=AND)
+        for remote, local in self._raw_fields.items():
+            lookup = local.get_lookup(self, self.related_model._meta.get_field(remote), alias)
+            if lookup:
+                constraint.add(lookup, AND)
+        if constraint.children:
+            return constraint
+        else:
+            return None
+
+    def compute_to_fields(self, to_fields):
+        """
+        compute the to_fields parameterse to make it uniformly a dict of CompositePart
+        :param set[unicode]|dict[unicode, unicode] to_fields: the list/dict of fields to match
+        :return: the well formated to_field containing only subclasses of CompositePart
+        :rtype: dict[str, CompositePart]
+        """
+        # for problem in trim_join, we must try to give the fields in a consistent order with others models...
+        # see #26515 at  https://code.djangoproject.com/ticket/26515
+
+        return OrderedDict(
+            (k, (v if isinstance(v, CompositePart) else LocalFieldValue(v)))
+            for k, v in (to_fields.items() if isinstance(to_fields, dict) else zip(to_fields, to_fields))
+        )
+
+    def db_type(self, connection):
+        # A CompositeForeignKey don't have a column in the database
+        # so return None.
+        return None
+
+    def db_parameters(self, connection):
+        return {"type": None, "check": None}
+
+    def contribute_to_class(self, cls, name, **kwargs):
+        super().contribute_to_class(cls, name, **kwargs)
+        setattr(cls, self.name, CompositeForwardManyToOneDescriptor(self))
+
+    def get_instance_value_for_fields(self, instance, fields):
+        # we override this method to provide the feathur of converting
+        # some special values of teh composite local fields into a
+        # None pointing field.
+        # ie, if company is '   ' and it mean that the current field
+        # point to nothing (as if it was None) => we transform this
+        # '   ' into a true None to let django das as if it was None
+        res = super(CompositeForeignKey, self).get_instance_value_for_fields(instance, fields)
+        if self.null_if_equal:
+            for field_name, exception_value in self.null_if_equal:
+                val = getattr(instance, field_name)
+                if val == exception_value:
+                    # we have field_name that is equal to the bad value
+                    # currently, it is enouth since the django implementation check at first
+                    # if there is a None in the result
+                    return (None,)
+        return res
+
+
+class CompositeOneToOneField(CompositeForeignKey):
+    # Field flags
+    many_to_many = False
+    many_to_one = False
+    one_to_many = False
+    one_to_one = True
+
+    related_accessor_class = ReverseOneToOneDescriptor
+
+    description = "One-to-one relationship"
+
+    def __init__(self, to, **kwargs):
+        kwargs["unique"] = True
+        super().__init__(to, **kwargs)
+        self.remote_field.multiple = False
+
+    def deconstruct(self):
+        name, path, args, kwargs = super().deconstruct()
+        if "unique" in kwargs:
+            del kwargs["unique"]
+        return name, path, args, kwargs
+
+
+class CompositePart(object):
+    is_local_field = True
+
+    def __init__(self, value):
+        self.value = value
+
+    def deconstruct(self):
+        module_name = self.__module__
+        name = self.__class__.__name__
+        return ("%s.%s" % (module_name, name), (self.value,), {})
+
+    def __repr__(self):
+        return "%s(%r)" % (self.__class__.__name__, self.value)
+
+    def __eq__(self, other):
+        if self.__class__ != other.__class__:
+            return False
+        return self.value == other.value
+
+    def get_lookup(self, main_field, for_remote, alias):
+        """
+        create a fake field for the lookup capability
+        :param CompositeForeignKey main_field: the local fk
+        :param Field for_remote: the remote field to match
+        :return:
+        """
+
+
+class RawFieldValue(CompositePart):
+    """
+    represent a raw value for  a field.
+    """
+
+    is_local_field = False
+
+    def get_lookup(self, main_field, for_remote, alias):
+        """
+        create a fake field for the lookup capability
+        :param CompositeForeignKey main_field: the local fk
+        :param Field for_remote: the remote field to match
+        :return:
+        """
+        lookup_class = for_remote.get_lookup("exact")
+        return lookup_class(for_remote.get_col(alias), self.value)
+
+
+class FunctionBasedFieldValue(RawFieldValue):
+    def __init__(self, func):
+        self._func = func
+
+    def deconstruct(self):
+        module_name = self.__module__
+        name = self.__class__.__name__
+        return ("%s.%s" % (module_name, name), (self._func,), {})
+
+    def __eq__(self, other):
+        if self.__class__ != other.__class__:
+            return False
+        return self._func == other._func
+
+    @property
+    def value(self):
+        return self._func()
+
+    @value.setter
+    def value(self):
+        pass
+
+
+class LocalFieldValue(CompositePart):
+    """
+    implicitly used, represent the value of a local field
+    """
+
+    is_local_field = True

wbfdm/models/instruments/__init__.py

@@ -0,0 +1,19 @@
+from .llm import run_company_extraction_llm
+from .instruments import Instrument, InstrumentType, Cash, Equity
+from .instrument_prices import InstrumentPrice
+from .instrument_relationships import (
+    InstrumentClassificationRelatedInstrument,
+    InstrumentClassificationThroughModel,
+    InstrumentFavoriteGroup,
+    RelatedInstrumentThroughModel,
+)
+from .classifications import (
+    Classification,
+    ClassificationGroup,
+)
+from .instrument_lists import InstrumentList, InstrumentListThroughModel
+
+from .instrument_requests import InstrumentRequest
+
+from .private_equities import Deal
+from .options import Option, OptionAggregate

wbfdm/models/instruments/classifications.py

@@ -0,0 +1,265 @@
+from typing import List, Optional
+
+import roman
+from django.contrib.postgres.expressions import ArraySubquery
+from django.db import models
+from django.db.models.functions import Cast
+from django.db.models.signals import post_save
+from django.dispatch import receiver
+from mptt.models import MPTTModel, TreeForeignKey
+from wbcore.models import WBModel
+from wbcore.utils.models import ComplexToStringMixin
+
+from .instrument_relationships import InstrumentClassificationThroughModel
+
+
+class ClassificationGroup(WBModel):
+    name = models.CharField(max_length=128, verbose_name="Name")
+    is_primary = models.BooleanField(
+        default=False,
+        verbose_name="Primary",
+        help_text="Set to True if this " "classification must be used as " "default if not specified " "otherwise",
+    )
+    max_depth = models.IntegerField(default=0, verbose_name="Maximum Depth")
+    code_level_digits = models.IntegerField(default=2, verbose_name="The number of digits per code level")
+
+    def __str__(self) -> str:
+        return f'{self.name} ({"Primary" if self.is_primary else "Non Primary"})'
+
+    def save(self, *args, **kwargs):
+        qs = ClassificationGroup.objects.filter(is_primary=True).exclude(id=self.id)
+        if self.is_primary:
+            qs.update(is_primary=False)
+        elif not qs.exists():
+            self.is_primary = True
+        return super().save(*args, **kwargs)
+
+    def get_levels_representation(self) -> List[str]:
+        return [
+            self.classifications.filter(height=i).first().level_representation
+            for i in range(self.max_depth + 1)
+            if self.classifications.filter(height=i).exists()
+        ]
+
+    def get_fields_names(self, sep: str = "__") -> list[str]:
+        return [f"parent{f'{sep}parent' * height}" for height in range(self.max_depth)]
+
+    def annotate_queryset(
+        self,
+        queryset: models.QuerySet,
+        classification_height: int,
+        instrument_label_key: str,
+        unique: bool = False,
+        annotation_label: str = "classifications",
+    ):
+        ref_id = "classification__"
+        if classification_height:
+            ref_id += f"{'parent__' * classification_height}"
+        ref_id += "id"
+        if instrument_label_key:
+            instrument_label_key += "__"
+        base_subquery = InstrumentClassificationThroughModel.objects.filter(
+            classification__group=self,
+            instrument__tree_id=models.OuterRef(f"{instrument_label_key}tree_id"),
+            instrument__lft__lte=models.OuterRef(f"{instrument_label_key}lft"),
+            instrument__rght__gte=models.OuterRef(f"{instrument_label_key}rght"),
+        )
+        if unique:
+            expression = models.Subquery(base_subquery.values(ref_id)[:1])
+        else:
+            expression = ArraySubquery(
+                base_subquery.values(ref_id).distinct(ref_id)
+            )  # we use distinct in order to remove duplicated classification (e.g. classification added to the parent as well as the children)
+
+        return queryset.annotate(**{annotation_label: expression})
+
+    class Meta:
+        verbose_name = "Classification Group"
+        verbose_name_plural = "Classification Groups"
+
+    @classmethod
+    def get_representation_endpoint(cls) -> str:
+        return "wbfdm:classificationgrouprepresentation-list"
+
+    @classmethod
+    def get_representation_value_key(cls) -> str:
+        return "id"
+
+    @classmethod
+    def get_representation_label_key(cls) -> str:
+        return "{{name}}"
+
+    @classmethod
+    def get_endpoint_basename(cls) -> str:
+        return "wbfdm:classificationgroup"
+
+
+class Classification(MPTTModel, ComplexToStringMixin):
+    parent = TreeForeignKey(
+        "self",
+        related_name="children",
+        null=True,
+        blank=True,
+        on_delete=models.CASCADE,
+        verbose_name="Parent Classification",
+    )
+    height = models.PositiveIntegerField(
+        default=0,
+        verbose_name="The height (leaf node have height 0)",
+    )
+    group = models.ForeignKey(
+        ClassificationGroup,
+        related_name="classifications",
+        on_delete=models.CASCADE,
+        verbose_name="Classification Group",
+    )
+
+    level_representation = models.CharField(max_length=256, verbose_name="Level Representation")
+
+    name = models.CharField(max_length=128, verbose_name="Name")
+    code_aggregated = models.CharField(max_length=64, verbose_name="Code Aggregated")
+
+    investable = models.BooleanField(default=True, help_text="Is this classification investable for us?")
+
+    description = models.TextField(
+        default="",
+        blank=True,
+        help_text="Give a basic definition and description",
+        verbose_name="Definition/Description",
+    )
+
+    @classmethod
+    def dict_to_model(cls, classification_data):
+        if isinstance(classification_data, int):
+            return cls.objects.filter(id=classification_data).first()
+        res = cls.objects.all()
+        if code_aggregated := classification_data.get("code_aggregated", None):
+            res = res.filter(code_aggregated=code_aggregated)
+        if group_id := classification_data.get("group", None):
+            res = res.filter(group=group_id)
+        if res.count() == 1:
+            return res.first()
+
+    def __str__(self):
+        if self.computed_str:
+            return self.computed_str
+        return f"{self.code_aggregated} {self.name}"
+
+    def get_classified_instruments(self, only_favorites: bool = False) -> models.QuerySet:
+        childs_classifications = self.get_descendants(include_self=True)
+        params = {"classifications__in": childs_classifications}
+        if only_favorites:
+            params["classifications_through__is_favorite"] = True
+
+        from wbfdm.models import Instrument
+
+        return Instrument.objects.filter(**params).distinct()
+
+    def save(self, *args, **kwargs):
+        if self.parent:
+            self.group = self.parent.group
+        if not self.code_aggregated:
+            self.code_aggregated = self.get_next_valid_code(self.group, self.parent)
+        if not self.level_representation:
+            self.level_representation = self.get_default_level_representation(self.group, self.parent)
+        return super().save(*args, **kwargs)
+
+    def compute_str(self) -> str:
+        if parent := self.parent:
+            tree_titles = parent.name
+            while parent and (parent := parent.parent):
+                tree_titles += f" - {parent.name}"
+            return f"{self.code_aggregated} {self.name} [{tree_titles}] ({self.group.name})"
+        return f"{self.code_aggregated} {self.name} ({self.group.name})"
+
+    class Meta:
+        verbose_name = "Classification"
+        verbose_name_plural = "Classifications"
+        constraints = [models.UniqueConstraint(fields=["group", "code_aggregated"], name="unique_classification")]
+
+    @classmethod
+    def get_next_valid_code(cls, group: "ClassificationGroup", parent: "Classification | None" = None) -> str:
+        """
+        Return the next valid classification code given the classification parent and its group parameters
+        Args:
+            group: The classification group the estimated code belongs to
+            parent: The classification parent (if any)
+
+        Returns:
+            The next valid and unused aggregated classification code
+        """
+        if not group:
+            raise ValueError("This method needs a group")
+        siblings_classifications = (
+            Classification.objects.filter(parent=parent, group=group)
+            .annotate(casted_code=Cast("code_aggregated", models.BigIntegerField()))
+            .order_by("-casted_code")
+        )
+        parent_level = parent.level + 1 if parent else 0
+        code_aggregated_digits = group.code_level_digits * (parent_level + 1)
+        if last_classification := siblings_classifications.first():
+            for i in range(0, 100 - last_classification.casted_code % 10**group.code_level_digits):
+                if not siblings_classifications.filter(casted_code=last_classification.casted_code + i).exists():
+                    last_valid_code = last_classification.casted_code + i
+                    return f"{last_valid_code:0{code_aggregated_digits}}"
+        if parent:
+            return parent.code_aggregated + f"{1:0{group.code_level_digits}}"
+        return f"{1:0{group.code_level_digits}}"
+
+    @classmethod
+    def get_default_level_representation(
+        cls, group: "ClassificationGroup", parent: Optional["Classification"] = None
+    ) -> str:
+        """
+        Return the default level representation, extracted from the classification siblings
+        Args:
+            group: The classification group the estimated code belongs to
+            parent: The classification parent (if any)
+
+        Returns:
+            A default level representation (e.g. Industry)
+        """
+        level = parent.level + 1 if parent else None
+        siblings_classifications = cls.objects.filter(level=level, group=group).order_by("id")
+        if siblings_classifications.exists():
+            return siblings_classifications.last().level_representation
+        level = roman.toRoman(level) if level else 0
+        return f"Level {level}"
+
+    @classmethod
+    def get_representation_endpoint(cls) -> str:
+        return "wbfdm:classificationrepresentation-list"
+
+    @classmethod
+    def get_representation_value_key(cls) -> str:
+        return "id"
+
+    @classmethod
+    def get_endpoint_basename(cls) -> str:
+        return "wbfdm:classification"
+
+
+@receiver(post_save, sender="wbfdm.Classification")
+def post_save_parent_classification(sender, instance, created, raw, **kwargs):
+    # Recursively call the parent save function to recompute its parameters
+    if not raw and instance.parent:
+        instance.parent.save()
+    if instance.level is not None:
+        update_fields = {"height": instance.group.max_depth - instance.level}
+        Classification.objects.filter(id=instance.id).update(**update_fields)
+        instance.refresh_from_db()
+    # # Ensure initial parent classifcation span the proper classification tree structure
+    if instance.group and not instance.get_descendants().exists() and instance.level < instance.group.max_depth:
+        Classification.objects.create(
+            parent=instance,
+            group=instance.group,
+            name=f"{instance.name} (Level {instance.level})",
+        )
+    """
+    If a parent classification is not investable, therefore its "children" become non investable too, by cascade.
+    If a child classification becomes investable and one of its parent is non investable, therefore he cannot be
+    investable as long as its parent is non investable. (-> in the serializer)
+    """
+    if not raw and not instance.investable and instance.get_descendants().exists():
+        descandants = instance.get_descendants()
+        descandants.update(investable=False)