bullishpy 0.5.0__tar.gz → 0.6.0__tar.gz

{bullishpy-0.5.0 → bullishpy-0.6.0}/PKG-INFO

@@ -1,13 +1,11 @@
 Metadata-Version: 2.3
 Name: bullishpy
-Version: 0.5.0
+Version: 0.6.0
 Summary: 
 Author: aan
 Author-email: andoludovic.andriamamonjy@gmail.com
-Requires-Python: >=3.10,<3.13
+Requires-Python: >=3.12,<3.13
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: bearishpy (>=0.20.0,<0.21.0)
 Requires-Dist: huey (>=2.5.3,<3.0.0)
@@ -16,6 +14,7 @@ Requires-Dist: plotly (>=6.1.2,<7.0.0)
 Requires-Dist: streamlit (>=1.45.1,<2.0.0)
 Requires-Dist: streamlit-file-browser (>=3.2.22,<4.0.0)
 Requires-Dist: streamlit-pydantic (>=v0.6.1-rc.3,<0.7.0)
+Requires-Dist: ta-lib (>=0.6.4,<0.7.0)
 Requires-Dist: tickermood (>=0.4.0,<0.5.0)
 Description-Content-Type: text/markdown
 

{bullishpy-0.5.0 → bullishpy-0.6.0}/bullish/analysis/analysis.py

@@ -1,5 +1,4 @@
 import logging
-from datetime import date
 from typing import (
     Annotated,
     Any,
@@ -7,13 +6,12 @@ from typing import (
     Optional,
     Sequence,
     Type,
-    cast,
     get_args,
     TYPE_CHECKING,
+    ClassVar,
 )
 
 import pandas as pd
-import pandas_ta as ta  # type: ignore
 from bearish.interface.interface import BearishDbBase  # type: ignore
 from bearish.models.assets.equity import BaseEquity  # type: ignore
 from bearish.models.base import (  # type: ignore
@@ -41,6 +39,8 @@ from bearish.models.query.query import AssetQuery, Symbols  # type: ignore
 from bearish.types import TickerOnlySources  # type: ignore
 from pydantic import BaseModel, BeforeValidator, Field, create_model
 
+from bullish.analysis.indicators import Indicators, IndicatorModels
+
 if TYPE_CHECKING:
     from bullish.database.crud import BullishDb
 
@@ -61,59 +61,6 @@ def to_float(value: Any) -> Optional[float]:
     return float(value)
 
 
-def price_growth(prices: pd.DataFrame, days: int, max: bool = False) -> Optional[float]:
-    prices_ = prices.copy()
-    last_index = prices_.last_valid_index()
-    delta = pd.Timedelta(days=days)
-    start_index = last_index - delta  # type: ignore
-
-    try:
-        closest_index = prices_.index.unique().asof(start_index)  # type: ignore
-        price = (
-            prices_.loc[closest_index].close
-            if not max
-            else prices_[closest_index:].close.max()
-        )
-    except Exception as e:
-        logger.warning(
-            f"""Failing to calculate price growth: {e}.""",
-            exc_info=True,
-        )
-        return None
-    return (  # type: ignore
-        (prices_.loc[last_index].close - price) * 100 / prices_.loc[last_index].close
-    )
-
-
-def buy_opportunity(
-    series_a: pd.Series, series_b: pd.Series  # type: ignore
-) -> Optional[date]:
-    sell = ta.cross(series_a=series_a, series_b=series_b)
-    buy = ta.cross(series_a=series_b, series_b=series_a)
-    if not buy[buy == 1].index.empty and not sell[sell == 1].index.empty:
-        last_buy_signal = pd.Timestamp(buy[buy == 1].index[-1])
-        last_sell_signal = pd.Timestamp(sell[sell == 1].index[-1])
-        if last_buy_signal > last_sell_signal:
-            return last_buy_signal
-    return None
-
-
-def perc(data: pd.Series) -> float:  # type: ignore
-    return cast(float, ((data.iloc[-1] - data.iloc[0]) / data.iloc[0]) * 100)
-
-
-def yoy(prices: pd.DataFrame) -> pd.Series:  # type: ignore
-    return prices.close.resample("YE").apply(perc)  # type: ignore
-
-
-def mom(prices: pd.DataFrame) -> pd.Series:  # type: ignore
-    return prices.close.resample("ME").apply(perc)  # type: ignore
-
-
-def wow(prices: pd.DataFrame) -> pd.Series:  # type: ignore
-    return prices.close.resample("W").apply(perc)  # type: ignore
-
-
 def _load_data(
     data: Sequence[DataSourceBase], symbol: str, class_: Type[DataSourceBase]
 ) -> pd.DataFrame:
@@ -128,23 +75,23 @@ def _load_data(
         return pd.DataFrame(columns=columns).sort_index()
 
 
-def _compute_growth(series: pd.Series) -> bool:  # type: ignore
+def _compute_growth(series: pd.Series) -> bool:
     if series.empty:
         return False
     return all(series.pct_change(fill_method=None).dropna() > 0)
 
 
-def _all_positive(series: pd.Series) -> bool:  # type: ignore
+def _all_positive(series: pd.Series) -> bool:
     if series.empty:
         return False
     return all(series.dropna() > 0)
 
 
-def _get_last(data: pd.Series) -> Optional[float]:  # type: ignore
+def _get_last(data: pd.Series) -> Optional[float]:
     return data.iloc[-1] if not data.empty else None
 
 
-def _abs(data: pd.Series) -> pd.Series:  # type: ignore
+def _abs(data: pd.Series) -> pd.Series:
     try:
         return abs(data)
     except Exception as e:
@@ -152,19 +99,8 @@ def _abs(data: pd.Series) -> pd.Series:  # type: ignore
         return data
 
 
-class TechnicalAnalysis(BaseModel):
-    rsi_last_value: Optional[float] = Field(
-        None, alias="RSI Last value", description="RSI last value", ge=0, le=100
-    )
-    macd_12_26_9_buy_date: Optional[date] = None
-    ma_50_200_buy_date: Optional[date] = None
-    slope_7: Optional[float] = None
-    slope_14: Optional[float] = None
-    slope_30: Optional[float] = None
-    slope_60: Optional[float] = None
-    last_adx: Optional[float] = None
-    last_dmp: Optional[float] = None
-    last_dmn: Optional[float] = None
+class TechnicalAnalysisBase(BaseModel):
+    _description: ClassVar[str] = "General technical indicators"
     last_price: Annotated[
         Optional[float],
         BeforeValidator(to_float),
@@ -172,191 +108,113 @@ class TechnicalAnalysis(BaseModel):
             default=None,
         ),
     ]
-    last_price_date: Annotated[
-        Optional[date],
-        Field(
-            default=None,
-        ),
-    ]
-    year_to_date_growth: Annotated[
-        Optional[float],
-        Field(
-            default=None,
-        ),
-    ]
-    last_52_weeks_growth: Annotated[
-        Optional[float],
-        Field(
-            default=None,
-        ),
-    ]
-    last_week_growth: Annotated[
-        Optional[float],
-        Field(
-            default=None,
-        ),
-    ]
-    last_month_growth: Annotated[
-        Optional[float],
-        Field(
-            default=None,
-        ),
-    ]
-    last_year_growth: Annotated[
-        Optional[float],
-        Field(
-            default=None,
-        ),
-    ]
-    year_to_date_max_growth: Annotated[
-        Optional[float],
-        Field(
-            default=None,
-        ),
-    ]
-    last_week_max_growth: Annotated[
-        Optional[float],
-        Field(
-            default=None,
-        ),
-    ]
-    last_month_max_growth: Annotated[
-        Optional[float],
-        Field(
-            default=None,
-        ),
-    ]
-    last_year_max_growth: Annotated[
-        Optional[float],
-        Field(
-            default=None,
-        ),
-    ]
-    macd_12_26_9_buy: Annotated[
-        Optional[float],
-        Field(
-            default=None,
-        ),
-    ]
-    star_yoy: Annotated[
-        Optional[float],
-        Field(
-            default=None,
-        ),
-    ]
-    star_wow: Annotated[
-        Optional[float],
-        Field(
-            default=None,
-        ),
-    ]
-    star_mom: Annotated[
-        Optional[float],
-        Field(
-            default=None,
-        ),
-    ]
+
+
+TechnicalAnalysisModels = [*IndicatorModels, TechnicalAnalysisBase]
+
+
+class TechnicalAnalysis(*TechnicalAnalysisModels):  # type: ignore
 
     @classmethod
     def from_data(cls, prices: pd.DataFrame) -> "TechnicalAnalysis":
         try:
-            last_index = prices.last_valid_index()
-            year_to_date_days = (
-                last_index
-                - pd.Timestamp(year=last_index.year, month=1, day=1, tz="UTC")  # type: ignore
-            ).days
-            year_to_date_growth = price_growth(prices, year_to_date_days)
-            last_52_weeks_growth = price_growth(prices=prices, days=399)
-            last_week_growth = price_growth(prices=prices, days=7)
-            last_month_growth = price_growth(prices=prices, days=31)
-            last_year_growth = price_growth(prices=prices, days=365)
-            year_to_date_max_growth = price_growth(prices, year_to_date_days, max=True)
-            last_week_max_growth = price_growth(prices=prices, days=7, max=True)
-            last_month_max_growth = price_growth(prices=prices, days=31, max=True)
-            last_year_max_growth = price_growth(prices=prices, days=365, max=True)
-            prices.ta.sma(50, append=True)
-            prices.ta.sma(200, append=True)
-            prices.ta.adx(append=True)
-            prices["SLOPE_14"] = ta.linreg(prices.close, slope=True, length=14)
-            prices["SLOPE_7"] = ta.linreg(prices.close, slope=True, length=7)
-            prices["SLOPE_30"] = ta.linreg(prices.close, slope=True, length=30)
-            prices["SLOPE_60"] = ta.linreg(prices.close, slope=True, length=60)
-            prices.ta.macd(append=True)
-            prices.ta.rsi(append=True)
-
-            rsi_last_value = prices.RSI_14.iloc[-1]
-            macd_12_26_9_buy_date = buy_opportunity(
-                prices.MACDs_12_26_9, prices.MACD_12_26_9
-            )
-            star_yoy = yoy(prices).median()
-            star_mom = mom(prices).median()
-            star_wow = wow(prices).median()
-            try:
-                macd_12_26_9_buy = (
-                    prices.MACD_12_26_9.iloc[-1] > prices.MACDs_12_26_9.iloc[-1]
-                )
-            except Exception as e:
-                logger.warning(
-                    f"Failing to calculate MACD buy date: {e}", exc_info=True
-                )
-                macd_12_26_9_buy = None
-            ma_50_200_buy_date = buy_opportunity(prices.SMA_200, prices.SMA_50)
-            return cls(
-                rsi_last_value=rsi_last_value,
-                macd_12_26_9_buy_date=macd_12_26_9_buy_date,
-                macd_12_26_9_buy=macd_12_26_9_buy,
-                ma_50_200_buy_date=ma_50_200_buy_date,
-                last_price=prices.close.iloc[-1],
-                last_price_date=prices.index[-1],
-                last_adx=prices.ADX_14.iloc[-1],
-                last_dmp=prices.DMP_14.iloc[-1],
-                last_dmn=prices.DMN_14.iloc[-1],
-                slope_7=prices.SLOPE_7.iloc[-1],
-                slope_14=prices.SLOPE_14.iloc[-1],
-                slope_30=prices.SLOPE_30.iloc[-1],
-                slope_60=prices.SLOPE_60.iloc[-1],
-                year_to_date_growth=year_to_date_growth,
-                last_52_weeks_growth=last_52_weeks_growth,
-                last_week_growth=last_week_growth,
-                last_month_growth=last_month_growth,
-                last_year_growth=last_year_growth,
-                year_to_date_max_growth=year_to_date_max_growth,
-                last_week_max_growth=last_week_max_growth,
-                last_month_max_growth=last_month_max_growth,
-                last_year_max_growth=last_year_max_growth,
-                star_yoy=star_yoy,
-                star_mom=star_mom,
-                star_wow=star_wow,
-            )
+            res = Indicators().to_dict(prices)
+            return cls(last_price=prices.close.iloc[-1], **res)
         except Exception as e:
             logger.error(f"Failing to calculate technical analysis: {e}", exc_info=True)
-            return cls()  # type: ignore
+            return cls()
 
 
 class BaseFundamentalAnalysis(BaseModel):
-    positive_debt_to_equity: Optional[bool] = None
-    positive_return_on_assets: Optional[bool] = None
-    positive_return_on_equity: Optional[bool] = None
-    positive_diluted_eps: Optional[bool] = None
-    positive_basic_eps: Optional[bool] = None
-    growing_basic_eps: Optional[bool] = None
-    growing_diluted_eps: Optional[bool] = None
-    positive_net_income: Optional[bool] = None
-    positive_operating_income: Optional[bool] = None
-    growing_net_income: Optional[bool] = None
-    growing_operating_income: Optional[bool] = None
-    positive_free_cash_flow: Optional[bool] = None
-    growing_operating_cash_flow: Optional[bool] = None
-    operating_cash_flow_is_higher_than_net_income: Optional[bool] = None
-
-    mean_capex_ratio: Optional[float] = None
-    max_capex_ratio: Optional[float] = None
-    min_capex_ratio: Optional[float] = None
-    mean_dividend_payout_ratio: Optional[float] = None
-    max_dividend_payout_ratio: Optional[float] = None
-    min_dividend_payout_ratio: Optional[float] = None
-
-    earning_per_share: Optional[float] = None
+    positive_debt_to_equity: Optional[bool] = Field(
+        None,
+        description="True if the company's debt-to-equity ratio is favorable (typically low or improving).",
+    )
+    positive_return_on_assets: Optional[bool] = Field(
+        None,
+        description="True if the company reports a positive return on assets (ROA), "
+        "indicating efficient use of its assets.",
+    )
+    positive_return_on_equity: Optional[bool] = Field(
+        None,
+        description="True if the return on equity (ROE) is positive, "
+        "showing profitability relative to shareholder equity.",
+    )
+    positive_diluted_eps: Optional[bool] = Field(
+        None,
+        description="True if the diluted earnings per share (EPS), "
+        "which includes the effect of convertible securities, is positive.",
+    )
+    positive_basic_eps: Optional[bool] = Field(
+        None,
+        description="True if the basic earnings per share (EPS) is positive, reflecting profitable operations.",
+    )
+    growing_basic_eps: Optional[bool] = Field(
+        None,
+        description="True if the basic EPS has shown consistent growth over a defined time period.",
+    )
+    growing_diluted_eps: Optional[bool] = Field(
+        None,
+        description="True if the diluted EPS has consistently increased over time.",
+    )
+    positive_net_income: Optional[bool] = Field(
+        None,
+        description="True if the net income is positive, indicating overall profitability.",
+    )
+    positive_operating_income: Optional[bool] = Field(
+        None,
+        description="True if the company has positive operating income from its core business operations.",
+    )
+    growing_net_income: Optional[bool] = Field(
+        None, description="True if net income has shown consistent growth over time."
+    )
+    growing_operating_income: Optional[bool] = Field(
+        None,
+        description="True if the operating income has consistently increased over a period.",
+    )
+    positive_free_cash_flow: Optional[bool] = Field(
+        None,
+        description="True if the company has positive free cash flow, indicating financial flexibility and health.",
+    )
+    growing_operating_cash_flow: Optional[bool] = Field(
+        None,
+        description="True if the company's operating cash flow is growing steadily.",
+    )
+    operating_cash_flow_is_higher_than_net_income: Optional[bool] = Field(
+        None,
+        description="True if the operating cash flow exceeds net income, often a sign of high-quality earnings.",
+    )
+
+    # Capital Expenditure Ratios
+    mean_capex_ratio: Optional[float] = Field(
+        None,
+        description="Average capital expenditure (CapEx) ratio, usually "
+        "calculated as CapEx divided by revenue or operating cash flow.",
+    )
+    max_capex_ratio: Optional[float] = Field(
+        None, description="Maximum observed CapEx ratio over the evaluation period."
+    )
+    min_capex_ratio: Optional[float] = Field(
+        None, description="Minimum observed CapEx ratio over the evaluation period."
+    )
+
+    # Dividend Payout Ratios
+    mean_dividend_payout_ratio: Optional[float] = Field(
+        None,
+        description="Average dividend payout ratio, representing the proportion of earnings paid out as dividends.",
+    )
+    max_dividend_payout_ratio: Optional[float] = Field(
+        None, description="Maximum dividend payout ratio observed over the period."
+    )
+    min_dividend_payout_ratio: Optional[float] = Field(
+        None, description="Minimum dividend payout ratio observed over the period."
+    )
+
+    # EPS Value
+    earning_per_share: Optional[float] = Field(
+        None,
+        description="The latest or most relevant value of earnings per share (EPS), indicating net income per share.",
+    )
 
     def is_empty(self) -> bool:
         return all(getattr(self, field) is None for field in self.model_fields)
@@ -489,7 +347,10 @@ class YearlyFundamentalAnalysis(BaseFundamentalAnalysis): ...
 
 
 fields_with_prefix = {
-    f"{QUARTERLY}_{name}": (field_info.annotation, Field(default=None))
+    f"{QUARTERLY}_{name}": (
+        field_info.annotation,
+        Field(default=None, description=field_info.description),
+    )
     for name, field_info in BaseFundamentalAnalysis.model_fields.items()
 }
 
@@ -510,7 +371,7 @@ class QuarterlyFundamentalAnalysis(BaseQuarterlyFundamentalAnalysis):  # type: i
             cash_flows=financials.quarterly_cash_flows,
             ticker=ticker,
         )
-        return cls.model_validate({f"{QUARTERLY}_{k}": v for k, v in base_financial_analisys.model_dump().items()})  # type: ignore # noqa: E501
+        return cls.model_validate({f"{QUARTERLY}_{k}": v for k, v in base_financial_analisys.model_dump().items()})  # type: ignore
 
 
 class FundamentalAnalysis(YearlyFundamentalAnalysis, QuarterlyFundamentalAnalysis):

{bullishpy-0.5.0 → bullishpy-0.6.0}/bullish/analysis/filter.py

@@ -1,6 +1,6 @@
 import datetime
 from datetime import date
-from typing import Literal, get_args, Any, Optional, List, Tuple, Type
+from typing import Literal, get_args, Any, Optional, List, Tuple, Type, Dict
 
 from bearish.types import SeriesLength  # type: ignore
 from pydantic import BaseModel, Field, ConfigDict
@@ -8,9 +8,9 @@ from pydantic import create_model
 from pydantic.fields import FieldInfo
 
 from bullish.analysis.analysis import (
-    TechnicalAnalysis,
     YearlyFundamentalAnalysis,
     QuarterlyFundamentalAnalysis,
+    TechnicalAnalysisModels,
 )
 
 Industry = Literal[
@@ -425,11 +425,18 @@ def _get_type(name: str, info: FieldInfo) -> Tuple[Any, Any]:
     if info.annotation == Optional[float]:  # type: ignore
         ge = next((item.ge for item in info.metadata if hasattr(item, "ge")), 0)
         le = next((item.le for item in info.metadata if hasattr(item, "le")), 100)
-        return (Optional[List[float]], Field(default=[ge, le], alias=alias))
+        default = [ge, le]
+        return (
+            Optional[List[float]],
+            Field(default=default, alias=alias, description=info.description),
+        )
     elif info.annotation == Optional[date]:  # type: ignore
         le = date.today()
-        ge = le - datetime.timedelta(days=30 * 12)  # 30 days * 12 months
-        return (List[date], Field(default=[ge, le], alias=alias))
+        ge = le - datetime.timedelta(days=30 * 2)  # 30 days * 12 months
+        return (
+            List[date],
+            Field(default=[ge, le], alias=alias, description=info.description),
+        )
     else:
         raise NotImplementedError
 
@@ -467,49 +474,80 @@ PROPERTIES_GROUP = list(
     )
 )
 
-GROUP_MAPPING = {
+GROUP_MAPPING: Dict[str, List[str]] = {
     "income": INCOME_GROUP,
     "cash_flow": CASH_FLOW_GROUP,
     "eps": EPS_GROUP,
     "properties": PROPERTIES_GROUP,
-    "country": get_args(Country),
-    "industry": get_args(Industry),
-    "industry_group": get_args(IndustryGroup),
-    "sector": get_args(Sector),
+    "country": list(get_args(Country)),
+    "industry": list(get_args(Industry)),
+    "industry_group": list(get_args(IndustryGroup)),
+    "sector": list(get_args(Sector)),
+    "symbol": [],
 }
 
 
-def _create_fundamental_analysis_model() -> Type[BaseModel]:
+def _create_fundamental_analysis_models() -> List[Type[BaseModel]]:
+    models = []
     boolean_fields = {
-        "income": (Optional[List[str]], Field(default=None)),
-        "cash_flow": (Optional[List[str]], Field(default=None)),
-        "eps": (Optional[List[str]], Field(default=None)),
-        "properties": (Optional[List[str]], Field(default=None)),
+        "income": (Optional[List[str]], Field(default=None, description="Income")),
+        "cash_flow": (
+            Optional[List[str]],
+            Field(default=None, description="Cash flow"),
+        ),
+        "eps": (
+            Optional[List[str]],
+            Field(default=None, description="Earnings per share"),
+        ),
+        "properties": (
+            Optional[List[str]],
+            Field(default=None, description="General properties"),
+        ),
     }
-    remaining_fields = {
+    yearly_fields = {
         name: _get_type(name, info)
-        for name, info in {
-            **YearlyFundamentalAnalysis.model_fields,
-            **QuarterlyFundamentalAnalysis.model_fields,
-        }.items()
-        if info.annotation != Optional[bool]
+        for name, info in YearlyFundamentalAnalysis.model_fields.items()
+        if info.annotation != Optional[bool]  # type: ignore
     }
-    return create_model(
-        "FundamentalAnalysisFilter",
-        __config__=ConfigDict(populate_by_name=True),
-        **(boolean_fields | remaining_fields),
-    )
-
-
-TechnicalAnalysisFilter = create_model(  # type: ignore
-    "TechnicalAnalysisFilter",
-    __config__=ConfigDict(populate_by_name=True),
-    **{
+    quarterly_fields = {
         name: _get_type(name, info)
-        for name, info in TechnicalAnalysis.model_fields.items()
-    },
-)
-FundamentalAnalysisFilter = _create_fundamental_analysis_model()
+        for name, info in QuarterlyFundamentalAnalysis.model_fields.items()
+        if info.annotation != Optional[bool]
+    }
+    for property in [
+        (boolean_fields, "Selection filter", "SelectionFilter"),
+        (yearly_fields, "Yearly properties", "YearlyFilter"),
+        (quarterly_fields, "Quarterly properties", "QuarterlyFilter"),
+    ]:
+        model_ = create_model(  # type: ignore
+            property[-1],
+            __config__=ConfigDict(populate_by_name=True),
+            **property[0],
+        )
+        model_._description = property[1]
+        models.append(model_)
+
+    return models
+
+
+def create_technical_analysis_models() -> List[Type[BaseModel]]:
+    models = []
+    for model in TechnicalAnalysisModels:
+        model_ = create_model(  # type: ignore
+            f"{model.__name__}Filter",  # type: ignore
+            __config__=ConfigDict(populate_by_name=True),
+            **{
+                name: _get_type(name, info) for name, info in model.model_fields.items()  # type: ignore
+            },
+        )
+
+        model_._description = model._description  # type: ignore
+        models.append(model_)
+    return models
+
+
+TechnicalAnalysisFilters = create_technical_analysis_models()
+FundamentalAnalysisFilters = _create_fundamental_analysis_models()
 
 
 class GeneralFilter(BaseModel):
@@ -517,15 +555,19 @@ class GeneralFilter(BaseModel):
     industry: Optional[List[str]] = None
     industry_group: Optional[List[str]] = None
     sector: Optional[List[str]] = None
-    market_capitalization: Optional[List[float]] = Field(
-        default_factory=lambda: [5e8, 1e12]
-    )
+    symbol: Optional[List[str]] = None
+    market_capitalization: Optional[List[float]] = Field(default=[5e8, 1e12])
 
 
-class FilterQuery(GeneralFilter, TechnicalAnalysisFilter, FundamentalAnalysisFilter):  # type: ignore
+class FilterQuery(GeneralFilter, *TechnicalAnalysisFilters, *FundamentalAnalysisFilters):  # type: ignore
 
     def valid(self) -> bool:
-        return bool(self.model_dump(exclude_defaults=True, exclude_unset=True))
+        return any(
+            bool(v)
+            for _, v in self.model_dump(
+                exclude_defaults=True, exclude_unset=True
+            ).items()
+        )
 
     def to_query(self) -> str:
         parameters = self.model_dump(exclude_defaults=True, exclude_unset=True)