wbfdm 2.2.1__py2.py3-none-any.whl

wbfdm/filters/__init__.py

@@ -0,0 +1,31 @@
+from .classifications import (
+    ClassificationFilter,
+    ClassificationTreeChartFilter,
+    InstrumentClassificationThroughModelViewFilterSet,
+)
+from .financials_analysis import (
+    FinancialAnalysisFilterSet,
+    FinancialAnalysisValuationRatiosFilterSet,
+    EarningsAnalysisFilterSet,
+    GroupKeyFinancialsFilterSet,
+)
+from .instruments import (
+    InstrumentFavoriteGroupFilterSet,
+    InstrumentFilterSet,
+    BaseClassifiedInstrumentFilterSet,
+    MonthlyPerformancesInstrumentFilterSet,
+)
+from .instrument_prices import (
+    InstrumentPriceFilterSet,
+    InstrumentPriceSingleBenchmarkFilterSet,
+    InstrumentPriceFrequencyFilter,
+    InstrumentPriceFinancialStatisticsChartFilterSet,
+    InstrumentPriceInstrumentFilterSet,
+)
+from .exchanges import ExchangeFilterSet
+from .financials import (
+    MarketDataChartFilterSet,
+    FinancialRatioFilterSet,
+    StatementFilter,
+    StatementWithEstimateFilter,
+)

wbfdm/filters/classifications.py

@@ -0,0 +1,100 @@
+from wbcore import filters as wb_filters
+from wbfdm.models import (
+    Classification,
+    ClassificationGroup,
+    Instrument,
+    InstrumentClassificationThroughModel,
+)
+
+
+class ClassificationFilter(wb_filters.FilterSet):
+    instruments = wb_filters.ModelChoiceFilter(
+        label="Instrument",
+        queryset=Instrument.objects.all(),
+        endpoint=Instrument.get_representation_endpoint(),
+        filter_params={"is_classifiable": True},
+        value_key=Instrument.get_representation_value_key(),
+        label_key=Instrument.get_representation_label_key(),
+    )
+
+    instruments_neq = wb_filters.ModelChoiceFilter(
+        label="Instrument not classified in",
+        queryset=Instrument.objects.all(),
+        endpoint=Instrument.get_representation_endpoint(),
+        value_key=Instrument.get_representation_value_key(),
+        label_key=Instrument.get_representation_label_key(),
+        filter_params={"is_classifiable": True},
+        field_name="instruments",
+        lookup_expr="exact",
+        exclude=True,
+    )
+
+    instrument_type_key = wb_filters.CharFilter(
+        label="Instrument Type Key", hidden=True, method="filter_instrument_type_key"
+    )
+
+    def filter_instrument_type_key(self, queryset, name, value):
+        if value:
+            return queryset.filter(instruments__instrument_type__key=value).distinct()
+        return queryset
+
+    class Meta:
+        model = Classification
+        fields = {
+            "id": ["in"],
+            "parent": ["exact"],
+            "height": ["gte", "exact", "lte"],
+            "level": ["gte", "exact", "lte"],
+            "group": ["exact"],
+            "level_representation": ["icontains"],
+            "name": ["icontains"],
+            "code_aggregated": ["icontains", "exact"],
+        }
+        hidden_fields = ["id__in"]
+
+
+class ClassificationTreeChartFilter(wb_filters.FilterSet):
+    top_classification = wb_filters.ModelChoiceFilter(
+        label="Top Classification",
+        queryset=Classification.objects.all(),
+        endpoint=Classification.get_representation_endpoint(),
+        value_key=Classification.get_representation_value_key(),
+        label_key=Classification.get_representation_label_key(),
+        method="filter_top_classification",
+    )
+
+    aggregation_type = wb_filters.ChoiceFilter(
+        choices=[("classification_count", "Classification Count"), ("instrument_count", "Instrument Count")],
+        default="classification_count",
+        label="Aggregation Type",
+        method="fake_filter",
+    )
+
+    def filter_top_classification(self, queryset, name, value):
+        if value:
+            return queryset.filter(id__in=value.get_descendants().values("id"))
+        return queryset
+
+    class Meta:
+        model = Classification
+        fields = {}
+
+
+class InstrumentClassificationThroughModelViewFilterSet(wb_filters.FilterSet):
+    classification__group = wb_filters.ModelChoiceFilter(
+        label="Group",
+        queryset=ClassificationGroup.objects.all(),
+        endpoint=ClassificationGroup.get_representation_endpoint(),
+        value_key=ClassificationGroup.get_representation_value_key(),
+        label_key=ClassificationGroup.get_representation_label_key(),
+    )
+
+    class Meta:
+        model = InstrumentClassificationThroughModel
+        fields = {
+            "instrument": ["exact"],
+            "classification": ["exact"],
+            "is_favorite": ["exact"],
+            "pure_player": ["exact"],
+            "top_player": ["exact"],
+        }

wbfdm/filters/exchanges.py

@@ -0,0 +1,22 @@
+from wbcore import filters as wb_filters
+from wbfdm.models import Exchange
+
+
+class ExchangeFilterSet(wb_filters.FilterSet):
+    class Meta:
+        model = Exchange
+        fields = {
+            "name": ["exact", "icontains"],
+            "mic_code": ["exact", "icontains"],
+            "operating_mic_code": ["exact", "icontains"],
+            "bbg_composite_primary": ["exact"],
+            "bbg_composite": ["exact", "icontains"],
+            "refinitiv_identifier_code": ["exact", "icontains"],
+            "refinitiv_mnemonic": ["exact", "icontains"],
+            "country": ["exact"],
+            "city": ["exact"],
+            "website": ["exact", "icontains"],
+            "comments": ["exact", "icontains"],
+            "opening_time": ["exact", "gte", "lte"],
+            "closing_time": ["exact", "gte", "lte"],
+        }

wbfdm/filters/financials.py

@@ -0,0 +1,95 @@
+from wbcore import filters
+from wbcore.filters.defaults import five_year_data_range
+from wbfdm.enums import CalendarType, DataType, Indicator, MarketDataChartType
+from wbfdm.models.instruments import Instrument
+
+
+class MarketDataChartFilterSet(filters.FilterSet):
+    period = filters.FinancialPerformanceDateRangeFilter(
+        label="Period",
+        method="fake_filter",
+        default=five_year_data_range,
+    )
+    chart_type = filters.ChoiceFilter(
+        method="fake_filter",
+        label="Chart Type",
+        choices=MarketDataChartType.choices,
+        default="close",
+    )
+    benchmarks = filters.ModelMultipleChoiceFilter(
+        label="Benchmarks",
+        queryset=Instrument.objects.all(),
+        endpoint=Instrument.get_representation_endpoint(),
+        value_key=Instrument.get_representation_value_key(),
+        label_key=Instrument.get_representation_label_key(),
+        filter_params={"is_security": True},
+        method="fake_filter",
+    )
+    indicators = filters.MultipleChoiceFilter(
+        method="fake_filter",
+        label="Indicators",
+        choices=Indicator.choices,
+        required=False,
+    )
+    volume = filters.BooleanFilter(
+        method="fake_filter",
+        label="Add Volume",
+        default=False,
+        required=False,
+    )
+    show_estimates = filters.BooleanFilter(
+        method="fake_filter",
+        label="Show Estimates",
+        default=True,
+        required=False,
+    )
+
+    class Meta:
+        model = Instrument
+        fields = {}
+
+
+class FinancialRatioFilterSet(filters.FilterSet):
+    ttm = filters.BooleanFilter(
+        method="fake_filter",
+        label="TTM/FTM",
+        default=True,
+    )
+
+    period = filters.FinancialPerformanceDateRangeFilter(
+        method="fake_filter",
+        label="Period",
+        default=five_year_data_range,
+    )
+
+    class Meta:
+        model = Instrument
+        fields = {}
+
+
+class StatementFilter(filters.FilterSet):
+    data_type = filters.ChoiceFilter(
+        method="fake_filter",
+        label="Data Type",
+        choices=DataType.choices,
+        required=True,
+        default=DataType.STANDARDIZED,
+    )
+
+    class Meta:
+        model = Instrument
+        fields = {}
+
+
+class StatementWithEstimateFilter(filters.FilterSet):
+    calendar_type = filters.ChoiceFilter(
+        method="fake_filter",
+        label="Calendar Type",
+        choices=CalendarType.choices,
+        required=True,
+        default=CalendarType.FISCAL,
+    )
+
+    class Meta:
+        model = Instrument
+        fields = {}

wbfdm/filters/financials_analysis.py

@@ -0,0 +1,119 @@
+from datetime import date
+
+from django.db import models
+from pandas.tseries.offsets import BYearEnd
+from psycopg.types.range import DateRange
+from wbcore import filters as wb_filters
+from wbfdm.figures.financials.financial_analysis_charts import (
+    PeriodChoices,
+    VariableChoices,
+)
+from wbfdm.models.instruments.instruments import Instrument
+
+
+def byearend_n_year_ago(n):
+    today = date.today()
+    return (today - BYearEnd(n)).date()
+
+
+def byearend_2_year_ago(field, request, view):
+    return byearend_n_year_ago(2)
+
+
+class GroupKeyFinancialsFilterSet(wb_filters.FilterSet):
+    group_keys = wb_filters.CharFilter(
+        required=True,
+        method=lambda q, n, v: q,
+    )
+
+    class Meta:
+        models = Instrument
+        fields = {}
+
+
+class FinancialAnalysisFilterSet(wb_filters.FilterSet):
+    class Meta:
+        model = Instrument
+        fields = {}
+
+
+def _get_12m(field, request, view):
+    return date(date.today().year - 1, 1, 1)
+
+
+class FinancialAnalysisValuationRatiosFilterSet(wb_filters.FilterSet):
+    date = wb_filters.FinancialPerformanceDateRangeFilter(
+        method=lambda queryset, label, value: queryset,
+        label="Date Range",
+        required=True,
+        clearable=False,
+        default=lambda r, v, q: DateRange(_get_12m(r, v, q), date.today()),
+    )
+
+    class OutputChoices(models.TextChoices):
+        TSTABLE = "TSTABLE", "Table (Time-series)"
+        TABLE = "TABLE", "Table (Last Value)"
+        CHART = "CHART", "Chart"
+
+    class RangeChoices(models.TextChoices):
+        MINMAX = "MINMAX", "Min-Max (entire period)"
+        ROLLING = "ROLLING", "Rolling"
+
+    output = wb_filters.ChoiceFilter(
+        choices=OutputChoices.choices, label="Output", method="fake_filter", default=OutputChoices.CHART
+    )
+    period = wb_filters.ChoiceFilter(
+        choices=PeriodChoices.choices, label="Period", method="fake_filter", default=PeriodChoices.NTM
+    )
+    vs_related = wb_filters.BooleanFilter(label="Versus related", default=False, method="fake_filter")
+    clean_data = wb_filters.BooleanFilter(label="Clean data", default=True, method="fake_filter")
+    ranges = wb_filters.BooleanFilter(label="Draw ranges", default=False, required=False, method="fake_filter")
+    range_type = wb_filters.ChoiceFilter(
+        choices=RangeChoices.choices,
+        label="Range type",
+        method="fake_filter",
+        required=True,
+        default=RangeChoices.MINMAX,
+    )
+    range_period = wb_filters.NumberFilter(
+        precision=0, label="Rolling period", method="fake_filter", required=True, default=120
+    )
+    x_axis_var = wb_filters.ChoiceFilter(
+        choices=VariableChoices.choices, label="X-Axis", method="fake_filter", default=VariableChoices.EPSG
+    )
+    y_axis_var = wb_filters.ChoiceFilter(
+        choices=VariableChoices.choices, label="Y-Axis", method="fake_filter", default=VariableChoices.PE
+    )
+    z_axis_var = wb_filters.ChoiceFilter(
+        choices=VariableChoices.choices, label="Bubble", method="fake_filter", default=VariableChoices.MKTCAP
+    )
+    median = wb_filters.BooleanFilter(label="Median", default=True, method="fake_filter")
+
+    class Meta:
+        model = Instrument
+        fields = {}
+
+
+class EarningsAnalysisFilterSet(wb_filters.FilterSet):
+    date = wb_filters.FinancialPerformanceDateRangeFilter(
+        method=lambda queryset, label, value: queryset,
+        label="Date Range",
+        required=True,
+        clearable=False,
+        default=lambda r, v, q: DateRange(_get_12m(r, v, q), date.today()),
+    )
+
+    class OutputChoices(models.TextChoices):
+        EPS = "EPS", "Earnings ($)"
+
+    analysis = wb_filters.ChoiceFilter(
+        choices=OutputChoices.choices, label="Analysis", method=lambda q, n, v: q, default=OutputChoices.EPS
+    )
+    period = wb_filters.ChoiceFilter(
+        choices=PeriodChoices.choices, label="Period", method=lambda q, n, v: q, default=PeriodChoices.NTM
+    )
+    vs_related = wb_filters.BooleanFilter(label="Show related", default=False, method=lambda q, n, v: q)
+
+    class Meta:
+        model = Instrument
+        fields = {}

wbfdm/filters/instrument_prices.py

@@ -0,0 +1,112 @@
+from datetime import date
+
+from django.db import models
+from psycopg.types.range import DateRange
+from wbcore import filters as wb_filters
+from wbfdm.filters.utils import get_earliest_date, get_latest_date
+from wbfdm.models import Instrument, InstrumentPrice
+
+from .financials_analysis import byearend_2_year_ago
+
+
+class FakeDateRange(wb_filters.FilterSet):
+    date = wb_filters.FinancialPerformanceDateRangeFilter(
+        method=lambda queryset, label, value: queryset,
+        label="Date Range",
+        required=True,
+        clearable=False,
+        default=lambda r, v, q: DateRange(byearend_2_year_ago(r, v, q), date.today()),
+    )
+
+    class Meta:
+        model = Instrument
+        fields = {}
+
+
+class InstrumentPriceFilterSet(wb_filters.FilterSet):
+    date = wb_filters.FinancialPerformanceDateRangeFilter(
+        method=wb_filters.DateRangeFilter.base_date_range_filter_method,
+        label="Date Range",
+        required=True,
+        clearable=False,
+        default=lambda r, v, q: DateRange(get_earliest_date(r, v, q), get_latest_date(r, v, q)),
+    )
+
+    class Meta:
+        model = InstrumentPrice
+        fields = {
+            "volume": ["gte", "exact", "lte"],
+            "volume_50d": ["gte", "exact", "lte"],
+            # 'volume_200d': ['exact'],
+            "market_capitalization": ["gte", "exact", "lte"],
+            "instrument__instrument_type": ["exact"],
+        }
+
+
+class InstrumentPriceSingleBenchmarkFilterSet(InstrumentPriceFilterSet):
+    benchmark = wb_filters.ModelChoiceFilter(
+        label="Compare to..",
+        queryset=Instrument.objects.all(),
+        endpoint=Instrument.get_representation_endpoint(),
+        value_key=Instrument.get_representation_value_key(),
+        label_key=Instrument.get_representation_label_key(),
+        filter_params={"is_security": True},
+        method="fake_filter",
+    )
+
+    class Meta:
+        model = InstrumentPrice
+        fields = {}
+
+
+class InstrumentPriceMultipleBenchmarkChartFilterSet(InstrumentPriceFilterSet):
+    benchmarks = wb_filters.ModelMultipleChoiceFilter(
+        label="Benchmarks",
+        queryset=Instrument.objects.all(),
+        endpoint=Instrument.get_representation_endpoint(),
+        value_key=Instrument.get_representation_value_key(),
+        label_key=Instrument.get_representation_label_key(),
+        filter_params={"is_security": True},
+        method="fake_filter",
+    )
+    normalized = wb_filters.BooleanFilter(label="Normalize", default=True, method="fake_filter")
+
+    class Meta:
+        model = InstrumentPrice
+        fields = {}
+
+
+class InstrumentPriceFrequencyFilter(InstrumentPriceFilterSet):
+    class FrequencyChoice(models.TextChoices):
+        DAILY = "B", "Daily"
+        WEEKLY = "W-MON", "Weekly (Monday)"
+        MONTHLY = "BME", "Monthly"
+
+    frequency = wb_filters.ChoiceFilter(
+        label="Frequency", choices=FrequencyChoice.choices, default=FrequencyChoice.DAILY, method="fake_filter"
+    )
+
+    class Meta:
+        model = InstrumentPrice
+        fields = {}
+
+
+class InstrumentPriceFinancialStatisticsChartFilterSet(
+    InstrumentPriceSingleBenchmarkFilterSet, InstrumentPriceFrequencyFilter
+):
+    class Meta:
+        model = InstrumentPrice
+        fields = {}
+
+
+class InstrumentPriceInstrumentFilterSet(wb_filters.FilterSet):
+    class Meta:
+        model = InstrumentPrice
+        fields = {
+            "date": ["gte", "exact", "lte"],
+            "net_value": ["gte", "exact", "lte"],
+            "sharpe_ratio": ["gte", "exact", "lte"],
+            "correlation": ["gte", "exact", "lte"],
+            "beta": ["gte", "exact", "lte"],
+            "calculated": ["exact"],
+        }

wbfdm/filters/instruments.py

@@ -0,0 +1,198 @@
+from datetime import datetime
+
+from django.db.models import Q
+from psycopg.types.range import DateRange
+from wbcore import filters as wb_filters
+from wbcore.contrib.tags.filters import TagFilterMixin
+from wbfdm.filters.utils import get_earliest_date, get_latest_date
+from wbfdm.models.instruments import (
+    ClassificationGroup,
+    Instrument,
+    InstrumentClassificationThroughModel,
+    InstrumentFavoriteGroup,
+)
+from wbfdm.models.instruments.classifications import Classification
+from wbfdm.preferences import get_default_classification_group
+
+
+def get_default_favorite_group(field, request, view):
+    if favorite := InstrumentFavoriteGroup.objects.filter(owner=request.user.profile, primary=True).first():
+        return favorite.id
+    return None
+
+
+class InstrumentFavoriteGroupFilterSet(wb_filters.FilterSet):
+    favorite_group = wb_filters.ModelChoiceFilter(
+        label="Favorite Group",
+        queryset=InstrumentFavoriteGroup.objects.all(),
+        endpoint=InstrumentFavoriteGroup.get_representation_endpoint(),
+        value_key=InstrumentFavoriteGroup.get_representation_value_key(),
+        label_key=InstrumentFavoriteGroup.get_representation_label_key(),
+        default=get_default_favorite_group,
+        method="filter_favorite_group",
+    )
+
+    def filter_favorite_group(self, queryset, name, value):
+        if value:
+            return queryset.filter(id__in=value.instruments.values_list("id"))
+        return queryset
+
+    class Meta:
+        model = Instrument
+        fields = {}
+
+
+class InstrumentFilterSet(TagFilterMixin, InstrumentFavoriteGroupFilterSet):
+    parent = wb_filters.ModelChoiceFilter(
+        label="Parent",
+        queryset=Instrument.objects.all(),
+        endpoint=Instrument.get_representation_endpoint(),
+        value_key=Instrument.get_representation_value_key(),
+        label_key=Instrument.get_representation_label_key(),
+        hidden=True,
+    )
+
+    classifications = wb_filters.ModelChoiceFilter(
+        label="Classification",
+        queryset=Classification.objects.all(),
+        endpoint=Classification.get_representation_endpoint(),
+        value_key=Classification.get_representation_value_key(),
+        label_key=Classification.get_representation_label_key(),
+        method="filter_classification",
+    )
+
+    classifications_neq = wb_filters.ModelChoiceFilter(
+        label="Instrument not classified in..",
+        queryset=Classification.objects.all(),
+        endpoint=Classification.get_representation_endpoint(),
+        value_key=Classification.get_representation_value_key(),
+        label_key=Classification.get_representation_label_key(),
+        method="filter_classification",
+        hidden=True,
+    )
+
+    def filter_classification(self, queryset, name, value):
+        if value:
+            if name == "classifications":
+                return queryset.filter(classifications__in=value.get_descendants(include_self=True))
+            else:
+                return queryset.exclude(classifications__in=value.get_descendants(include_self=True))
+        return queryset
+
+    is_active = wb_filters.BooleanFilter(label="Only Active", method="filter_is_active")
+
+    def filter_is_active(self, queryset, name, value):
+        today = datetime.today()
+        if value is True:
+            return queryset.filter(
+                (Q(delisted_date__isnull=True) | Q(delisted_date__gte=today))
+                & Q(inception_date__isnull=False)
+                & Q(inception_date__lte=today)
+            )
+        return queryset
+
+    is_investable = wb_filters.BooleanFilter(
+        label="Is Investable", default=True, method="filter_is_investable", hidden=True
+    )
+
+    def filter_is_investable(self, queryset, name, value):
+        if value:
+            return queryset.filter(children__isnull=True)
+        return queryset
+
+    instrument_type__key = wb_filters.CharFilter(label="Instrument Type Key", hidden=True)
+    instrument_type__is_classifiable = wb_filters.BooleanFilter(label="Instrument Type Classifiable", hidden=True)
+
+    is_classifiable = wb_filters.BooleanFilter(label="Is Classifiable", method="filter_is_classifiable", hidden=True)
+
+    def filter_is_classifiable(self, queryset, name, value):
+        if value:
+            return queryset.filter(instrument_type__is_classifiable=True, level=0)
+        return queryset
+
+    # is_tree_in_investable_universe = wb_filters.BooleanFilter(label="Investable Universe", method="filter_is_tree_in_investable_universe", required=True)
+    # def filter_is_tree_in_investable_universe(self, queryset, name, value):
+    #     if value is not None:
+    #         return queryset.annotate(
+    #             is_tree_in_investable_universe=Exists(
+    #                 Instrument.objects.filter(
+    #                     tree_id=OuterRef("tree_id"),
+    #                     lft__gte=OuterRef("lft"),
+    #                     rght__lte=OuterRef("rght"),
+    #                     is_investable_universe=True
+    #                 )
+    #             )
+    #         ).filter(Q(is_tree_in_investable_universe=value))
+    #     return queryset
+    def __init__(self, data=None, *args, **kwargs):
+        if data:
+            data = data.dict()
+            if "parent" in data:
+                data.pop("classifications", None)  # remove classifications in case we are navigating the tree
+                data.pop("level", None)
+        super().__init__(data=data, *args, **kwargs)
+
+    class Meta:
+        model = Instrument
+        fields = {
+            "is_investable_universe": ["exact"],
+            "instrument_type": ["exact"],
+            "isin": ["exact"],
+            "ticker": ["exact"],
+            "currency": ["exact"],
+            # "related_instruments": ["exact"], # I don't think this filter is necessary
+            "country": ["exact"],
+            "exchange": ["exact"],
+            "id": ["in"],
+            "is_managed": ["exact"],
+            "is_security": ["exact"],
+            "is_primary": ["exact"],
+            "parent": ["exact", "isnull"],
+            "level": ["exact"],
+        }
+        hidden_fields = ["id__in", "is_managed", "is_security", "level"]
+
+
+def _get_default_classification_group_id(*args, **kwargs):
+    if group := get_default_classification_group():
+        return group.id
+    return None
+
+
+class BaseClassifiedInstrumentFilterSet(TagFilterMixin, wb_filters.FilterSet):
+    classification_group = wb_filters.ModelChoiceFilter(
+        label="Classification Group",
+        queryset=ClassificationGroup.objects.all(),
+        endpoint=ClassificationGroup.get_representation_endpoint(),
+        value_key=ClassificationGroup.get_representation_value_key(),
+        label_key=ClassificationGroup.get_representation_label_key(),
+        default=_get_default_classification_group_id(),
+        method="fake_filter",
+        required=True,
+    )
+
+    def query_classification(self, queryset, name, value):
+        if value:
+            return queryset.filter(**{name.replace("_", "__"): value.id})
+        return queryset
+
+    class Meta:
+        model = InstrumentClassificationThroughModel
+        fields = {
+            "instrument": ["exact"],
+            "is_favorite": ["exact"],
+        }
+
+
+class MonthlyPerformancesInstrumentFilterSet(wb_filters.FilterSet):
+    period = wb_filters.FinancialPerformanceDateRangeFilter(
+        label="Period",
+        required=True,
+        clearable=False,
+        method="fake_filter",
+        default=lambda r, v, q: DateRange(get_earliest_date(r, v, q), get_latest_date(r, v, q)),
+    )
+
+    class Meta:
+        model = Instrument
+        fields = {}