wbfdm 1.43.2__tar.gz → 1.44.0__tar.gz

{wbfdm-1.43.2 → wbfdm-1.44.0}/PKG-INFO

@@ -1,9 +1,10 @@
 Metadata-Version: 2.4
 Name: wbfdm
-Version: 1.43.2
+Version: 1.44.0
 Summary: The workbench module ensures rapid access to diverse financial data (market, fundamental, forecasts, ESG), with features for storing instruments, classifying them, and conducting financial analysis.
 Author-email: Christopher Wittlinger <c.wittlinger@stainly.com>
 Requires-Dist: roman==4.*
+Requires-Dist: sentry-sdk==2.*
 Requires-Dist: stockstats==0.6.*
 Requires-Dist: wbcore
 Requires-Dist: wbnews
@@ -13,3 +14,4 @@ Requires-Dist: requests-cache==1.0.*; extra == 'dsws'
 Provides-Extra: qa
 Requires-Dist: jinjasql2==0.1.*; extra == 'qa'
 Requires-Dist: mssql-django==1.4.*; extra == 'qa'
+Requires-Dist: pypika; extra == 'qa'

{wbfdm-1.43.2 → wbfdm-1.44.0}/pyproject.toml

@@ -9,12 +9,14 @@ dependencies = [
   "wbnews",
   "stockstats == 0.6.*",
   "roman == 4.*",
+  "sentry-sdk == 2.*",
 ]
 
 [project.optional-dependencies]
 qa = [
   "mssql-django == 1.4.*",
   "jinjasql2 == 0.1.*",
+  "pypika",
 ]
 dsws = [
   "requests-cache == 1.0.*",
@@ -24,6 +26,7 @@ dsws = [
 [tool.uv.sources]
 wbcore = { workspace = true }
 wbnews = { workspace = true }
+pypika = { git = "https://github.com/kayak/pypika.git" }
 
 [tool.uv]
 package = true

{wbfdm-1.43.2 → wbfdm-1.44.0}/wbfdm/analysis/financial_analysis/utils.py

@@ -25,6 +25,7 @@ class Loader:
         calendar_type: CalendarType = CalendarType.FISCAL,
         market_data_values: list[MarketData] | None = None,
         statement_values: list[Financial] | None = None,
+        period_type: PeriodType = PeriodType.ALL,
     ):
         self.instrument = instrument
         self.calendar_type = calendar_type
@@ -35,6 +36,7 @@ class Loader:
         self.statement_values = (
             statement_values  # specify if any extra statement needs to be merged into the dataframe
         )
+        self.period_type = period_type
         self.errors: dict[str, list[str]] = defaultdict(list)
 
     def load(self) -> pd.DataFrame:
@@ -54,9 +56,9 @@ class Loader:
         df = pd.DataFrame(
             Instrument.objects.filter(id=self.instrument.id).dl.financials(
                 values=self.values,
-                period_type=PeriodType.ALL,
                 from_year=date.today().year - 5,
                 calendar_type=self.calendar_type,
+                period_type=self.period_type,
             )
         )
         if df.empty:

wbfdm-1.44.0/wbfdm/contrib/qa/dataloaders/adjustments.py

@@ -0,0 +1,69 @@
+from contextlib import suppress
+from datetime import date
+from itertools import batched
+from typing import Iterator
+
+from django.db import ProgrammingError, connections
+from wbcore.contrib.dataloader.dataloaders import Dataloader
+from wbcore.contrib.dataloader.utils import dictfetchall
+from wbfdm.contrib.qa.dataloaders.utils import SOURCE_DS2
+from wbfdm.dataloaders.protocols import AdjustmentsProtocol
+from wbfdm.dataloaders.types import AdjustmentDataDict
+
+import pypika as pk
+from pypika import functions as fn
+from pypika.enums import SqlTypes, Order
+from pypika.terms import LiteralValue
+
+
+class DatastreamAdjustmentsDataloader(AdjustmentsProtocol, Dataloader):
+    def adjustments(self, from_date: date | None = None, to_date: date | None = None) -> Iterator[AdjustmentDataDict]:
+        lookup = {k: v for k, v in self.entities.values_list("dl_parameters__adjustments__parameters", "id")}
+
+        adj = pk.Table("DS2Adj")
+        adj_date = fn.Cast(adj.AdjDate, SqlTypes.DATE).as_("adjustment_date")
+        adj_end_date = fn.Cast(adj.EndAdjDate, SqlTypes.DATE).as_("adjustment_end_date")
+
+        infocode = pk.Table("#ds2infocode")
+
+        query = (
+            pk.MSSQLQuery.select(
+                adj.InfoCode.as_("external_identifier"),
+                fn.Concat(adj.InfoCode, "_", adj_date).as_("id"),
+                adj_date,
+                adj_end_date,
+                SOURCE_DS2,
+                adj.AdjFactor.as_("adjustment_factor"),
+                adj.CumAdjFactor.as_("cumulative_adjustement_factor"),
+            )
+            .from_(adj)
+            .where(adj.AdjType == 2)
+            .where(adj.InfoCode.isin([LiteralValue("select infocode from #ds2infocode")]))
+            .orderby(adj.AdjDate, order=Order.desc)
+        )
+
+        if from_date:
+            query = query.where(adj.AdjDate >= from_date)
+
+        if to_date:
+            query = query.where(adj.AdjDate <= to_date)
+
+        with connections["qa"].cursor() as cursor:
+            # we suppress an error here, because if the temporary table already exists
+            # then we do not want to fail. It should not fail, but if a previous run did
+            # not clean up the table properly, then at least we do not get stuck here
+            with suppress(ProgrammingError):
+                cursor.execute(
+                    pk.MSSQLQuery.create_table(infocode).columns(pk.Column("infocode", SqlTypes.INTEGER)).get_sql()
+                )
+                for batch in batched(lookup.keys(), 1000):
+                    cursor.execute(f"insert into #ds2infocode values {",".join(map(lambda x: f"({x})", batch))};")
+
+            cursor.execute(query.get_sql())
+
+            for row in dictfetchall(cursor, AdjustmentDataDict):
+                row["instrument_id"] = lookup[row["external_identifier"]]
+                yield row
+
+            # here we remove the temporary table again to avoid data spillage
+            # cursor.execute(pk.MSSQLQuery.drop_table(infocode).get_sql())

wbfdm-1.44.0/wbfdm/contrib/qa/dataloaders/corporate_actions.py

@@ -0,0 +1,69 @@
+from contextlib import suppress
+from datetime import date
+from itertools import batched
+from typing import Iterator
+
+from django.db import ProgrammingError, connections
+from wbcore.contrib.dataloader.dataloaders import Dataloader
+from wbcore.contrib.dataloader.utils import dictfetchall
+from wbfdm.contrib.qa.dataloaders.utils import SOURCE_DS2
+from wbfdm.dataloaders.protocols import CorporateActionsProtocol
+from wbfdm.dataloaders.types import CorporateActionDataDict
+
+import pypika as pk
+from pypika import functions as fn
+from pypika.enums import SqlTypes
+from pypika.terms import LiteralValue
+
+
+class DatastreamCorporateActionsDataloader(CorporateActionsProtocol, Dataloader):
+    def corporate_actions(
+        self,
+        from_date: date | None = None,
+        to_date: date | None = None,
+    ) -> Iterator[CorporateActionDataDict]:
+        lookup = {k: v for k, v in self.entities.values_list("dl_parameters__corporate_actions__parameters", "id")}
+
+        cap_event = pk.Table("Ds2CapEvent")
+        effective_date = fn.Cast(cap_event.EffectiveDate, SqlTypes.DATE)
+        infocode = pk.Table("#ds2infocode")
+
+        query = (
+            pk.MSSQLQuery.select(
+                cap_event.InfoCode.as_("external_identifier"),
+                fn.Concat(cap_event.InfoCode, "_", effective_date).as_("id"),
+                effective_date.as_("valuation_date"),
+                SOURCE_DS2,
+                cap_event.ActionTypeCode.as_("action_code"),
+                cap_event.EventStatusCode.as_("event_code"),
+                cap_event.NumOldShares.as_("old_shares"),
+                cap_event.NumNewShares.as_("new_shares"),
+                cap_event.ISOCurrCode.as_("currency"),
+            )
+            .from_(cap_event)
+            .where(cap_event.InfoCode.isin([LiteralValue("select infocode from #ds2infocode")]))
+            .orderby(cap_event.EffectiveDate, order=pk.Order.desc)
+        )
+
+        if from_date:
+            query = query.where(cap_event.EffectiveDate >= from_date)
+
+        if to_date:
+            query = query.where(cap_event.EffectiveDate <= to_date)
+
+        with connections["qa"].cursor() as cursor:
+            # Create temporary table if it doesn't exist
+            with suppress(ProgrammingError):
+                cursor.execute(
+                    pk.MSSQLQuery.create_table(infocode).columns(pk.Column("infocode", SqlTypes.INTEGER)).get_sql()
+                )
+                for batch in batched(lookup.keys(), 1000):
+                    cursor.execute(f"insert into #ds2infocode values {','.join(map(lambda x: f'({x})', batch))};")
+
+            cursor.execute(query.get_sql())
+            for row in dictfetchall(cursor, CorporateActionDataDict):
+                row["instrument_id"] = lookup[row["external_identifier"]]
+                yield row
+
+            # Clean up temporary table
+            cursor.execute(pk.MSSQLQuery.drop_table(infocode).get_sql())

wbfdm-1.44.0/wbfdm/contrib/qa/dataloaders/market_data.py

@@ -0,0 +1,142 @@
+from contextlib import suppress
+from functools import reduce
+from itertools import batched
+from datetime import date
+from enum import Enum
+from typing import Iterator
+import pypika as pk
+from pypika import Column, MSSQLQuery, functions as fn
+from pypika.enums import SqlTypes, Order
+from pypika.terms import ValueWrapper, LiteralValue
+
+from django.db import ProgrammingError, connections
+from wbcore.contrib.dataloader.dataloaders import Dataloader
+from wbcore.contrib.dataloader.utils import dictfetchall
+from wbfdm.dataloaders.protocols import MarketDataProtocol
+from wbfdm.contrib.qa.dataloaders.utils import create_table
+from wbfdm.dataloaders.types import MarketDataDict
+from wbfdm.enums import Frequency, MarketData
+
+
+class DS2MarketData(Enum):
+    OPEN = ("Open_", None)
+    CLOSE = ("Close_", None)
+    HIGH = ("High", None)
+    LOW = ("Low", None)
+    BID = ("Bid", None)
+    ASK = ("Ask", None)
+    VWAP = ("VWAP", None)
+    VOLUME = ("Volume", None)
+    MARKET_CAPITALIZATION = ("ConsolMktVal", 1_000_000)
+    SHARES_OUTSTANDING = ("ConsolNumShrs", 1_000)
+
+
+class DatastreamMarketDataDataloader(MarketDataProtocol, Dataloader):
+    def market_data(
+        self,
+        values: list[MarketData] | None = [MarketData.CLOSE],
+        from_date: date | None = None,
+        to_date: date | None = None,
+        exact_date: date | None = None,
+        frequency: Frequency = Frequency.DAILY,
+        target_currency: str | None = None,
+        **kwargs,
+    ) -> Iterator[MarketDataDict]:
+        """Get market data for instruments.
+
+        Args:
+            queryset (QuerySet["Instrument"]): The queryset of instruments.
+            values (list[MarketData]): List of values to include in the results.
+            from_date (date | None): The starting date for filtering prices. Defaults to None.
+            to_date (date | None): The ending date for filtering prices. Defaults to None.
+            frequency (Frequency): The frequency of the requested data
+
+        Returns:
+            Iterator[MarketDataDict]: An iterator of dictionaries conforming to the DailyValuationDict.
+        """
+
+        lookup = {
+            f"{k[0]},{k[1]}": v for k, v in self.entities.values_list("dl_parameters__market_data__parameters", "id")
+        }
+        value_mapping = [(DS2MarketData[x.name].value, x.value) for x in values or []]
+
+        # Define tables
+        pricing = pk.Table("vw_DS2Pricing")
+        market_val = pk.Table("DS2MktVal")
+        fx_code = pk.Table("DS2FxCode")
+        fx = pk.Table("DS2FxRate")
+
+        mapping, create_mapping_table = create_table(
+            "#ds2infoexchcode", Column("InfoCode", SqlTypes.INTEGER), Column("ExchIntCode", SqlTypes.INTEGER)
+        )
+
+        # Base query to get data we always need unconditionally
+        query = (
+            pk.MSSQLQuery.from_(pricing)
+            .select(
+                fn.Concat(pricing.InfoCode, ",", pricing.ExchIntCode).as_("external_identifier"),
+                fn.Concat(
+                    pricing.InfoCode, ",", pricing.ExchIntCode, "_", fn.Cast(pricing.MarketDate, SqlTypes.DATE)
+                ).as_("id"),
+                fn.Cast(pricing.MarketDate, SqlTypes.DATE).as_("valuation_date"),
+                ValueWrapper("qa-ds2").as_("source"),
+            )
+            .left_join(market_val)
+            .on((pricing.InfoCode == market_val.InfoCode) & (pricing.MarketDate == market_val.ValDate))
+            # We join on _codes, which removes all instruments not in _codes - implicit where
+            .join(mapping)
+            .on((pricing.InfoCode == mapping.InfoCode) & (pricing.ExchIntCode == mapping.ExchIntCode))
+            .where(pricing.AdjType == 2)
+            .orderby(pricing.MarketDate, order=Order.desc)
+        )
+
+        # If we need to convert to a target currency, we need the fx rate table and multiply all values with the fx rate
+        if target_currency:
+            query = (
+                query.select(
+                    ValueWrapper(target_currency).as_("currency"),
+                    *[
+                        (LiteralValue(value[0][0]) * fn.Coalesce(fx.midrate, 1)).as_(value[1])
+                        for value in value_mapping
+                    ],
+                )
+                .left_join(fx_code)
+                .on(
+                    (fx_code.FromCurrCode == target_currency)
+                    & (fx_code.ToCurrCode == pricing.Currency)
+                    & (fx_code.RateTypeCode == "SPOT")
+                )
+                .left_join(fx)
+                .on((fx_code.ExRateIntCode == fx.ExRateIntCode) & (fx.ExRateDate == pricing.MarketDate))
+            )
+        else:
+            query = query.select(
+                pricing.Currency.as_("currency"),
+                *[LiteralValue(value[0][0]).as_(value[1]) for value in value_mapping],
+            )
+
+        # Add conditional where clauses
+        if from_date:
+            query = query.where(pricing.MarketDate >= from_date)
+
+        if to_date:
+            query = query.where(pricing.MarketDate <= to_date)
+
+        if exact_date:
+            query = query.where(pricing.MarketDate == exact_date)
+
+        with connections["qa"].cursor() as cursor:
+            with suppress(ProgrammingError):
+                cursor.execute(create_mapping_table.get_sql())
+                for batch in batched(
+                    self.entities.values_list("dl_parameters__market_data__parameters", flat=True), 1000
+                ):
+                    cursor.execute(reduce(lambda x, y: x.insert(y), batch, MSSQLQuery.into(mapping)).get_sql())
+
+            cursor.execute(query.get_sql())
+
+            for row in dictfetchall(cursor, MarketDataDict):
+                row["instrument_id"] = lookup[row["external_identifier"]]
+                yield row
+
+            cursor.execute(MSSQLQuery.drop_table(mapping).get_sql())

wbfdm-1.44.0/wbfdm/contrib/qa/dataloaders/officers.py

@@ -0,0 +1,74 @@
+from typing import Iterator
+
+from django.db import connections, ProgrammingError
+from wbcore.contrib.dataloader.dataloaders import Dataloader
+from wbcore.contrib.dataloader.utils import dictfetchall
+from wbfdm.dataloaders.protocols import OfficersProtocol
+from wbfdm.dataloaders.types import OfficerDataDict
+from itertools import batched
+from contextlib import suppress
+
+import pypika as pk
+from pypika import functions as fn
+from pypika.enums import SqlTypes
+from pypika.terms import LiteralValue
+
+
+from pypika.analytics import RowNumber
+
+
+class RKDOfficersDataloader(OfficersProtocol, Dataloader):
+    def officers(
+        self,
+    ) -> Iterator[OfficerDataDict]:
+        lookup = {k: v for k, v in self.entities.values_list("dl_parameters__officers__parameters", "id")}
+
+        # Define tables
+        designation = pk.Table("RKDFndCmpOffTitleChg")
+        officer = pk.Table("RKDFndCmpOfficer")
+        temp_codes = pk.Table("#rkd_codes")
+
+        # Build the query
+        query = (
+            pk.MSSQLQuery.select(
+                fn.Concat(designation.Code, "-", RowNumber().orderby(officer.OfficerRank)).as_("id"),
+                designation.Code.as_("external_identifier"),
+                designation.Title.as_("position"),
+                fn.Concat(
+                    officer.Prefix,
+                    " ",
+                    officer.FirstName,
+                    " ",
+                    officer.LastName,
+                    pk.Case().when(officer.Suffix.isnull(), "").else_(fn.Concat(", ", officer.Suffix)),
+                ).as_("name"),
+                officer.Age.as_("age"),
+                officer.Sex.as_("sex"),
+                fn.Cast(designation.DesgStartDt, SqlTypes.DATE).as_("start"),
+            )
+            .from_(designation)
+            .join(officer)
+            .on((designation.Code == officer.Code) & (designation.OfficerID == officer.Officerid))
+            .where(designation.Code.isin([LiteralValue("select code from #rkd_codes")]))
+            .where(designation.DesgEndDt.isnull())
+            .orderby(officer.OfficerRank)
+        )
+
+        with connections["qa"].cursor() as cursor:
+            # Create and populate temporary table
+            with suppress(ProgrammingError):
+                cursor.execute(
+                    pk.MSSQLQuery.create_table(temp_codes).columns(pk.Column("code", SqlTypes.INTEGER)).get_sql()
+                )
+                for batch in batched(lookup.keys(), 1000):
+                    placeholders = ",".join(map(lambda x: f"('{x}')", batch))
+                    cursor.execute(f"insert into #rkd_codes values {placeholders};")
+
+            cursor.execute(query.get_sql())
+
+            for row in dictfetchall(cursor, OfficerDataDict):
+                row["instrument_id"] = lookup[row["external_identifier"]]
+                yield row
+
+            # Clean up temporary table
+            cursor.execute(pk.MSSQLQuery.drop_table(temp_codes).get_sql())

wbfdm-1.44.0/wbfdm/contrib/qa/dataloaders/utils.py

@@ -0,0 +1,22 @@
+from typing import TYPE_CHECKING
+
+from pypika.terms import ValueWrapper
+from pypika import Column, MSSQLQuery, Table
+
+if TYPE_CHECKING:
+    from pypika.terms import Term
+    from pypika.queries import CreateQueryBuilder
+
+
+def compile_source(source: str) -> "Term":
+    return ValueWrapper(source).as_("source")
+
+
+SOURCE_DS2 = compile_source("qa-ds2")
+SOURCE_RKD = compile_source("qa-rkd")
+SOURCE_IBES = compile_source("qa-ibes")
+
+
+def create_table(tablename: "str", *columns: "Column") -> tuple[Table, "CreateQueryBuilder"]:
+    table = Table(tablename)
+    return table, MSSQLQuery.create_table(table).columns(*columns)

{wbfdm-1.43.2 → wbfdm-1.44.0}/wbfdm/dataloaders/protocols.py

@@ -27,13 +27,13 @@ from wbfdm.enums import (
 
 
 class ReportDateProtocol(Protocol):
-    def reporting_dates(self, only_next: bool = True) -> Iterator[ReportDateDataDict]:
-        ...
+    def reporting_dates(self, only_next: bool = True) -> Iterator[ReportDateDataDict]: ...
 
 
 class AdjustmentsProtocol(Protocol):
-    def adjustments(self, from_date: date, to_date: date) -> Iterator[AdjustmentDataDict]:
-        ...
+    def adjustments(
+        self, from_date: date | None = None, to_date: date | None = None
+    ) -> Iterator[AdjustmentDataDict]: ...
 
 
 class MarketDataProtocol(Protocol):
@@ -45,20 +45,17 @@ class MarketDataProtocol(Protocol):
         exact_date: date | None = None,
         frequency: Frequency = Frequency.DAILY,
         target_currency: str | None = None,
-    ) -> Iterator[MarketDataDict]:
-        ...
+    ) -> Iterator[MarketDataDict]: ...
 
 
 class CorporateActionsProtocol(Protocol):
     def corporate_actions(
         self, from_date: date | None = None, to_date: date | None = None
-    ) -> Iterator[CorporateActionDataDict]:
-        ...
+    ) -> Iterator[CorporateActionDataDict]: ...
 
 
 class OfficersProtocol(Protocol):
-    def officers(self) -> Iterator[OfficerDataDict]:
-        ...
+    def officers(self) -> Iterator[OfficerDataDict]: ...
 
 
 class StatementsProtocol(Protocol):
@@ -73,8 +70,7 @@ class StatementsProtocol(Protocol):
         data_type: DataType = DataType.STANDARDIZED,
         financials: list[Financial] | None = None,
         target_currency: str | None = None,
-    ) -> Iterator[StatementDataDict]:
-        ...
+    ) -> Iterator[StatementDataDict]: ...
 
 
 class FinancialsProtocol(Protocol):
@@ -95,18 +91,15 @@ class FinancialsProtocol(Protocol):
         data_type: DataType = DataType.STANDARDIZED,
         estimate_type: EstimateType = EstimateType.VALID,
         target_currency: str | None = None,
-    ) -> Iterator[FinancialDataDict]:
-        ...
+    ) -> Iterator[FinancialDataDict]: ...
 
 
 class ESGControversyProtocol(Protocol):
-    def esg_controversies(self) -> Iterator[ESGControversyDataDict]:
-        ...
+    def esg_controversies(self) -> Iterator[ESGControversyDataDict]: ...
 
 
 class ESGProtocol(Protocol):
     def esg(
         self,
         values: list[ESG],
-    ) -> Iterator[ESGDataDict]:
-        ...
+    ) -> Iterator[ESGDataDict]: ...

{wbfdm-1.43.2 → wbfdm-1.44.0}/wbfdm/dataloaders/proxies.py

@@ -67,7 +67,7 @@ class InstrumentDataloaderProxy(
         for dl in self.iterate_dataloaders("reporting_dates"):
             yield from dl.reporting_dates(only_next=only_next)
 
-    def adjustments(self, from_date: date, to_date: date) -> Iterator[AdjustmentDataDict]:
+    def adjustments(self, from_date: date | None = None, to_date: date | None = None) -> Iterator[AdjustmentDataDict]:
         for dl in self.iterate_dataloaders("adjustments"):
             yield from dl.adjustments(from_date=from_date, to_date=to_date)
 

{wbfdm-1.43.2 → wbfdm-1.44.0}/wbfdm/dataloaders/types.py

@@ -33,6 +33,8 @@ class MarketDataDict(BaseDict):
     Attributes:
         valuation_date: date
             The date of valuation.
+        external_identifier: str
+            The external identifier of the instrument
         open: float | None
             The opening value (if available).
         close: float | None
@@ -52,6 +54,7 @@ class MarketDataDict(BaseDict):
     """
 
     valuation_date: date
+    external_identifier: str
 
     open: NotRequired[float]
     close: NotRequired[float]

{wbfdm-1.43.2 → wbfdm-1.44.0}/wbfdm/enums.py

@@ -50,12 +50,12 @@ class Financial(ChoiceEnum):
     NET_INCOME_BEFORE_TAXES = "pbt"
     NET_INCOME = "net_income"
     EPS = "eps"
-    FREE_CASH_FLOW = "fcf"
+    FREE_CASH_FLOW = "free_cash_flow"
     EBITDA = "ebitda"
     EBITDA_PER_SHARE = "ebitda_sh"
     NET_DEBT = "net_debt"
     ENTERPRISE_VALUE = "ev"
-    SHARES_OUTSTANDING = "outstanding_shares"
+    SHARES_OUTSTANDING = "shares_outstanding"
     COST_OF_GOODS_SOLD = "cogs"
     GROSS_PROFIT_MARGIN = "gross_profit_margin"
     SELLING_MARKETING_EXPENSES = "selling_marketing_expenses"
@@ -79,7 +79,7 @@ class Financial(ChoiceEnum):
     CASH_FLOW_FROM_OPERATIONS = "cash_flow_from_operations"
     CAPEX = "capex"
     CASH_FLOW_FROM_INVESTING = "cash_flow_from_investing"
-    FREE_CASH_FLOW_PER_SHARE = "fcf_per_share"
+    FREE_CASH_FLOW_PER_SHARE = "free_cash_flow_per_share"
     TOTAL_DIVIDENDS = "total_dividends"
     CASH_FLOW_FROM_FINANCING = "cash_flow_from_financing"
     CASH_FLOW_PER_SHARE = "cash_flow_per_share"

{wbfdm-1.43.2 → wbfdm-1.44.0}/wbfdm/serializers/instruments/instruments.py

@@ -192,6 +192,7 @@ class InstrumentModelSerializer(InstrumentAdditionalResourcesMixin, InstrumentMo
         if not instance.is_managed:
             res.update(
                 {
+                    "fin-summary": reverse("wbfdm:financial-summary-list", args=[instance.id], request=request),
                     "swe-income-statement": reverse(
                         "wbfdm:statementwithestimates-list", args=[instance.id, "income"], request=request
                     ),

{wbfdm-1.43.2 → wbfdm-1.44.0}/wbfdm/tests/analysis/financial_analysis/test_statement_with_estimates.py

@@ -380,7 +380,7 @@ class TestStatementWithEstimates:
             "employees",
             "stock_compensation_employee_ratio",
             "capex",
-            "outstanding_shares",
+            "shares_outstanding",
             "market_capitalization",
             "close",
             "market_capitalization",

{wbfdm-1.43.2 → wbfdm-1.44.0}/wbfdm/urls.py

@@ -195,6 +195,7 @@ instrument_router.register(
 )
 instrument_router.register(r"valuation_ratios", viewsets.ValuationRatioChartViewSet, basename="valuation_ratios")
 instrument_router.register(r"prices", viewsets.InstrumentPriceViewSet, basename="prices")
+instrument_router.register(r"financial-summary", viewsets.FinancialSummary, basename="financial-summary")
 
 instrument_statement_router = WBCoreRouter()
 instrument_statement_router.register(

{wbfdm-1.43.2 → wbfdm-1.44.0}/wbfdm/viewsets/configs/buttons/instruments.py

@@ -232,7 +232,7 @@ class InstrumentButtonViewConfig(ButtonViewConfig):
                         key="pai",
                     ),
                 ],
-            )
+            ),
             # bt.DropDownButton(
             #     label="Financial Analysis (Old)",
             #     weight=3,

{wbfdm-1.43.2 → wbfdm-1.44.0}/wbfdm/viewsets/configs/display/__init__.py

@@ -20,3 +20,4 @@ from .instruments_relationships import (
 from .exchanges import ExchangeDisplayConfig
 from .monthly_performances import MonthlyPerformancesInstrumentDisplayViewConfig
 from .esg import InstrumentESGPAIDisplayViewConfig, InstrumentESGControversyDisplayViewConfig
+from .financial_summary import FinancialSummaryDisplayViewConfig