wbfdm 2.2.1__py2.py3-none-any.whl

wbfdm/viewsets/instruments/instruments.py

@@ -0,0 +1,106 @@
+from django.db.models import Case, Exists, F, IntegerField, OuterRef, When
+from rest_framework.filters import OrderingFilter
+from wbcore import viewsets
+from wbcore.contrib.guardian.filters import ObjectPermissionsFilter
+from wbcore.viewsets.mixins import DjangoFilterBackend
+from wbfdm.contrib.metric.backends.performances import PERFORMANCE_METRIC
+from wbfdm.contrib.metric.backends.statistics import STATISTICS_METRIC
+from wbfdm.contrib.metric.viewsets.mixins import InstrumentMetricMixin
+from wbfdm.filters import InstrumentFilterSet
+from wbfdm.import_export.resources.instruments import InstrumentResource
+from wbfdm.models import Instrument, InstrumentType
+from wbfdm.serializers import (
+    InstrumentModelListSerializer,
+    InstrumentModelSerializer,
+    InstrumentRepresentationSerializer,
+    InstrumentTypeRepresentationSerializer,
+)
+
+from ..configs import (
+    ChildrenInstrumentModelViewConfig,
+    InstrumentButtonViewConfig,
+    InstrumentDisplayConfig,
+    InstrumentEndpointConfig,
+    InstrumentTitleConfig,
+)
+from ..mixins import InstrumentMixin
+from .utils import InstrumentSearchFilter
+
+
+class InstrumentTypeRepresentationViewSet(viewsets.RepresentationViewSet):
+    queryset = InstrumentType.objects.all()
+    serializer_class = InstrumentTypeRepresentationSerializer
+    search_fields = ("name", "key")
+
+
+class InstrumentRepresentationViewSet(viewsets.RepresentationViewSet):
+    filter_backends = (InstrumentSearchFilter, ObjectPermissionsFilter, DjangoFilterBackend, OrderingFilter)
+
+    queryset = Instrument.objects.annotate_base_data().exclude(name="")
+    serializer_class = InstrumentRepresentationSerializer
+    search_fields = ("name", "name_repr", "isin", "ticker")
+
+    filterset_class = InstrumentFilterSet
+    ordering_fields = ("title", "ticker")
+    ordering = ["-search_rank"]
+
+
+class InstrumentModelViewSet(InstrumentMetricMixin, viewsets.ModelViewSet):
+    METRIC_KEYS = (PERFORMANCE_METRIC, STATISTICS_METRIC)
+    METRIC_SHOW_AGGREGATES = False
+    filter_backends = (InstrumentSearchFilter, ObjectPermissionsFilter, DjangoFilterBackend, OrderingFilter)
+
+    queryset = Instrument.objects.annotate_all()
+    serializer_class = InstrumentModelListSerializer
+    ordering_fields = (
+        "instrument_type",
+        "name_repr",
+        "ticker",
+        "isin",
+        "country__name",
+        "currency__key",
+    )
+    search_fields = (
+        "name_repr",
+        "name",
+        "isin",
+        "ticker",
+        "computed_str",
+        "refinitiv_identifier_code",
+        "refinitiv_mnemonic_code",
+    )
+    ordering = ["-search_rank"]
+
+    def get_serializer_class(self):
+        if self.get_action() in ["list", "list-metadata"]:
+            return InstrumentModelListSerializer
+        return InstrumentModelSerializer
+
+    display_config_class = InstrumentDisplayConfig
+    title_config_class = InstrumentTitleConfig
+    button_config_class = InstrumentButtonViewConfig
+    endpoint_config_class = InstrumentEndpointConfig
+    filterset_class = InstrumentFilterSet
+
+    def get_resource_class(self):
+        return InstrumentResource
+
+    def get_queryset(self):
+        qs = (
+            super()
+            .get_queryset()
+            .select_related("currency", "country", "instrument_type", "parent", "exchange")
+            .prefetch_related("tags", "classifications")
+        ).annotate(
+            has_children=Exists(Instrument.objects.filter(parent=OuterRef("pk"))),
+            _group_key=Case(When(has_children=True, then=F("id")), default=None, output_field=IntegerField()),
+            currency_symbol=F("currency__symbol"),
+        )
+        return qs
+
+
+class ChildrenInstrumentModelViewSet(InstrumentMixin, InstrumentModelViewSet):
+    button_config_class = ChildrenInstrumentModelViewConfig
+
+    def get_queryset(self):
+        return super().get_queryset().filter(parent=self.instrument)

wbfdm/viewsets/instruments/instruments_relationships.py

@@ -0,0 +1,235 @@
+from django.db.models import Prefetch, Q
+from django.db.models.expressions import F
+from django.db.models.query import QuerySet
+from django.utils.functional import cached_property
+from rest_framework import filters
+from wbcore import filters as wb_filters
+from wbcore import serializers as wb_serializers
+from wbcore import viewsets
+from wbcore.contrib.tags.serializers import TagSerializerMixin
+from wbcore.permissions.permissions import InternalUserPermissionMixin
+from wbfdm.filters.instruments import BaseClassifiedInstrumentFilterSet
+from wbfdm.models import (
+    Classification,
+    ClassificationGroup,
+    Instrument,
+    InstrumentFavoriteGroup,
+    RelatedInstrumentThroughModel,
+)
+from wbfdm.models.instruments import (
+    InstrumentClassificationRelatedInstrument,
+    InstrumentClassificationThroughModel,
+)
+from wbfdm.preferences import get_default_classification_group
+from wbfdm.serializers import (
+    ClassifiableInstrumentRepresentationSerializer,
+    ClassificationRepresentationSerializer,
+    InstrumentClassificationRelatedInstrumentModelSerializer,
+    InstrumentClassificationRelatedInstrumentRepresentationSerializer,
+    InstrumentFavoriteGroupModelSerializer,
+    InstrumentFavoriteGroupRepresentationSerializer,
+    RelatedInstrumentThroughInstrumentModelSerializer,
+)
+from wbfdm.viewsets.configs.display import ClassifiedInstrumentDisplayConfig
+from wbfdm.viewsets.configs.titles import ClassifiedInstrumentTitleConfig
+
+from ..configs import (
+    ClassificationInstrumentRelatedInstrumentDisplayConfig,
+    ClassificationInstrumentRelatedInstrumentEndpointConfig,
+    ClassifiedInstrumentEndpointConfig,
+    InstrumentFavoriteGroupDisplayConfig,
+    InstrumentFavoriteGroupTitleConfig,
+    RelatedInstrumentThroughInstrumentDisplayConfig,
+    RelatedInstrumentThroughInstrumentEndpointConfig,
+)
+from ..mixins import InstrumentMixin
+
+
+class InstrumentClassificationRelatedInstrumentRepresentationViewSet(viewsets.RepresentationViewSet):
+    queryset = InstrumentClassificationRelatedInstrument.objects.all()
+    serializer_class = InstrumentClassificationRelatedInstrumentRepresentationSerializer
+
+    def get_queryset(self):
+        queryset = super().get_queryset()
+        if pk := self.kwargs.get("classified_instrument_id", None):
+            queryset = queryset.filter(classified_instrument_id=pk)
+        return queryset
+
+
+class InstrumentClassificationRelatedInstrumentModelViewSet(viewsets.ModelViewSet):
+    queryset = InstrumentClassificationRelatedInstrument.objects.all()
+    serializer_class = InstrumentClassificationRelatedInstrumentModelSerializer
+    display_config_class = ClassificationInstrumentRelatedInstrumentDisplayConfig
+    endpoint_config_class = ClassificationInstrumentRelatedInstrumentEndpointConfig
+
+    def get_queryset(self):
+        queryset = super().get_queryset()
+        if pk := self.kwargs.get("classified_instrument_id", None):
+            queryset = queryset.filter(classified_instrument_id=pk)
+        return queryset
+
+
+class InstrumentFavoriteGroupRepresentationViewSet(InternalUserPermissionMixin, viewsets.RepresentationViewSet):
+    IDENTIFIER = "wbfdm:favoritegroup"
+    filter_backends = (filters.OrderingFilter, filters.SearchFilter)
+    ordering_fields = ordering = ("name",)
+    search_fields = ("name", "instruments__name", "owner__computed_str")
+    queryset = InstrumentFavoriteGroup.objects.all()
+    serializer_class = InstrumentFavoriteGroupRepresentationSerializer
+
+
+class InstrumentFavoriteGroupModelViewSet(InternalUserPermissionMixin, viewsets.ModelViewSet):
+    queryset = InstrumentFavoriteGroup.objects.all()
+    serializer_class = InstrumentFavoriteGroupModelSerializer
+
+    ordering_fields = ("name", "owner__computed_str", "public")
+    ordering = ("name",)
+    search_fields = ("name", "instruments__name", "owner__computed_str")
+
+    filterset_fields = {"instruments": ["exact"], "owner": ["exact"], "public": ["exact"]}
+
+    display_config_class = InstrumentFavoriteGroupDisplayConfig
+    title_config_class = InstrumentFavoriteGroupTitleConfig
+
+    def get_queryset(self):
+        qs = InstrumentFavoriteGroup.objects.all()
+        if not self.request.user.is_superuser:
+            qs = qs.filter(Q(owner=self.request.user.profile) | Q(public=True))
+        return qs.select_related("owner").prefetch_related(
+            Prefetch("instruments", queryset=Instrument.objects.filter(favorite_groups__isnull=False).distinct())
+        )
+
+
+class RelatedInstrumentThroughInstrumentModelViewSet(
+    InstrumentMixin, InternalUserPermissionMixin, viewsets.ModelViewSet
+):
+    serializer_class = RelatedInstrumentThroughInstrumentModelSerializer
+    queryset = RelatedInstrumentThroughModel.objects.select_related(
+        "related_instrument",
+        "instrument",
+    )
+
+    search_fields = ("related_instrument__computed_str",)
+    ordering_fields = ["is_primary"]
+    ordering = ["-is_primary"]
+
+    filterset_fields = {"is_primary": ["exact"], "related_instrument": ["exact"], "related_type": ["exact"]}
+    display_config_class = RelatedInstrumentThroughInstrumentDisplayConfig
+    endpoint_config_class = RelatedInstrumentThroughInstrumentEndpointConfig
+
+    def get_queryset(self):
+        return super().get_queryset().filter(instrument=self.instrument)
+
+
+class ClassifiedInstrumentModelViewSet(InternalUserPermissionMixin, viewsets.ModelViewSet):
+    queryset = InstrumentClassificationThroughModel.objects.all()
+    display_config_class = ClassifiedInstrumentDisplayConfig
+    title_config_class = ClassifiedInstrumentTitleConfig
+    endpoint_config_class = ClassifiedInstrumentEndpointConfig
+
+    search_fields = ("instrument__computed_str",)
+
+    def get_ordering_fields(self) -> list[str]:
+        ordering_fields = ["instrument"]
+        for field_name in self.classification_group.get_fields_names(sep="_"):
+            ordering_fields.append(f"classification_{field_name}")
+        return ordering_fields
+
+    def get_serializer_class(self):
+        """
+        Unwrap defined serializer class and inject the metric fields into a new class
+        """
+
+        group = self.classification_group
+
+        attrs = dict()
+        serializer_fields = [
+            "id",
+            "instrument",
+            "_instrument",
+            "classification",
+            "_classification",
+            "is_favorite",
+            "tags",
+            "_tags",
+        ]
+        for field_name in group.get_fields_names(sep="_"):
+            base_field_name = f"classification_{field_name}"
+            # representation_field_name = f"_classification_{field_name}"
+            attrs[base_field_name] = wb_serializers.CharField(read_only=True)
+            serializer_fields.append(base_field_name)
+
+        class BaseClassifiedInstrumentModelSerializer(TagSerializerMixin, wb_serializers.ModelSerializer):
+            _instrument = ClassifiableInstrumentRepresentationSerializer(source="instrument")
+            _classification = ClassificationRepresentationSerializer(source="classification", label_key="{{name}}")
+
+            class Meta:
+                model = InstrumentClassificationThroughModel
+                fields = read_only_fields = serializer_fields
+
+        serializer_class = type(
+            "ClassifiedInstrumentModelSerializer", (BaseClassifiedInstrumentModelSerializer,), attrs
+        )
+
+        return serializer_class
+
+    def get_filterset_class(self, request):
+        group = self.classification_group
+
+        attrs = {
+            "classification": wb_filters.ModelChoiceFilter(
+                label="Height 0",
+                queryset=Classification.objects.filter(group=group, height=0),
+                endpoint=Classification.get_representation_endpoint(),
+                filter_params={"height": 0, "group": group.id},
+                value_key=Classification.get_representation_value_key(),
+                label_key="{{name}}",
+            )
+        }
+        for index, field_name in enumerate(group.get_fields_names(sep="_"), start=1):
+            attrs[f"classification_{field_name}"] = wb_filters.ModelChoiceFilter(
+                label=f"Height {index}",
+                queryset=Classification.objects.filter(group=group, height=index),
+                endpoint=Classification.get_representation_endpoint(),
+                filter_params={"height": index, "group": group.id},
+                value_key=Classification.get_representation_value_key(),
+                method="query_classification",
+                label_key="{{name}}",
+            )
+        filter_class = type("ClassifiedInstrumentFilterSet", (BaseClassifiedInstrumentFilterSet,), attrs)
+
+        def _get_filter_class_for_remote_filter(cls):
+            """
+            Define which filterset class sender to user for remote filter registration
+            """
+            return BaseClassifiedInstrumentFilterSet
+
+        filter_class.get_filter_class_for_remote_filter = classmethod(_get_filter_class_for_remote_filter)
+        return filter_class
+
+    @cached_property
+    def classification_group(self):
+        try:
+            return ClassificationGroup.objects.get(id=self.request.GET.get("classification_group"))
+        except ClassificationGroup.DoesNotExist:
+            return get_default_classification_group()
+
+    def get_queryset(self) -> QuerySet[InstrumentClassificationThroughModel]:
+        return (
+            super()
+            .get_queryset()
+            .filter(classification__group=self.classification_group)
+            .annotate(
+                **{
+                    f"classification_{field_name}".replace("__", "_"): F(f"classification__{field_name}__name")
+                    for field_name in self.classification_group.get_fields_names()
+                }
+            )
+            .select_related(
+                *[f"classification__{field_name}" for field_name in self.classification_group.get_fields_names()]
+            )
+            .prefetch_related(
+                "tags",
+                Prefetch("instrument", queryset=Instrument.objects.filter(classifications_through__isnull=False)),
+            )
+        )

wbfdm/viewsets/instruments/utils.py

@@ -0,0 +1,27 @@
+from django.contrib.postgres.search import SearchQuery, SearchRank
+from django.db.models import F, Q
+from django.db.models.expressions import Value
+from django.db.models.functions import Coalesce
+
+
+class InstrumentSearchFilter:
+    def get_min_search_rank(self, view) -> float:
+        return getattr(view, "SEARCH_MIN_RANK", 0.3)
+
+    def filter_queryset(self, request, queryset, view):
+        if search := request.GET.get("search", None):
+            min_search_rank = self.get_min_search_rank(view)
+            query = SearchQuery(search, search_type="phrase")
+            queryset = (
+                queryset.annotate(search_rank=Coalesce(SearchRank(F("search_vector"), query), Value(-1.0)))
+                .filter(
+                    (Q(search_vector=query) & Q(search_rank__gte=min_search_rank))
+                    | Q(name__icontains=search)
+                    | Q(name_repr__icontains=search)
+                    | Q(isin__icontains=search)
+                )
+                .order_by("-search_rank")
+            ).distinct()
+        else:
+            queryset = queryset.annotate(search_rank=Value(-1.0))
+        return queryset

wbfdm/viewsets/market_data.py

@@ -0,0 +1,172 @@
+from contextlib import suppress
+from datetime import date
+from itertools import cycle
+
+import plotly.express as px
+from django.utils.functional import cached_property
+from plotly import graph_objects as go
+from plotly.subplots import make_subplots
+from wbcore import viewsets
+from wbcore.utils.date import get_date_interval_from_request
+from wbfdm.enums import Indicator, MarketDataChartType
+from wbfdm.filters import MarketDataChartFilterSet
+from wbfdm.models.instruments import Instrument
+
+from .configs import MarketDataChartTitleConfig, PerformanceSummaryChartTitleConfig
+from .mixins import InstrumentMixin
+
+
+class PerformanceSummaryChartViewSet(InstrumentMixin, viewsets.ChartViewSet):
+    queryset = Instrument.objects.all()
+    title_config_class = PerformanceSummaryChartTitleConfig
+
+    def get_queryset(self):
+        return super().get_queryset().filter(id=self.instrument.id)
+
+    def get_plotly(self, queryset):
+        today = date.today()
+        trace_factory = (
+            queryset.first().technical_analysis(from_date=today.replace(year=today.year - 4)).trace_factory()
+        )
+
+        fig = go.Figure()
+        for trace in trace_factory.performance_summary_trace(bar_options={"color": px.colors.qualitative.T10[0]}):
+            fig.add_trace(trace)
+        fig.update_layout(
+            template="plotly_white",
+            yaxis_tickformat="%",
+        )
+        return fig
+
+
+class MarketDataChartViewSet(InstrumentMixin, viewsets.ChartViewSet):
+    queryset = Instrument.objects.all()
+    filterset_class = MarketDataChartFilterSet
+    title_config_class = MarketDataChartTitleConfig
+
+    CHART_MAPPING = {
+        MarketDataChartType.CLOSE: "close_trace",
+        MarketDataChartType.RETURN: "return_trace",
+        MarketDataChartType.LOG_RETURN: "log_return_trace",
+        MarketDataChartType.DRAWDOWN: "drawdown_trace",
+        MarketDataChartType.CANDLESTICK: "candlestick_trace",
+        MarketDataChartType.OHLC: "ohlc_trace",
+    }
+    BENCHMARK_CHART_MAPPING = {
+        MarketDataChartType.CLOSE: "close_trace",
+        MarketDataChartType.RETURN: "return_trace",
+        MarketDataChartType.LOG_RETURN: "log_return_trace",
+        MarketDataChartType.DRAWDOWN: "drawdown_trace",
+        MarketDataChartType.CANDLESTICK: "close_trace",
+        MarketDataChartType.OHLC: "close_trace",
+    }
+    STATISTIC_MAPPING = {
+        MarketDataChartType.CLOSE: "close",
+        MarketDataChartType.RETURN: "cum-ret",
+        MarketDataChartType.LOG_RETURN: "cum-log-ret",
+        MarketDataChartType.DRAWDOWN: "drawdown",
+        MarketDataChartType.CANDLESTICK: "close",
+        MarketDataChartType.OHLC: "close",
+    }
+    INDICATOR_MAPPING = {
+        Indicator.SMA_50: 50,
+        Indicator.SMA_100: 100,
+        Indicator.SMA_120: 120,
+        Indicator.SMA_200: 200,
+    }
+
+    def get_queryset(self):
+        return super().get_queryset().filter(id=self.instrument.id)
+
+    def get_benchmark_queryset(self):
+        return Instrument.objects.filter(id__in=self.benchmarks_ids)
+
+    @cached_property
+    def benchmarks_ids(self) -> list[int]:
+        if benchmarks_str := self.request.GET.get("benchmarks", None):
+            return benchmarks_str.split(",")
+        return []
+
+    def get_parameters(self) -> list:
+        return self.request.GET.get("parameters", "").split(";")
+
+    def get_plotly(self, queryset):
+        # Parametrization
+        chart_type = MarketDataChartType(self.request.GET.get("chart_type", "close"))
+        volume = self.request.GET.get("volume", "false") == "true"
+        show_estimates = self.request.GET.get("show_estimates", "false") == "true"
+        from_date, to_date = get_date_interval_from_request(self.request, date_range_fieldname="period")
+        colors = cycle(px.colors.qualitative.T10)
+
+        # Bootstrap chart
+        fig = make_subplots(
+            rows=2 if volume else 1,
+            cols=1,
+            shared_xaxes=True,
+            vertical_spacing=0.03,
+            row_width=[0.2, 0.7] if volume else [1],
+        )
+
+        # Generate Chart for main timeseries
+        ta = queryset.first().technical_analysis(from_date, to_date)
+        factory = ta.trace_factory()
+        for trace in getattr(factory, self.CHART_MAPPING[chart_type])(
+            line_options=dict(color=next(colors)), show_estimates=show_estimates
+        ):
+            fig.add_trace(trace)
+
+        # Generate Charts for all added benchmarks
+        for benchmark in self.get_benchmark_queryset():
+            _factory = benchmark.technical_benchmark_analysis(ta.df.index.min(), to_date).trace_factory()
+            for trace in getattr(_factory, self.BENCHMARK_CHART_MAPPING[chart_type])(
+                base_series=ta.df[self.STATISTIC_MAPPING[chart_type]],
+                line_options=dict(color=next(colors)),
+            ):
+                fig.add_trace(trace)
+
+        # Generate Charts for any selected indicators
+        if indicators := self.request.GET.get("indicators", None):
+            for indicator in indicators.split(","):
+                for trace in factory.sma_trace(
+                    self.INDICATOR_MAPPING[Indicator(indicator)], line_options=dict(color=next(colors))
+                ):
+                    fig.add_trace(trace)
+
+        if volume:
+            fig.add_trace(
+                factory.volume_trace(),
+                row=2,
+                col=1,
+            )
+
+        fig.update_layout(
+            template="plotly_white",
+            legend=dict(x=0.02, y=0.98, bgcolor="rgba(0,0,0,0)"),
+            margin=dict(l=0, r=0, t=0, b=40),
+            xaxis_rangeslider_visible=False,
+            showlegend=True,
+            hovermode="x",
+        )
+        fig.update_xaxes(rangebreaks=[{"pattern": "day of week", "bounds": [6, 1]}])
+
+        for i, d in enumerate(fig.data):
+            with suppress(AttributeError, IndexError, ValueError):  # Either Candlestick or OHCL
+                if (y := d.y[-1]) is not None:
+                    text_value = (
+                        f"{y:.2%}"
+                        if chart_type in [MarketDataChartType.RETURN, MarketDataChartType.LOG_RETURN]
+                        else f"{y:.1f}"
+                    )
+                    fig.add_scatter(
+                        x=[d.x[-1]],
+                        y=[y],
+                        name=d.name,
+                        mode="markers+text",
+                        text=text_value,
+                        textfont=dict(color=d.line.color),
+                        textposition="middle right",
+                        marker=dict(color=d.line.color, size=12, symbol="circle"),
+                        legendgroup=d.name,
+                        showlegend=False,
+                    )
+        return fig

wbfdm/viewsets/mixins.py

@@ -0,0 +1,9 @@
+from django.utils.functional import cached_property
+from rest_framework.generics import get_object_or_404
+from wbfdm.models import Instrument
+
+
+class InstrumentMixin:
+    @cached_property
+    def instrument(self) -> Instrument:
+        return get_object_or_404(Instrument, pk=self.kwargs["instrument_id"])

wbfdm/viewsets/officers.py

@@ -0,0 +1,27 @@
+from rest_framework.response import Response
+from wbcore import viewsets
+from wbfdm.models.instruments import Instrument
+from wbfdm.serializers import OfficerSerializer
+from wbfdm.viewsets.configs.display.officers import OfficerDisplayViewConfig
+from wbfdm.viewsets.configs.titles.instruments import SubviewInstrumentTitleViewConfig
+
+from .mixins import InstrumentMixin
+
+
+class OfficerViewSet(InstrumentMixin, viewsets.ViewSet):
+    IDENTIFIER = "wbfdm:instrument-officers"
+    SUBVIEW_NAME = "Officers"
+    display_config_class = OfficerDisplayViewConfig
+    title_config_class = SubviewInstrumentTitleViewConfig
+    serializer_class = OfficerSerializer
+    permission_classes = []
+
+    def list(self, request, instrument_id):
+        queryset = self.get_queryset()
+        serializer = self.get_serializer_class()
+        serializer = serializer(queryset, many=True)
+        return Response({"results": serializer.data})
+
+    def get_queryset(self):
+        queryset = Instrument.objects.filter(id=self.instrument.id)
+        return queryset.dl.officers()

wbfdm/viewsets/prices.py

@@ -0,0 +1,62 @@
+from datetime import date, timedelta
+
+import pandas as pd
+from wbcore.contrib.io.viewsets import ExportPandasAPIViewSet
+from wbcore.pandas import fields as pf
+from wbcore.serializers.fields.types import DisplayMode
+from wbcore.utils.date import get_date_interval_from_request
+from wbfdm.filters.instrument_prices import FakeDateRange
+from wbfdm.models.instruments import Instrument
+from wbfdm.viewsets.configs.display.prices import InstrumentPriceDisplayConfig
+from wbfdm.viewsets.configs.titles.prices import InstrumentPriceTitleViewConfig
+
+from .mixins import InstrumentMixin
+
+
+class InstrumentPriceViewSet(InstrumentMixin, ExportPandasAPIViewSet):
+    IDENTIFIER = "wbfdm:instrument-price"
+    display_config_class = InstrumentPriceDisplayConfig
+    title_config_class = InstrumentPriceTitleViewConfig
+    pandas_fields = pf.PandasFields(
+        fields=(
+            pf.PKField(key="id", label="ID"),
+            pf.DateField(
+                key="valuation_date",
+                label="valuation_date",
+            ),
+            pf.FloatField(key="open", label="open"),
+            pf.FloatField(key="high", label="high"),
+            pf.FloatField(key="low", label="low"),
+            pf.FloatField(key="close", label="close"),
+            pf.FloatField(key="volume", label="volume", display_mode=DisplayMode.SHORTENED),
+            pf.FloatField(key="outstanding_shares", label="outstanding_shares", display_mode=DisplayMode.SHORTENED),
+            pf.FloatField(
+                key="market_capitalization", label="market_capitalization", display_mode=DisplayMode.SHORTENED
+            ),
+        )
+    )
+    permission_classes = []
+    filterset_class = FakeDateRange
+    queryset = Instrument.objects.all()
+    ordering_fields = (
+        "valuation_date",
+        "open",
+        "high",
+        "low",
+        "close",
+        "volume",
+        "outstanding_shares",
+        "market_capitalization",
+    )
+    ordering = ["-valuation_date"]
+
+    def get_queryset(self):
+        return Instrument.objects.filter(id=self.instrument.id)
+
+    def get_dataframe(self, request, queryset, **kwargs):
+        start, end = get_date_interval_from_request(request, date_range_fieldname="date")
+        if not end:
+            end = date.today()
+        if not start:
+            start = end - timedelta(days=365)
+        return pd.DataFrame(queryset.dl.market_data(from_date=start, to_date=end))

wbfdm/viewsets/statements/__init__.py

@@ -0,0 +1 @@
+from .statements import StatementPandasViewSet