wbfdm 2.2.1__py2.py3-none-any.whl

wbfdm/tests/models/test_instruments.py

@@ -0,0 +1,202 @@
+import calendar
+from datetime import date, timedelta
+from decimal import Decimal
+from unittest.mock import patch
+
+import numpy as np
+import pandas as pd
+import pytest
+from faker import Faker
+from pandas.tseries.offsets import BDay
+from wbfdm.dataloaders.proxies import InstrumentDataloaderProxy
+from wbfdm.factories.instrument_prices import InstrumentPrice
+from wbfdm.models import Instrument, RelatedInstrumentThroughModel
+
+fake = Faker()
+
+
+@pytest.mark.django_db
+class TestInstrumentModel:
+    def test_init(self, instrument):
+        assert instrument.id is not None
+
+    def test_get_prices(self, instrument_factory, instrument_price_factory):
+        instrument = instrument_factory.create()
+        other_instrument = instrument_factory.create()
+        price = instrument_price_factory.create(instrument=instrument, outstanding_shares=100)
+        price.refresh_from_db()
+        instrument_price_factory.create(instrument=other_instrument)  # Noise
+        res = list(instrument.get_prices())
+        assert len(res) == 1
+        assert res[0]["valuation_date"] == price.date
+        assert res[0]["open"] == float(price.net_value)
+        assert res[0]["close"] == float(price.net_value)
+        assert res[0]["high"] == float(price.net_value)
+        assert res[0]["low"] == float(price.net_value)
+        assert res[0]["volume"] == price.volume
+        assert res[0]["market_capitalization"] == price.market_capitalization
+        assert res[0]["outstanding_shares"] == float(price.outstanding_shares)
+
+    def test_get_price(self, instrument_factory, instrument_price_factory):
+        instrument = instrument_factory.create()
+        other_instrument = instrument_factory.create()
+        price = instrument_price_factory.create(instrument=instrument)
+        price.refresh_from_db()
+        instrument_price_factory.create(instrument=other_instrument)  # Noise
+        assert instrument.get_price(price.date) == float(price.net_value)
+        assert instrument.get_price((price.date + BDay(1)).date()) == float(price.net_value)
+        assert instrument.get_price((price.date + BDay(2)).date()) == float(price.net_value)
+        assert instrument.get_price((price.date + BDay(3)).date()) == float(price.net_value)
+        with pytest.raises(ValueError):
+            instrument.get_price((price.date + BDay(4)).date())  # for return the latest valid price 3 days earlier.
+
+        # if the instrument is considered cash, we always return a value of 1
+        instrument.is_cash = True
+        instrument.save()
+        assert instrument.get_price(price.date) == Decimal(1)
+
+    def test_extract_daily_performance_df(self):
+        tidx = pd.date_range("2016-07-01", periods=4, freq="B")
+        data = np.random.randn(4)
+        df = pd.Series(data, index=tidx, name="close")
+        res = Instrument.extract_daily_performance_df(df)
+        assert res.performance[0] == df[1] / df[0] - 1
+
+    def test_extract_monthly_performance_df(self):
+        tidx = pd.date_range("2016-07-01", periods=4, freq="ME")
+        data = np.random.randn(4)
+        df = pd.Series(data, index=tidx, name="close")
+        df.index = pd.to_datetime(df.index)
+        res = Instrument.extract_monthly_performance_df(df)
+        assert res.performance[0] == df[1] / df[0] - 1
+
+    def test_extract_inception_performance_df(self):
+        tidx = pd.date_range("2016-07-01", periods=4, freq="D")
+        data = np.random.randn(4)
+        df = pd.Series(data, index=tidx, name="close")
+        res = Instrument.extract_inception_performance_df(df)
+
+        assert res == df[3] / df[0] - 1
+
+    def test_extract_annual_performance_df(self):
+        tidx = pd.date_range("2016-07-01", periods=4, freq="BYE")
+        data = np.random.randn(4)
+        df = pd.Series(data, index=tidx, name="close")
+        res = Instrument.extract_annual_performance_df(df)
+
+        assert res.performance[0] == df[1] / df[0] - 1
+
+    def test_get_monthly_return_summary(self, instrument, instrument_price_factory):
+        instrument_price_factory.create_batch(10, instrument=instrument)
+        res, _ = instrument.get_monthly_return_summary()
+        assert "performance" in res.columns
+        assert "month" in res.columns
+        assert "year" in res.columns
+
+    def test_get_monthly_return_summary_dict(self, instrument, instrument_price_factory):
+        instrument_price_factory.create_batch(10, instrument=instrument)
+        res = instrument.get_monthly_return_summary_dict()
+        for year in res.keys():
+            for month in res[year].keys():
+                assert month in calendar.month_abbr or month == "annual"
+                assert "performance" in res[year][month]
+
+    def test_get_prices_df(self, instrument, instrument_price_factory):
+        price = instrument_price_factory.create(instrument=instrument)
+        previous_price = instrument_price_factory.create(  # noqa
+            date=price.date - timedelta(days=1), instrument=instrument
+        )
+        assert instrument.get_prices_df(from_date=price.date)[0] == float(price.net_value)
+
+    @patch.object(Instrument, "get_prices_df")
+    def test_build_benchmark_df(self, mock_get_prices_df, instrument, instrument_factory, instrument_price_factory):
+        instrument_price_factory.create_batch(5, instrument=instrument)
+        start_val = InstrumentPrice.objects.earliest("date").date
+        end_val = InstrumentPrice.objects.latest("date").date
+        tidx = pd.date_range(start=start_val, end=end_val, freq="D")
+        mock_data = pd.Series(data=np.random.random_sample((tidx.shape[0],)), index=tidx)
+        mock_get_prices_df.return_value = mock_data
+
+        # Test without risk or benchmark assigned to instrument
+        res = instrument.build_benchmark_df(end_val)
+        assert res.empty
+
+        # Assign benchmark and risk instrument
+        RelatedInstrumentThroughModel.objects.create(
+            instrument=instrument,
+            related_instrument=instrument_factory.create(),
+            is_primary=True,
+            related_type=RelatedInstrumentThroughModel.RelatedTypeChoices.BENCHMARK,
+        )
+        RelatedInstrumentThroughModel.objects.create(
+            instrument=instrument,
+            is_primary=True,
+            related_instrument=instrument_factory.create(),
+            related_type=RelatedInstrumentThroughModel.RelatedTypeChoices.RISK_INSTRUMENT,
+        )
+        instrument.refresh_from_db()
+        res = instrument.build_benchmark_df(end_val)
+        assert res.rate.equals(mock_data)
+        assert res.benchmark_net_value.equals(mock_data)
+        assert "net_value" in res.columns
+
+    @patch.object(InstrumentDataloaderProxy, "market_data")
+    def test_save_prices_in_db(self, mock_fct, instrument, instrument_price_factory, currency_fx_rates_factory):
+        # we check that the import also handle missing data with a forward fill
+        from_date = date(2024, 1, 1)
+        to_date = date(2024, 1, 3)
+        currency_fx_rates_factory.create(currency=instrument.currency, date=from_date)
+        currency_fx_rates_factory.create(currency=instrument.currency, date=from_date + timedelta(days=1))
+        currency_fx_rates_factory.create(currency=instrument.currency, date=to_date)
+        mock_fct.return_value = [
+            {
+                "valuation_date": from_date,
+                "close": 1,
+                "volume": 1,
+                "market_capitalization": 1,
+            },
+            {
+                "valuation_date": to_date,
+                "close": 2,
+                "volume": 2,
+                "market_capitalization": 2,
+            },
+        ]
+        instrument.save_prices_in_db(from_date, to_date + timedelta(days=1))
+        assert InstrumentPrice.objects.get(
+            instrument=instrument, date=from_date, calculated=False
+        ).net_value == Decimal(1)
+        assert InstrumentPrice.objects.get(
+            instrument=instrument, date=from_date + timedelta(days=1), calculated=True
+        ).net_value == Decimal(1)
+        assert InstrumentPrice.objects.get(instrument=instrument, date=to_date, calculated=False).net_value == Decimal(
+            2
+        )
+
+    def test_security_instrument_type(self, instrument_factory, instrument_type_factory):
+        company_type = instrument_type_factory.create(is_security=False)
+        security_type = instrument_type_factory.create(is_security=True)
+        quote_type = instrument_type_factory.create(is_security=False)
+
+        company = instrument_factory.create(instrument_type=company_type)
+        security = instrument_factory.create(instrument_type=security_type, parent=company)
+        quote = instrument_factory.create(instrument_type=quote_type, parent=security)
+
+        assert company.security_instrument_type == company_type
+        assert security.security_instrument_type == security_type
+        assert quote.security_instrument_type == security_type
+
+    def test_pre_save(self, instrument, instrument_factory):
+        parent = instrument_factory.create()
+        instrument.parent = parent
+        instrument.save()
+
+        instrument.name_repr = "test"
+        instrument.save()
+        parent.refresh_from_db()
+        assert parent.name_repr == "test"
+
+        parent.name_repr = "test2"
+        parent.save()
+        instrument.refresh_from_db()
+        assert instrument.name_repr == "test2"

wbfdm/tests/models/test_merge.py

@@ -0,0 +1,99 @@
+import pytest
+from faker import Faker
+from wbfdm.factories.instruments import InstrumentFactory
+from wbfdm.models import (
+    Instrument,
+    InstrumentClassificationThroughModel,
+    RelatedInstrumentThroughModel,
+)
+
+fake = Faker()
+
+
+@pytest.mark.django_db
+class TestMergeInstrument:
+    @pytest.fixture()
+    def merged_instrument(self):
+        return InstrumentFactory.create()
+
+    @pytest.fixture()
+    def main_instrument(self):
+        return InstrumentFactory.create()
+
+    def test_default(
+        self,
+        main_instrument,
+        merged_instrument,
+        exchange_factory,
+        instrument_favorite_group_factory,
+        related_instrument_through_model_factory,
+        instrument_classification_through_model_factory,
+    ):
+        # Prepare data: add exchange
+        main_exchange = main_instrument.exchange
+
+        # Prepare data: Create Favorite group with the merged instrument within
+        favorite_group = instrument_favorite_group_factory.create(instruments=[merged_instrument])
+
+        # prepare data: related instruments
+        main_related_instrument_rel = related_instrument_through_model_factory.create(instrument=main_instrument)
+        merged_related_instrument_rel = related_instrument_through_model_factory.create(instrument=merged_instrument)
+        reversed_related_instrument_rel = related_instrument_through_model_factory.create(
+            related_instrument=merged_instrument
+        )
+
+        # prepare data: classification
+        main_classification_rel = instrument_classification_through_model_factory.create(instrument=main_instrument)
+        merged_classification_rel = instrument_classification_through_model_factory.create(
+            instrument=merged_instrument
+        )
+        reversed_classification_rel = instrument_classification_through_model_factory.create(
+            related_instruments=[merged_instrument]
+        )
+
+        main_instrument.merge(merged_instrument)
+
+        # Test if the merged instrument is indeed deleted
+        with pytest.raises(Instrument.DoesNotExist):
+            merged_instrument.refresh_from_db()
+
+        # Check Exchanges
+        assert {main_instrument.exchange} == {
+            main_exchange
+        }  # check that the merged instrument exchange is forward to the main instrument
+
+        # Check favorite Group
+        assert list(favorite_group.instruments.all()) == [
+            main_instrument
+        ]  # Check that the favorite group with the merged instrument removed it and included the main instrument
+
+        # Check related instruments
+        assert RelatedInstrumentThroughModel.objects.filter(
+            instrument=main_instrument,
+            related_instrument=merged_related_instrument_rel.related_instrument,
+            is_primary=merged_related_instrument_rel.is_primary,
+            related_type=merged_related_instrument_rel.related_type,
+        ).exists()  # Check that the related instrument with the merged instrument removed it and included the main instrument
+        assert main_instrument.related_instruments.filter(
+            id=main_related_instrument_rel.related_instrument.id
+        ).exists()  # Check that the main instrument related instrument is still there
+        assert RelatedInstrumentThroughModel.objects.filter(
+            related_instrument=main_instrument, instrument=reversed_related_instrument_rel.instrument
+        ).exists()  # Check that the reverse related instrument relationship has been forward to the main instrument
+
+        # Check classification
+        assert InstrumentClassificationThroughModel.objects.filter(
+            instrument=main_instrument,
+            classification=merged_classification_rel.classification,
+            is_favorite=merged_classification_rel.is_favorite,
+            reason=merged_classification_rel.reason,
+            pure_player=merged_classification_rel.pure_player,
+            top_player=merged_classification_rel.top_player,
+            percent_of_revenue=merged_classification_rel.percent_of_revenue,
+        ).exists()
+        assert main_instrument.classifications.filter(
+            id=main_classification_rel.classification.id
+        ).exists()  # Check that the main instrument classification relationship is still there
+        assert InstrumentClassificationThroughModel.objects.filter(
+            related_instruments=main_instrument, classification=reversed_classification_rel.classification
+        ).exists()  # Check that the reverse classificaiton instrument relationship has been forward to the main instrument

wbfdm/tests/models/test_options.py

@@ -0,0 +1,69 @@
+import pytest
+from django.forms.models import model_to_dict
+from faker import Faker
+from wbfdm.import_export.handlers.option import (
+    OptionAggregateImportHandler,
+    OptionImportHandler,
+)
+from wbfdm.models import Option, OptionAggregate
+
+fake = Faker()
+
+
+@pytest.mark.django_db
+class TestOptionAggregateModel:
+    def test_option_creation(self, option_aggregate):
+        assert option_aggregate.id is not None
+
+    def test_import_option(self, import_source, instrument, option_aggregate_factory):
+        def serialize(option_aggregate):
+            data = model_to_dict(option_aggregate)
+            data["date"] = option_aggregate.date.strftime("%Y-%m-%d")
+            data["instrument"] = {"id": instrument.id}
+            del data["id"]
+            del data["import_source"]
+            return data
+
+        option_aggregate = option_aggregate_factory.build()
+        data = {"data": [serialize(option_aggregate)]}
+        handler = OptionAggregateImportHandler(import_source)
+
+        # Import non existing data
+        handler.process(data)
+        assert OptionAggregate.objects.count() == 1
+
+        # Import already existing data
+        # import_source.data['data'][0]['shares'] *= 2
+
+        handler.process(data)
+        assert OptionAggregate.objects.count() == 1
+
+
+@pytest.mark.django_db
+class TestOptionModel:
+    def test_option_creation(self, option):
+        assert option.id is not None
+
+    def test_import_option(self, import_source, instrument, option_factory):
+        def serialize(option):
+            data = model_to_dict(option)
+            data["date"] = option.date.strftime("%Y-%m-%d")
+            data["expiration_date"] = option.expiration_date.strftime("%Y-%m-%d")
+            data["instrument"] = {"id": instrument.id}
+            del data["id"]
+            del data["import_source"]
+            return data
+
+        option = option_factory.build()
+        data = {"data": [serialize(option)]}
+        handler = OptionImportHandler(import_source)
+
+        # Import non existing data
+        handler.process(data)
+        assert Option.objects.count() == 1
+
+        # Import already existing data
+        # import_source.data['data'][0]['shares'] *= 2
+
+        handler.process(data)
+        assert Option.objects.count() == 1

wbfdm/tests/test_tasks.py

@@ -0,0 +1,6 @@
+import pytest
+
+
+@pytest.mark.django_db
+def test_daily_update_of_investable_universe_data(instrument):
+    pass

wbfdm/tests/tests.py

@@ -0,0 +1,10 @@
+# from wbcore.test import default_config
+#
+# config = {}
+# for key, value in default_config.items():
+#     config[key] = list(
+#         filter(
+#             lambda x: x.__module__.startswith("wbfdm") and False,
+#             value
+#         )
+#     )

wbfdm/urls.py

@@ -0,0 +1,222 @@
+from django.urls import include, path
+from wbcore.routers import WBCoreRouter
+from wbfdm import viewsets
+
+router = WBCoreRouter()
+router.register(r"instrument", viewsets.InstrumentModelViewSet, basename="instrument")
+router.register(
+    r"instrumentrepresentation", viewsets.InstrumentRepresentationViewSet, basename="instrumentrepresentation"
+)
+router.register(
+    r"instrumenttyperepresentation",
+    viewsets.InstrumentTypeRepresentationViewSet,
+    basename="instrumenttyperepresentation",
+)
+router.register(r"exchange", viewsets.ExchangeModelViewSet, basename="exchange")
+router.register(r"exchangerepresentation", viewsets.ExchangeRepresentationViewSet, basename="exchangerepresentation")
+
+router.register(r"instrumentrequest", viewsets.InstrumentRequestModelViewSet, basename="instrumentrequest")
+router.register(
+    r"instrumentrequestrepresentation",
+    viewsets.InstrumentRequestRepresentationViewSet,
+    basename="instrumentrequestrepresentation",
+)
+
+
+router.register(
+    r"favoritegrouprepresentation",
+    viewsets.InstrumentFavoriteGroupRepresentationViewSet,
+    basename="favoritegrouprepresentation",
+)
+router.register(r"favoritegroup", viewsets.InstrumentFavoriteGroupModelViewSet, basename="favoritegroup")
+
+router.register(
+    r"classificationrepresentation",
+    viewsets.ClassificationRepresentationViewSet,
+    basename="classificationrepresentation",
+)
+router.register(
+    r"classificationgrouprepresentation",
+    viewsets.ClassificationGroupRepresentationViewSet,
+    basename="classificationgrouprepresentation",
+)
+router.register(r"classification", viewsets.ClassificationModelViewSet, basename="classification")
+router.register(r"classificationgroup", viewsets.ClassificationGroupModelViewSet, basename="classificationgroup")
+router.register(r"classifiedinstrument", viewsets.ClassifiedInstrumentModelViewSet, basename="classifiedinstrument")
+router.register(
+    r"instrumentlistrepresentation",
+    viewsets.InstrumentListRepresentationModelViewSet,
+    basename="instrumentlistrepresentation",
+)
+router.register(r"instrumentlist", viewsets.InstrumentListModelViewSet, basename="instrumentlist")
+router.register(r"instrumentlistthrough", viewsets.InstrumentListThroughModelViewSet, basename="instrumentlistthrough")
+
+# Financials viewsets
+
+
+classification_router = WBCoreRouter()
+classification_router.register(
+    r"instrument", viewsets.ClassificationInstrumentThroughInstrumentModelViewSet, basename="classification-instrument"
+)
+
+classification_through_router = WBCoreRouter()
+classification_through_router.register(
+    "related_instrument", viewsets.InstrumentClassificationRelatedInstrumentModelViewSet, basename="related_instrument"
+)
+classification_through_router.register(
+    "related_instrument_representation",
+    viewsets.InstrumentClassificationRelatedInstrumentRepresentationViewSet,
+    basename="related_instrument_representation",
+)
+
+
+classification_group_router = WBCoreRouter()
+classification_group_router.register(
+    r"classification",
+    viewsets.ClassificationClassificationGroupModelViewSet,
+    basename="classificationgroup-classification",
+)
+classification_group_router.register(
+    r"treechart", viewsets.ClassificationTreeChartView, basename="classificationgroup-treechart"
+)
+classification_group_router.register(
+    r"iciclechart", viewsets.ClassificationIcicleChartView, basename="classificationgroup-iciclechart"
+)
+
+parent_classification_router = WBCoreRouter()
+parent_classification_router.register(
+    r"classification",
+    viewsets.ChildClassificationParentClassificationModelViewSet,
+    basename="classificationparent-classification",
+)
+
+
+router.register(
+    r"instrumentclassificationrelationship",
+    viewsets.InstrumentClassificationThroughModelViewSet,
+    basename="instrumentclassificationrelationship",
+)
+router.register(r"price", viewsets.InstrumentPriceModelViewSet, basename="price")
+
+
+instrument_router = WBCoreRouter()
+instrument_router.register(r"price", viewsets.InstrumentPriceInstrumentModelViewSet, basename="instrument-price")
+instrument_router.register(r"children", viewsets.ChildrenInstrumentModelViewSet, basename="instrument-children")
+instrument_router.register(
+    r"relatedinstrument",
+    viewsets.RelatedInstrumentThroughInstrumentModelViewSet,
+    basename="instrument-relatedinstrument",
+)
+instrument_router.register(
+    r"pricestatisticchart",
+    viewsets.InstrumentPriceInstrumentStatisticsChartView,
+    basename="instrument-pricestatisticchart",
+)
+instrument_router.register(
+    r"distributionreturnschart",
+    viewsets.InstrumentPriceInstrumentDistributionReturnsChartView,
+    basename="instrument-distributionreturnschart",
+)
+instrument_router.register(
+    r"bestandworstreturns",
+    viewsets.BestAndWorstReturnsInstrumentPandasView,
+    basename="instrument-bestandworstreturns",
+)
+instrument_router.register(
+    r"financialstatistics",
+    viewsets.FinancialStatisticsInstrumentPandasView,
+    basename="instrument-financialstatistics",
+)
+instrument_router.register(
+    r"summarytablechart", viewsets.SummaryTableInstrumentChartViewSet, basename="instrument-summarytablechart"
+)
+
+instrument_router.register(
+    r"financialsgraphchart", viewsets.FinancialsGraphInstrumentChartViewSet, basename="instrument-financialsgraphchart"
+)
+
+instrument_router.register(
+    r"profitabilityratioschart",
+    viewsets.ProfitabilityRatiosInstrumentChartViewSet,
+    basename="instrument-profitabilityratioschart",
+)
+
+instrument_router.register(
+    r"cashflowanalysistablechart",
+    viewsets.CashFlowAnalysisInstrumentTableViewSet,
+    basename="instrument-cashflowanalysistablechart",
+)
+
+instrument_router.register(
+    r"cashflowanalysisbarchart",
+    viewsets.CashFlowAnalysisInstrumentBarChartViewSet,
+    basename="instrument-cashflowanalysisbarchart",
+)
+
+instrument_router.register(
+    r"netdebtandebitdachart",
+    viewsets.NetDebtAndEbitdaInstrumentChartViewSet,
+    basename="instrument-netdebtandebitdachart",
+)
+
+instrument_router.register(
+    r"earningschart",
+    viewsets.EarningsInstrumentChartViewSet,
+    basename="instrument-earningschart",
+)
+
+instrument_router.register(
+    r"classification",
+    viewsets.InstrumentClassificationThroughInstrumentModelViewSet,
+    basename="instrument-classification",
+)
+instrument_router.register(
+    r"valuationratios", viewsets.ValuationRatiosChartView, basename="instrument-valuationratios"
+)
+
+instrument_router.register(
+    r"instrumentlistthrough",
+    viewsets.InstrumentListThroughModelInstrumentViewSet,
+    basename="instrument-instrumentlistthrough",
+)
+
+instrument_router.register(r"controversies", viewsets.InstrumentESGControversiesViewSet, basename="controversies")
+instrument_router.register(r"pai", viewsets.InstrumentESGPAIViewSet, basename="pai")
+instrument_router.register(r"officers", viewsets.OfficerViewSet, basename="officers")
+instrument_router.register(r"market_data", viewsets.MarketDataChartViewSet, basename="market_data")
+instrument_router.register(
+    r"performance_summary", viewsets.PerformanceSummaryChartViewSet, basename="performance_summary"
+)
+instrument_router.register(
+    r"financial_metric_analysis", viewsets.FinancialMetricAnalysisPandasViewSet, basename="financial_metric_analysis"
+)
+instrument_router.register(
+    r"monthly_performances", viewsets.MonthlyPerformancesInstrumentPandasViewSet, basename="monthly_performances"
+)
+instrument_router.register(r"valuation_ratios", viewsets.ValuationRatioChartViewSet, basename="valuation_ratios")
+instrument_router.register(r"prices", viewsets.InstrumentPriceViewSet, basename="prices")
+
+instrument_statement_router = WBCoreRouter()
+instrument_statement_router.register(
+    r"statementwithestimates", viewsets.StatementWithEstimatesPandasViewSet, basename="statementwithestimates"
+)
+instrument_statement_router.register(r"statement", viewsets.StatementPandasViewSet, basename="statement")
+
+instrument_list = WBCoreRouter()
+instrument_list.register(
+    r"instrumentlistthrough",
+    viewsets.InstrumentListThroughModelInstrumentListViewSet,
+    basename="instrumentlist-instrumentlistthrough",
+)
+
+
+urlpatterns = [
+    path("", include(router.urls)),
+    path("instrument/<int:instrument_id>/", include(instrument_router.urls)),
+    path("classificationgroup/<int:group_id>/", include(classification_group_router.urls)),
+    path("classificationparent/<int:parent_id>/", include(parent_classification_router.urls)),
+    path("classification/<int:classification_id>/", include(classification_router.urls)),
+    path("classification_through/<int:classified_instrument_id>/", include(classification_through_router.urls)),
+    path("instrument_list/<int:instrument_list_id>/", include(instrument_list.urls)),
+    path("instrument/<int:instrument_id>/<str:statement>/", include(instrument_statement_router.urls)),
+]

wbfdm/utils.py

@@ -0,0 +1,54 @@
+from datetime import date
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from pandas.core.indexes.base import Index
+
+
+def rename_period_index_level_to_repr(df):
+    """
+    given a dataframe with multi index (year, interim, **other), with interim as a index number from 0 - 4, rename the level 1 index to its string representation (e.g. Q for quarter, S for semester, T for trimister and Y for yearly)
+
+    Returns:
+        The dataframe whose index level 1 has been renamed according to its period representation
+
+    """
+
+    if "period_type" in df.index.names:
+        df = df.reset_index()
+        df["interim"] = df["period_type"] + df["interim"].astype(str)
+        df.loc[df["interim"] == "Y0", "interim"] = "Y"
+        df = df.drop(columns=["period_type"])
+        df = df.set_index(["year", "interim"])
+    else:
+        renamed_index = []
+        for row in df.index:
+            if row[1] == 0:
+                period_repr = "Y"
+            else:
+                interim_count = (
+                    df.drop(0, level=1, errors="ignore")
+                    .loc[(row[0], slice(None), slice(None)), :]
+                    .index.get_level_values(1)
+                    .max()
+                )
+                if interim_count == 2:
+                    period_repr = f"S{row[1]}"
+                elif interim_count == 3:
+                    period_repr = f"T{row[1]}"
+                elif interim_count == 4:
+                    period_repr = f"Q{row[1]}"
+                else:
+                    period_repr = f"P{row[1]}"
+
+            renamed_index.append((row[0], period_repr, *(row[2:] if len(row) > 2 else ())))
+        df = df.set_index([renamed_index])
+    return df
+
+
+def rename_date_columns(columns: "Index", fmt: str) -> dict[str, str]:
+    column_mapping = dict()
+    for col in filter(lambda col: isinstance(col, date), columns):
+        column_mapping[col] = col.strftime(fmt)
+
+    return column_mapping

wbfdm/viewsets/__init__.py

@@ -0,0 +1,10 @@
+from .esg import InstrumentESGControversiesViewSet, InstrumentESGPAIViewSet
+from .instruments import *
+from .market_data import MarketDataChartViewSet, PerformanceSummaryChartViewSet
+from .prices import InstrumentPriceViewSet
+from .officers import OfficerViewSet
+
+from .financial_analysis import *
+from .technical_analysis import *
+from .statements import *
+from .exchanges import *

wbfdm/viewsets/configs/__init__.py

@@ -0,0 +1,5 @@
+from .display import *
+from .endpoints import *
+from .titles import *
+from .menus import *
+from .buttons import *