diff --git a/examples/rest/stocks-stock_financials.py b/examples/rest/stocks-stock_financials.py index dc356494..a75087e7 100644 --- a/examples/rest/stocks-stock_financials.py +++ b/examples/rest/stocks-stock_financials.py @@ -8,6 +8,13 @@ client = RESTClient() # POLYGON_API_KEY environment variable is used financials = [] -for f in client.vx.list_stock_financials("AAPL"): +for f in client.vx.list_stock_financials("AAPL", filing_date="2024-11-01"): financials.append(f) + + # get diluted_earnings_per_share + # print(f.financials.income_statement.diluted_earnings_per_share) + + # get net_income_loss + # print(f.financials.income_statement.net_income_loss) + print(financials) diff --git a/polygon/rest/models/financials.py b/polygon/rest/models/financials.py index 1a480c48..5443e4f6 100644 --- a/polygon/rest/models/financials.py +++ b/polygon/rest/models/financials.py @@ -1,328 +1,503 @@ -from typing import Optional, Dict +from dataclasses import dataclass +from typing import Any, Dict, List, Optional from ...modelclass import modelclass @modelclass +@dataclass class DataPoint: - "An individual financial data point." - formula: Optional[str] = None - label: Optional[str] = None - order: Optional[int] = None - unit: Optional[str] = None - value: Optional[float] = None - xpath: Optional[str] = None + """Represents a single numeric or textual data point in the financials.""" - @staticmethod - def from_dict(d): - return DataPoint(**d) - - -@modelclass -class ExchangeGainsLosses: - "Contains exchange gains losses data for a cash flow statement." - formula: Optional[str] = None label: Optional[str] = None order: Optional[int] = None unit: Optional[str] = None value: Optional[float] = None - xpath: Optional[str] = None - - @staticmethod - def from_dict(d): - return ExchangeGainsLosses(**d) - - -@modelclass -class NetCashFlow: - "Contains net cash flow data for a cash flow statement." + derived_from: Optional[List[str]] = None formula: Optional[str] = None - label: Optional[str] = None - order: Optional[int] = None - unit: Optional[str] = None - value: Optional[float] = None + source: Optional[Dict[str, str]] = None xpath: Optional[str] = None @staticmethod - def from_dict(d): - return NetCashFlow(**d) + def from_dict(d: Optional[Dict[str, Any]]) -> "DataPoint": + if not d: + return DataPoint() + return DataPoint( + label=d.get("label"), + order=d.get("order"), + unit=d.get("unit"), + value=d.get("value"), + derived_from=d.get("derived_from"), + formula=d.get("formula"), + source=d.get("source"), + xpath=d.get("xpath"), + ) +@dataclass @modelclass -class NetCashFlowFromFinancingActivities: - "Contains net cash flow from financing activities data for a cash flow statement." - formula: Optional[str] = None - label: Optional[str] = None - order: Optional[int] = None - unit: Optional[str] = None - value: Optional[float] = None - xpath: Optional[str] = None +class BalanceSheet: + assets: Optional[DataPoint] = None + current_assets: Optional[DataPoint] = None + cash: Optional[DataPoint] = None + accounts_receivable: Optional[DataPoint] = None + inventory: Optional[DataPoint] = None + prepaid_expenses: Optional[DataPoint] = None + other_current_assets: Optional[DataPoint] = None + noncurrent_assets: Optional[DataPoint] = None + long_term_investments: Optional[DataPoint] = None + fixed_assets: Optional[DataPoint] = None + intangible_assets: Optional[DataPoint] = None + noncurrent_prepaid_expense: Optional[DataPoint] = None + other_noncurrent_assets: Optional[DataPoint] = None + liabilities: Optional[DataPoint] = None + current_liabilities: Optional[DataPoint] = None + accounts_payable: Optional[DataPoint] = None + interest_payable: Optional[DataPoint] = None + wages: Optional[DataPoint] = None + other_current_liabilities: Optional[DataPoint] = None + noncurrent_liabilities: Optional[DataPoint] = None + long_term_debt: Optional[DataPoint] = None + other_noncurrent_liabilities: Optional[DataPoint] = None + commitments_and_contingencies: Optional[DataPoint] = None + redeemable_noncontrolling_interest: Optional[DataPoint] = None + redeemable_noncontrolling_interest_common: Optional[DataPoint] = None + redeemable_noncontrolling_interest_other: Optional[DataPoint] = None + redeemable_noncontrolling_interest_preferred: Optional[DataPoint] = None + equity: Optional[DataPoint] = None + equity_attributable_to_noncontrolling_interest: Optional[DataPoint] = None + equity_attributable_to_parent: Optional[DataPoint] = None + temporary_equity: Optional[DataPoint] = None + temporary_equity_attributable_to_parent: Optional[DataPoint] = None + liabilities_and_equity: Optional[DataPoint] = None @staticmethod - def from_dict(d): - return NetCashFlowFromFinancingActivities(**d) + def from_dict(d: Optional[Dict[str, Any]]) -> "BalanceSheet": + if not d: + return BalanceSheet() + return BalanceSheet( + assets=DataPoint.from_dict(d.get("assets")), + current_assets=DataPoint.from_dict(d.get("current_assets")), + cash=DataPoint.from_dict(d.get("cash")), + accounts_receivable=DataPoint.from_dict(d.get("accounts_receivable")), + inventory=DataPoint.from_dict(d.get("inventory")), + prepaid_expenses=DataPoint.from_dict(d.get("prepaid_expenses")), + other_current_assets=DataPoint.from_dict(d.get("other_current_assets")), + noncurrent_assets=DataPoint.from_dict(d.get("noncurrent_assets")), + long_term_investments=DataPoint.from_dict(d.get("long_term_investments")), + fixed_assets=DataPoint.from_dict(d.get("fixed_assets")), + intangible_assets=DataPoint.from_dict(d.get("intangible_assets")), + noncurrent_prepaid_expense=DataPoint.from_dict( + d.get("noncurrent_prepaid_expense") + ), + other_noncurrent_assets=DataPoint.from_dict( + d.get("other_noncurrent_assets") + ), + liabilities=DataPoint.from_dict(d.get("liabilities")), + current_liabilities=DataPoint.from_dict(d.get("current_liabilities")), + accounts_payable=DataPoint.from_dict(d.get("accounts_payable")), + interest_payable=DataPoint.from_dict(d.get("interest_payable")), + wages=DataPoint.from_dict(d.get("wages")), + other_current_liabilities=DataPoint.from_dict( + d.get("other_current_liabilities") + ), + noncurrent_liabilities=DataPoint.from_dict(d.get("noncurrent_liabilities")), + long_term_debt=DataPoint.from_dict(d.get("long_term_debt")), + other_noncurrent_liabilities=DataPoint.from_dict( + d.get("other_noncurrent_liabilities") + ), + commitments_and_contingencies=DataPoint.from_dict( + d.get("commitments_and_contingencies") + ), + redeemable_noncontrolling_interest=DataPoint.from_dict( + d.get("redeemable_noncontrolling_interest") + ), + redeemable_noncontrolling_interest_common=DataPoint.from_dict( + d.get("redeemable_noncontrolling_interest_common") + ), + redeemable_noncontrolling_interest_other=DataPoint.from_dict( + d.get("redeemable_noncontrolling_interest_other") + ), + redeemable_noncontrolling_interest_preferred=DataPoint.from_dict( + d.get("redeemable_noncontrolling_interest_preferred") + ), + equity=DataPoint.from_dict(d.get("equity")), + equity_attributable_to_noncontrolling_interest=DataPoint.from_dict( + d.get("equity_attributable_to_noncontrolling_interest") + ), + equity_attributable_to_parent=DataPoint.from_dict( + d.get("equity_attributable_to_parent") + ), + temporary_equity=DataPoint.from_dict(d.get("temporary_equity")), + temporary_equity_attributable_to_parent=DataPoint.from_dict( + d.get("temporary_equity_attributable_to_parent") + ), + liabilities_and_equity=DataPoint.from_dict(d.get("liabilities_and_equity")), + ) +@dataclass @modelclass class CashFlowStatement: - "Contains cash flow statement data." - exchange_gains_losses: Optional[ExchangeGainsLosses] = None - net_cash_flow: Optional[NetCashFlow] = None - net_cash_flow_from_financing_activities: Optional[ - NetCashFlowFromFinancingActivities - ] = None + net_cash_flow_from_operating_activities: Optional[DataPoint] = None + net_cash_flow_from_operating_activities_continuing: Optional[DataPoint] = None + net_cash_flow_from_operating_activities_discontinued: Optional[DataPoint] = None + net_cash_flow_from_investing_activities: Optional[DataPoint] = None + net_cash_flow_from_investing_activities_continuing: Optional[DataPoint] = None + net_cash_flow_from_investing_activities_discontinued: Optional[DataPoint] = None + net_cash_flow_from_financing_activities: Optional[DataPoint] = None + net_cash_flow_from_financing_activities_continuing: Optional[DataPoint] = None + net_cash_flow_from_financing_activities_discontinued: Optional[DataPoint] = None + exchange_gains_losses: Optional[DataPoint] = None + net_cash_flow: Optional[DataPoint] = None + net_cash_flow_continuing: Optional[DataPoint] = None + net_cash_flow_discontinued: Optional[DataPoint] = None @staticmethod - def from_dict(d): + def from_dict(d: Optional[Dict[str, Any]]) -> "CashFlowStatement": + if not d: + return CashFlowStatement() return CashFlowStatement( - exchange_gains_losses=( - None - if "exchange_gains_losses" not in d - else ExchangeGainsLosses.from_dict(d["exchange_gains_losses"]) - ), - net_cash_flow=( - None - if "net_cash_flow" not in d - else NetCashFlow.from_dict(d["net_cash_flow"]) - ), - net_cash_flow_from_financing_activities=( - None - if "net_cash_flow_from_financing_activities" not in d - else NetCashFlowFromFinancingActivities.from_dict( - d["net_cash_flow_from_financing_activities"] - ) + net_cash_flow_from_operating_activities=DataPoint.from_dict( + d.get("net_cash_flow_from_operating_activities") + ), + net_cash_flow_from_operating_activities_continuing=DataPoint.from_dict( + d.get("net_cash_flow_from_operating_activities_continuing") + ), + net_cash_flow_from_operating_activities_discontinued=DataPoint.from_dict( + d.get("net_cash_flow_from_operating_activities_discontinued") + ), + net_cash_flow_from_investing_activities=DataPoint.from_dict( + d.get("net_cash_flow_from_investing_activities") + ), + net_cash_flow_from_investing_activities_continuing=DataPoint.from_dict( + d.get("net_cash_flow_from_investing_activities_continuing") + ), + net_cash_flow_from_investing_activities_discontinued=DataPoint.from_dict( + d.get("net_cash_flow_from_investing_activities_discontinued") + ), + net_cash_flow_from_financing_activities=DataPoint.from_dict( + d.get("net_cash_flow_from_financing_activities") + ), + net_cash_flow_from_financing_activities_continuing=DataPoint.from_dict( + d.get("net_cash_flow_from_financing_activities_continuing") + ), + net_cash_flow_from_financing_activities_discontinued=DataPoint.from_dict( + d.get("net_cash_flow_from_financing_activities_discontinued") + ), + exchange_gains_losses=DataPoint.from_dict(d.get("exchange_gains_losses")), + net_cash_flow=DataPoint.from_dict(d.get("net_cash_flow")), + net_cash_flow_continuing=DataPoint.from_dict( + d.get("net_cash_flow_continuing") + ), + net_cash_flow_discontinued=DataPoint.from_dict( + d.get("net_cash_flow_discontinued") ), ) -@modelclass -class ComprehensiveIncomeLoss: - "Contains comprehensive income loss data for comprehensive income." - formula: Optional[str] = None - label: Optional[str] = None - order: Optional[int] = None - unit: Optional[str] = None - value: Optional[float] = None - xpath: Optional[str] = None - - @staticmethod - def from_dict(d): - return ComprehensiveIncomeLoss(**d) - - -@modelclass -class ComprehensiveIncomeLossAttributableToParent: - "Contains comprehensive income loss attributable to parent data for comprehensive income." - formula: Optional[str] = None - label: Optional[str] = None - order: Optional[int] = None - unit: Optional[str] = None - value: Optional[float] = None - xpath: Optional[str] = None - - @staticmethod - def from_dict(d): - return ComprehensiveIncomeLossAttributableToParent(**d) - - -@modelclass -class OtherComprehensiveIncomeLoss: - "Contains other comprehensive income loss data for comprehensive income." - formula: Optional[str] = None - label: Optional[str] = None - order: Optional[int] = None - unit: Optional[str] = None - value: Optional[float] = None - xpath: Optional[str] = None - - @staticmethod - def from_dict(d): - return OtherComprehensiveIncomeLoss(**d) - - +@dataclass @modelclass class ComprehensiveIncome: - "Contains comprehensive income data." - comprehensive_income_loss: Optional[ComprehensiveIncomeLoss] = None - comprehensive_income_loss_attributable_to_parent: Optional[ - ComprehensiveIncomeLossAttributableToParent + comprehensive_income_loss: Optional[DataPoint] = None + comprehensive_income_loss_attributable_to_noncontrolling_interest: Optional[ + DataPoint + ] = None + comprehensive_income_loss_attributable_to_parent: Optional[DataPoint] = None + other_comprehensive_income_loss: Optional[DataPoint] = None + other_comprehensive_income_loss_attributable_to_noncontrolling_interest: Optional[ + DataPoint ] = None - other_comprehensive_income_loss: Optional[OtherComprehensiveIncomeLoss] = None + other_comprehensive_income_loss_attributable_to_parent: Optional[DataPoint] = None @staticmethod - def from_dict(d): + def from_dict(d: Optional[Dict[str, Any]]) -> "ComprehensiveIncome": + if not d: + return ComprehensiveIncome() return ComprehensiveIncome( - comprehensive_income_loss=( - None - if "comprehensive_income_loss" not in d - else ComprehensiveIncomeLoss.from_dict(d["comprehensive_income_loss"]) - ), - comprehensive_income_loss_attributable_to_parent=( - None - if "comprehensive_income_loss_attributable_to_parent" not in d - else ComprehensiveIncomeLossAttributableToParent.from_dict( - d["comprehensive_income_loss_attributable_to_parent"] + comprehensive_income_loss=DataPoint.from_dict( + d.get("comprehensive_income_loss") + ), + comprehensive_income_loss_attributable_to_noncontrolling_interest=DataPoint.from_dict( + d.get( + "comprehensive_income_loss_attributable_to_noncontrolling_interest" ) ), - other_comprehensive_income_loss=( - None - if "other_comprehensive_income_loss" not in d - else OtherComprehensiveIncomeLoss.from_dict( - d["other_comprehensive_income_loss"] + comprehensive_income_loss_attributable_to_parent=DataPoint.from_dict( + d.get("comprehensive_income_loss_attributable_to_parent") + ), + other_comprehensive_income_loss=DataPoint.from_dict( + d.get("other_comprehensive_income_loss") + ), + other_comprehensive_income_loss_attributable_to_noncontrolling_interest=DataPoint.from_dict( + d.get( + "other_comprehensive_income_loss_attributable_to_noncontrolling_interest" ) ), + other_comprehensive_income_loss_attributable_to_parent=DataPoint.from_dict( + d.get("other_comprehensive_income_loss_attributable_to_parent") + ), ) -@modelclass -class BasicEarningsPerShare: - "Contains basic earning per share data for an income statement." - formula: Optional[str] = None - label: Optional[str] = None - order: Optional[int] = None - unit: Optional[str] = None - value: Optional[float] = None - xpath: Optional[str] = None - - @staticmethod - def from_dict(d): - return BasicEarningsPerShare(**d) - - -@modelclass -class CostOfRevenue: - "Contains cost of revenue data for an income statement." - formula: Optional[str] = None - label: Optional[str] = None - order: Optional[int] = None - unit: Optional[str] = None - value: Optional[float] = None - xpath: Optional[str] = None - - @staticmethod - def from_dict(d): - return CostOfRevenue(**d) - - -@modelclass -class GrossProfit: - "Contains gross profit data for an income statement." - formula: Optional[str] = None - label: Optional[str] = None - order: Optional[int] = None - unit: Optional[str] = None - value: Optional[float] = None - xpath: Optional[str] = None - - @staticmethod - def from_dict(d): - return GrossProfit(**d) - - -@modelclass -class OperatingExpenses: - "Contains operating expenses data for an income statement." - formula: Optional[str] = None - label: Optional[str] = None - order: Optional[int] = None - unit: Optional[str] = None - value: Optional[float] = None - xpath: Optional[str] = None - - @staticmethod - def from_dict(d): - return OperatingExpenses(**d) - - -@modelclass -class Revenues: - "Contains revenues data for an income statement." - formula: Optional[str] = None - label: Optional[str] = None - order: Optional[int] = None - unit: Optional[str] = None - value: Optional[float] = None - xpath: Optional[str] = None - - @staticmethod - def from_dict(d): - return Revenues(**d) - - +@dataclass @modelclass class IncomeStatement: - "Contains income statement data." - basic_earnings_per_share: Optional[BasicEarningsPerShare] = None - cost_of_revenue: Optional[CostOfRevenue] = None - gross_profit: Optional[GrossProfit] = None - operating_expenses: Optional[OperatingExpenses] = None - revenues: Optional[Revenues] = None + revenues: Optional[DataPoint] = None + benefits_costs_expenses: Optional[DataPoint] = None + cost_of_revenue: Optional[DataPoint] = None + cost_of_revenue_goods: Optional[DataPoint] = None + cost_of_revenue_services: Optional[DataPoint] = None + costs_and_expenses: Optional[DataPoint] = None + gross_profit: Optional[DataPoint] = None + gain_loss_on_sale_properties_net_tax: Optional[DataPoint] = None + nonoperating_income_loss: Optional[DataPoint] = None + operating_expenses: Optional[DataPoint] = None + selling_general_and_administrative_expenses: Optional[DataPoint] = None + depreciation_and_amortization: Optional[DataPoint] = None + research_and_development: Optional[DataPoint] = None + other_operating_expenses: Optional[DataPoint] = None + operating_income_loss: Optional[DataPoint] = None + other_operating_income_expenses: Optional[DataPoint] = None + income_loss_before_equity_method_investments: Optional[DataPoint] = None + income_loss_from_continuing_operations_after_tax: Optional[DataPoint] = None + income_loss_from_continuing_operations_before_tax: Optional[DataPoint] = None + income_loss_from_discontinued_operations_net_of_tax: Optional[DataPoint] = None + income_loss_from_discontinued_operations_net_of_tax_adjustment_to_prior_year_gain_loss_on_disposal: Optional[ + DataPoint + ] = None + income_loss_from_discontinued_operations_net_of_tax_during_phase_out: Optional[ + DataPoint + ] = None + income_loss_from_discontinued_operations_net_of_tax_gain_loss_on_disposal: Optional[ + DataPoint + ] = None + income_loss_from_discontinued_operations_net_of_tax_provision_for_gain_loss_on_disposal: Optional[ + DataPoint + ] = None + income_loss_from_equity_method_investments: Optional[DataPoint] = None + income_tax_expense_benefit: Optional[DataPoint] = None + income_tax_expense_benefit_current: Optional[DataPoint] = None + income_tax_expense_benefit_deferred: Optional[DataPoint] = None + interest_and_debt_expense: Optional[DataPoint] = None + interest_and_dividend_income_operating: Optional[DataPoint] = None + interest_expense_operating: Optional[DataPoint] = None + interest_income_expense_after_provision_for_losses: Optional[DataPoint] = None + interest_income_expense_operating_net: Optional[DataPoint] = None + noninterest_expense: Optional[DataPoint] = None + noninterest_income: Optional[DataPoint] = None + provision_for_loan_lease_and_other_losses: Optional[DataPoint] = None + net_income_loss: Optional[DataPoint] = None + net_income_loss_attributable_to_noncontrolling_interest: Optional[DataPoint] = None + net_income_loss_attributable_to_nonredeemable_noncontrolling_interest: Optional[ + DataPoint + ] = None + net_income_loss_attributable_to_parent: Optional[DataPoint] = None + net_income_loss_attributable_to_redeemable_noncontrolling_interest: Optional[ + DataPoint + ] = None + net_income_loss_available_to_common_stockholders_basic: Optional[DataPoint] = None + participating_securities_distributed_and_undistributed_earnings_loss_basic: ( + Optional[DataPoint] + ) = (None) + undistributed_earnings_loss_allocated_to_participating_securities_basic: Optional[ + DataPoint + ] = None + preferred_stock_dividends_and_other_adjustments: Optional[DataPoint] = None + basic_earnings_per_share: Optional[DataPoint] = None + diluted_earnings_per_share: Optional[DataPoint] = None + basic_average_shares: Optional[DataPoint] = None + diluted_average_shares: Optional[DataPoint] = None + common_stock_dividends: Optional[DataPoint] = None @staticmethod - def from_dict(d): + def from_dict(d: Optional[Dict[str, Any]]) -> "IncomeStatement": + if not d: + return IncomeStatement() return IncomeStatement( - basic_earnings_per_share=( - None - if "basic_earnings_per_share" not in d - else BasicEarningsPerShare.from_dict(d["basic_earnings_per_share"]) - ), - cost_of_revenue=( - None - if "cost_of_revenue" not in d - else CostOfRevenue.from_dict(d["cost_of_revenue"]) - ), - gross_profit=( - None - if "gross_profit" not in d - else GrossProfit.from_dict(d["gross_profit"]) - ), - operating_expenses=( - None - if "operating_expenses" not in d - else OperatingExpenses.from_dict(d["operating_expenses"]) - ), - revenues=None if "revenues" not in d else Revenues.from_dict(d["revenues"]), + revenues=DataPoint.from_dict(d.get("revenues")), + benefits_costs_expenses=DataPoint.from_dict( + d.get("benefits_costs_expenses") + ), + cost_of_revenue=DataPoint.from_dict(d.get("cost_of_revenue")), + cost_of_revenue_goods=DataPoint.from_dict(d.get("cost_of_revenue_goods")), + cost_of_revenue_services=DataPoint.from_dict( + d.get("cost_of_revenue_services") + ), + costs_and_expenses=DataPoint.from_dict(d.get("costs_and_expenses")), + gross_profit=DataPoint.from_dict(d.get("gross_profit")), + gain_loss_on_sale_properties_net_tax=DataPoint.from_dict( + d.get("gain_loss_on_sale_properties_net_tax") + ), + nonoperating_income_loss=DataPoint.from_dict( + d.get("nonoperating_income_loss") + ), + operating_expenses=DataPoint.from_dict(d.get("operating_expenses")), + selling_general_and_administrative_expenses=DataPoint.from_dict( + d.get("selling_general_and_administrative_expenses") + ), + depreciation_and_amortization=DataPoint.from_dict( + d.get("depreciation_and_amortization") + ), + research_and_development=DataPoint.from_dict( + d.get("research_and_development") + ), + other_operating_expenses=DataPoint.from_dict( + d.get("other_operating_expenses") + ), + operating_income_loss=DataPoint.from_dict(d.get("operating_income_loss")), + other_operating_income_expenses=DataPoint.from_dict( + d.get("other_operating_income_expenses") + ), + income_loss_before_equity_method_investments=DataPoint.from_dict( + d.get("income_loss_before_equity_method_investments") + ), + income_loss_from_continuing_operations_after_tax=DataPoint.from_dict( + d.get("income_loss_from_continuing_operations_after_tax") + ), + income_loss_from_continuing_operations_before_tax=DataPoint.from_dict( + d.get("income_loss_from_continuing_operations_before_tax") + ), + income_loss_from_discontinued_operations_net_of_tax=DataPoint.from_dict( + d.get("income_loss_from_discontinued_operations_net_of_tax") + ), + income_loss_from_discontinued_operations_net_of_tax_adjustment_to_prior_year_gain_loss_on_disposal=DataPoint.from_dict( + d.get( + "income_loss_from_discontinued_operations_net_of_tax_adjustment_to_prior_year_gain_loss_on_disposal" + ) + ), + income_loss_from_discontinued_operations_net_of_tax_during_phase_out=DataPoint.from_dict( + d.get( + "income_loss_from_discontinued_operations_net_of_tax_during_phase_out" + ) + ), + income_loss_from_discontinued_operations_net_of_tax_gain_loss_on_disposal=DataPoint.from_dict( + d.get( + "income_loss_from_discontinued_operations_net_of_tax_gain_loss_on_disposal" + ) + ), + income_loss_from_discontinued_operations_net_of_tax_provision_for_gain_loss_on_disposal=DataPoint.from_dict( + d.get( + "income_loss_from_discontinued_operations_net_of_tax_provision_for_gain_loss_on_disposal" + ) + ), + income_loss_from_equity_method_investments=DataPoint.from_dict( + d.get("income_loss_from_equity_method_investments") + ), + income_tax_expense_benefit=DataPoint.from_dict( + d.get("income_tax_expense_benefit") + ), + income_tax_expense_benefit_current=DataPoint.from_dict( + d.get("income_tax_expense_benefit_current") + ), + income_tax_expense_benefit_deferred=DataPoint.from_dict( + d.get("income_tax_expense_benefit_deferred") + ), + interest_and_debt_expense=DataPoint.from_dict( + d.get("interest_and_debt_expense") + ), + interest_and_dividend_income_operating=DataPoint.from_dict( + d.get("interest_and_dividend_income_operating") + ), + interest_expense_operating=DataPoint.from_dict( + d.get("interest_expense_operating") + ), + interest_income_expense_after_provision_for_losses=DataPoint.from_dict( + d.get("interest_income_expense_after_provision_for_losses") + ), + interest_income_expense_operating_net=DataPoint.from_dict( + d.get("interest_income_expense_operating_net") + ), + noninterest_expense=DataPoint.from_dict(d.get("noninterest_expense")), + noninterest_income=DataPoint.from_dict(d.get("noninterest_income")), + provision_for_loan_lease_and_other_losses=DataPoint.from_dict( + d.get("provision_for_loan_lease_and_other_losses") + ), + net_income_loss=DataPoint.from_dict(d.get("net_income_loss")), + net_income_loss_attributable_to_noncontrolling_interest=DataPoint.from_dict( + d.get("net_income_loss_attributable_to_noncontrolling_interest") + ), + net_income_loss_attributable_to_nonredeemable_noncontrolling_interest=DataPoint.from_dict( + d.get( + "net_income_loss_attributable_to_nonredeemable_noncontrolling_interest" + ) + ), + net_income_loss_attributable_to_parent=DataPoint.from_dict( + d.get("net_income_loss_attributable_to_parent") + ), + net_income_loss_attributable_to_redeemable_noncontrolling_interest=DataPoint.from_dict( + d.get( + "net_income_loss_attributable_to_redeemable_noncontrolling_interest" + ) + ), + net_income_loss_available_to_common_stockholders_basic=DataPoint.from_dict( + d.get("net_income_loss_available_to_common_stockholders_basic") + ), + participating_securities_distributed_and_undistributed_earnings_loss_basic=DataPoint.from_dict( + d.get( + "participating_securities_distributed_and_undistributed_earnings_loss_basic" + ) + ), + undistributed_earnings_loss_allocated_to_participating_securities_basic=DataPoint.from_dict( + d.get( + "undistributed_earnings_loss_allocated_to_participating_securities_basic" + ) + ), + preferred_stock_dividends_and_other_adjustments=DataPoint.from_dict( + d.get("preferred_stock_dividends_and_other_adjustments") + ), + basic_earnings_per_share=DataPoint.from_dict( + d.get("basic_earnings_per_share") + ), + diluted_earnings_per_share=DataPoint.from_dict( + d.get("diluted_earnings_per_share") + ), + basic_average_shares=DataPoint.from_dict(d.get("basic_average_shares")), + diluted_average_shares=DataPoint.from_dict(d.get("diluted_average_shares")), + common_stock_dividends=DataPoint.from_dict(d.get("common_stock_dividends")), ) +@dataclass @modelclass class Financials: - "Contains financial data." - balance_sheet: Optional[Dict[str, DataPoint]] = None + """ + Contains data for: + - balance_sheet (BalanceSheet) + - cash_flow_statement (CashFlowStatement) + - comprehensive_income (ComprehensiveIncome) + - income_statement (IncomeStatement) + """ + + balance_sheet: Optional[BalanceSheet] = None cash_flow_statement: Optional[CashFlowStatement] = None comprehensive_income: Optional[ComprehensiveIncome] = None income_statement: Optional[IncomeStatement] = None @staticmethod - def from_dict(d): + def from_dict(d: Optional[Dict[str, Any]]) -> "Financials": + if not d: + return Financials() return Financials( - balance_sheet=( - None - if "balance_sheet" not in d - else { - k: DataPoint.from_dict(v) for (k, v) in d["balance_sheet"].items() - } - ), - cash_flow_statement=( - None - if "cash_flow_statement" not in d - else CashFlowStatement.from_dict(d["cash_flow_statement"]) - ), - comprehensive_income=( - None - if "comprehensive_income" not in d - else ComprehensiveIncome.from_dict(d["comprehensive_income"]) - ), - income_statement=( - None - if "income_statement" not in d - else IncomeStatement.from_dict(d["income_statement"]) + balance_sheet=BalanceSheet.from_dict(d.get("balance_sheet")), + cash_flow_statement=CashFlowStatement.from_dict( + d.get("cash_flow_statement") + ), + comprehensive_income=ComprehensiveIncome.from_dict( + d.get("comprehensive_income") ), + income_statement=IncomeStatement.from_dict(d.get("income_statement")), ) +@dataclass @modelclass class StockFinancial: - "StockFinancial contains historical financial data for a stock ticker." + """ + StockFinancial contains historical financial data for a stock ticker. + The 'financials' attribute references an instance of Financials + which has typed sub-statements. + """ + cik: Optional[str] = None company_name: Optional[str] = None end_date: Optional[str] = None @@ -335,18 +510,18 @@ class StockFinancial: start_date: Optional[str] = None @staticmethod - def from_dict(d): + def from_dict(d: Optional[Dict[str, Any]]) -> "StockFinancial": + if not d: + return StockFinancial() return StockFinancial( - cik=d.get("cik", None), - company_name=d.get("company_name", None), - end_date=d.get("end_date", None), - filing_date=d.get("filing_date", None), - financials=( - None if "financials" not in d else Financials.from_dict(d["financials"]) - ), - fiscal_period=d.get("fiscal_period", None), - fiscal_year=d.get("fiscal_year", None), - source_filing_file_url=d.get("source_filing_file_url", None), - source_filing_url=d.get("source_filing_url", None), - start_date=d.get("start_date", None), + cik=d.get("cik"), + company_name=d.get("company_name"), + end_date=d.get("end_date"), + filing_date=d.get("filing_date"), + financials=Financials.from_dict(d.get("financials", {})), + fiscal_period=d.get("fiscal_period"), + fiscal_year=d.get("fiscal_year"), + source_filing_file_url=d.get("source_filing_file_url"), + source_filing_url=d.get("source_filing_url"), + start_date=d.get("start_date"), ) diff --git a/test_rest/mocks/vX/reference/financials.json b/test_rest/mocks/vX/reference/financials.json index c5e18621..ae84513b 100644 --- a/test_rest/mocks/vX/reference/financials.json +++ b/test_rest/mocks/vX/reference/financials.json @@ -45,12 +45,6 @@ "unit": "USD", "order": 400 }, - "other_than_fixed_noncurrent_assets": { - "label": "Other Than Fixed Noncurrent Assets", - "value": 1.6046e+10, - "unit": "USD", - "order": 500 - }, "noncurrent_liabilities": { "label": "Noncurrent Liabilities", "value": 1.1716e+10, diff --git a/test_rest/test_financials.py b/test_rest/test_financials.py deleted file mode 100644 index f5196212..00000000 --- a/test_rest/test_financials.py +++ /dev/null @@ -1,234 +0,0 @@ -from polygon.rest.models import ( - StockFinancial, - Financials, - DataPoint, - CashFlowStatement, - ExchangeGainsLosses, - NetCashFlow, - NetCashFlowFromFinancingActivities, - ComprehensiveIncome, - ComprehensiveIncomeLoss, - ComprehensiveIncomeLossAttributableToParent, - OtherComprehensiveIncomeLoss, - IncomeStatement, - BasicEarningsPerShare, - CostOfRevenue, - GrossProfit, - OperatingExpenses, - Revenues, -) -from base import BaseTest - - -class FinancialsTest(BaseTest): - def test_list_stock_financials(self): - financials = [f for f in self.c.vx.list_stock_financials()] - expected = [ - StockFinancial( - cik="0001413447", - company_name="NXP Semiconductors N.V.", - end_date="2022-04-03", - filing_date="2022-05-03", - financials=Financials( - balance_sheet={ - "equity_attributable_to_noncontrolling_interest": DataPoint( - formula=None, - label="Equity Attributable To Noncontrolling Interest", - order=1500, - unit="USD", - value=251000000.0, - xpath=None, - ), - "liabilities": DataPoint( - formula=None, - label="Liabilities", - order=600, - unit="USD", - value=14561000000.0, - xpath=None, - ), - "equity_attributable_to_parent": DataPoint( - formula=None, - label="Equity Attributable To Parent", - order=1600, - unit="USD", - value=6509000000.0, - xpath=None, - ), - "noncurrent_assets": DataPoint( - formula=None, - label="Noncurrent Assets", - order=300, - unit="USD", - value=16046000000.0, - xpath=None, - ), - "liabilities_and_equity": DataPoint( - formula=None, - label="Liabilities And Equity", - order=1900, - unit="USD", - value=21321000000.0, - xpath=None, - ), - "assets": DataPoint( - formula=None, - label="Assets", - order=100, - unit="USD", - value=21321000000.0, - xpath=None, - ), - "fixed_assets": DataPoint( - formula=None, - label="Fixed Assets", - order=400, - unit="USD", - value=2814000000.0, - xpath=None, - ), - "other_than_fixed_noncurrent_assets": DataPoint( - formula=None, - label="Other Than Fixed Noncurrent Assets", - order=500, - unit="USD", - value=16046000000.0, - xpath=None, - ), - "noncurrent_liabilities": DataPoint( - formula=None, - label="Noncurrent Liabilities", - order=800, - unit="USD", - value=11716000000.0, - xpath=None, - ), - "current_assets": DataPoint( - formula=None, - label="Current Assets", - order=200, - unit="USD", - value=5275000000.0, - xpath=None, - ), - "equity": DataPoint( - formula=None, - label="Equity", - order=1400, - unit="USD", - value=6760000000.0, - xpath=None, - ), - "current_liabilities": DataPoint( - formula=None, - label="Current Liabilities", - order=700, - unit="USD", - value=2845000000.0, - xpath=None, - ), - }, - cash_flow_statement=CashFlowStatement( - exchange_gains_losses=ExchangeGainsLosses( - formula=None, - label="Exchange Gains/Losses", - order=1000, - unit="USD", - value=0, - xpath=None, - ), - net_cash_flow=NetCashFlow( - formula=None, - label="Net Cash Flow", - order=1100, - unit="USD", - value=-147000000.0, - xpath=None, - ), - net_cash_flow_from_financing_activities=NetCashFlowFromFinancingActivities( - formula=None, - label="Net Cash Flow From Financing Activities", - order=700, - unit="USD", - value=-674000000.0, - xpath=None, - ), - ), - comprehensive_income=ComprehensiveIncome( - comprehensive_income_loss=ComprehensiveIncomeLoss( - formula=None, - label="Comprehensive Income/Loss", - order=100, - unit="USD", - value=644000000.0, - xpath=None, - ), - comprehensive_income_loss_attributable_to_parent=ComprehensiveIncomeLossAttributableToParent( - formula=None, - label="Comprehensive Income/Loss Attributable To Parent", - order=300, - unit="USD", - value=635000000.0, - xpath=None, - ), - other_comprehensive_income_loss=OtherComprehensiveIncomeLoss( - formula=None, - label="Other Comprehensive Income/Loss", - order=400, - unit="USD", - value=-22000000.0, - xpath=None, - ), - ), - income_statement=IncomeStatement( - basic_earnings_per_share=BasicEarningsPerShare( - formula=None, - label="Basic Earnings Per Share", - order=4200, - unit="USD / shares", - value=2.5, - xpath=None, - ), - cost_of_revenue=CostOfRevenue( - formula=None, - label="Cost Of Revenue", - order=300, - unit="USD", - value=1359000000.0, - xpath=None, - ), - gross_profit=GrossProfit( - formula=None, - label="Gross Profit", - order=800, - unit="USD", - value=1777000000.0, - xpath=None, - ), - operating_expenses=OperatingExpenses( - formula=None, - label="Operating Expenses", - order=1000, - unit="USD", - value=904000000.0, - xpath=None, - ), - revenues=Revenues( - formula=None, - label="Revenues", - order=100, - unit="USD", - value=3136000000.0, - xpath=None, - ), - ), - ), - fiscal_period="Q1", - fiscal_year="2022", - source_filing_file_url="https://api.polygon.io/v1/reference/sec/filings/0001413447-22-000014/files/nxpi-20220403_htm.xml", - source_filing_url="https://api.polygon.io/v1/reference/sec/filings/0001413447-22-000014", - start_date="2022-01-01", - ) - ] - - self.assertEqual(financials, expected)