Upload 292 files

openbb_platform/providers/imf/README.md

@@ -0,0 +1,35 @@
+# OpenBB IMF Provider Extension
+
+This package adds the `openbb-imf` provider extension to the OpenBB Platform.
+
+## Installation
+
+Install from PyPI with:
+
+```sh
+pip install openbb-imf
+```
+
+## Implementation
+
+The extension utilizes the JSON RESTful Web Service ((https://datahelp.imf.org/knowledgebase/articles/630877-data-services)[https://datahelp.imf.org/knowledgebase/articles/630877-data-services])
+
+No authorization is required to use, but IP addresses are bound by the limitations described in the link above.
+
+## Coverage
+
+- Databases:
+  - International Reserves and Foreign Currency Liquidity
+  - Direction of Trade Statistics
+  - Financial Soundness Indicators
+
+Coverage:
+  - All IRFCL tables.
+  - Individual, or multiple, time series from single or multiple countries.
+  - Core and Encouraged Set tables, plus all individual underlying series.
+
+### Endpoints
+
+- `obb.economy.available_indicators`
+- `obb.economy.indicators`
+- `obb.economy.direction_of_trade`

openbb_platform/providers/imf/__init__.py

@@ -0,0 +1 @@
+"""IMF Provoider Extension."""

openbb_platform/providers/imf/openbb_imf/__init__.py

@@ -0,0 +1,18 @@
+"""OpenBB IMF Provider Module."""
+
+from openbb_core.provider.abstract.provider import Provider
+from openbb_imf.models.available_indicators import ImfAvailableIndicatorsFetcher
+from openbb_imf.models.direction_of_trade import ImfDirectionOfTradeFetcher
+from openbb_imf.models.economic_indicators import ImfEconomicIndicatorsFetcher
+
+imf_provider = Provider(
+    name="imf",
+    website="https://datahelp.imf.org/knowledgebase/articles/667681-using-json-restful-web-service",
+    description="This provider allows you to access International Monetary Fund data through the IMF Public Data API.",
+    fetcher_dict={
+        "AvailableIndicators": ImfAvailableIndicatorsFetcher,
+        "DirectionOfTrade": ImfDirectionOfTradeFetcher,
+        "EconomicIndicators": ImfEconomicIndicatorsFetcher,
+    },
+    repr_name="International Monetary Fund (IMF) Public Data API",
+)

openbb_platform/providers/imf/openbb_imf/assets/__init__.py

@@ -0,0 +1 @@
+"""IMF Static Assets."""

openbb_platform/providers/imf/openbb_imf/assets/imf_country_map.json

@@ -0,0 +1,260 @@
+{
+    "AF": "Afghanistan",
+    "AL": "Albania",
+    "DZ": "Algeria",
+    "AS": "American Samoa",
+    "AO": "Angola",
+    "AI": "Anguilla",
+    "AG": "Antigua and Barbuda",
+    "AR": "Argentina",
+    "AM": "Armenia",
+    "AW": "Aruba",
+    "S19": "Asia not allocated",
+    "AU": "Australia",
+    "AT": "Austria",
+    "AZ": "Azerbaijan",
+    "BS": "Bahamas",
+    "BH": "Bahrain",
+    "BD": "Bangladesh",
+    "BB": "Barbados",
+    "BY": "Belarus",
+    "BE": "Belgium",
+    "R1": "Belgo-Luxembourg Economic Union",
+    "BZ": "Belize",
+    "BJ": "Benin",
+    "BM": "Bermuda",
+    "BT": "Bhutan",
+    "BO": "Bolivia",
+    "BA": "Bosnia and Herzegovina",
+    "BW": "Botswana",
+    "BR": "Brazil",
+    "BN": "Brunei Darussalam",
+    "BG": "Bulgaria",
+    "BF": "Burkina Faso",
+    "BI": "Burundi",
+    "CV": "Cabo Verde",
+    "KH": "Cambodia",
+    "CM": "Cameroon",
+    "CA": "Canada",
+    "5Y": "Eastern Caribbean Currency Union",
+    "CF": "Central African Republic",
+    "TD": "Chad",
+    "CL": "Chile",
+    "HK": "Hong Kong",
+    "MO": "Macao",
+    "CN": "China",
+    "CO": "Colombia",
+    "KM": "Comoros",
+    "CD": "Democratic Republic of the Congo",
+    "CG": "Congo",
+    "CR": "Costa Rica",
+    "CI": "Ivory Coast",
+    "HR": "Croatia",
+    "CU": "Cuba",
+    "CW": "Curacao",
+    "CY": "Cyprus",
+    "CZ": "Czech Republic",
+    "CSH": "Former Czechoslovakia",
+    "DK": "Denmark",
+    "DJ": "Djibouti",
+    "DM": "Dominica",
+    "DO": "Dominican Republic",
+    "DE2": "East Germany",
+    "EC": "Ecuador",
+    "EG": "Egypt",
+    "SV": "El Salvador",
+    "GQ": "Equatorial Guinea",
+    "ER": "Eritrea",
+    "EE": "Estonia",
+    "SZ": "Eswatini",
+    "ET": "Ethiopia",
+    "E19": "Europe not allocated",
+    "FK": "Falkland Islands (Malvinas)",
+    "FO": "Faroe Islands",
+    "FJ": "Fiji",
+    "FI": "Finland",
+    "FR": "France",
+    "PF": "French Polynesia",
+    "GA": "Gabon",
+    "GM": "Gambia",
+    "GE": "Georgia",
+    "DE": "Germany",
+    "GH": "Ghana",
+    "GI": "Gibraltar",
+    "GR": "Greece",
+    "GL": "Greenland",
+    "GD": "Grenada",
+    "GU": "Guam",
+    "GT": "Guatemala",
+    "GN": "Guinea",
+    "GW": "Guinea-Bissau",
+    "GY": "Guyana",
+    "HT": "Haiti",
+    "VA": "Vatican City State",
+    "HN": "Honduras",
+    "HU": "Hungary",
+    "IS": "Iceland",
+    "IN": "India",
+    "ID": "Indonesia",
+    "IR": "Iran",
+    "IQ": "Iraq",
+    "IE": "Ireland",
+    "IL": "Israel",
+    "IT": "Italy",
+    "JM": "Jamaica",
+    "JP": "Japan",
+    "JO": "Jordan",
+    "KZ": "Kazakhstan",
+    "KE": "Kenya",
+    "KI": "Kiribati",
+    "KP": "North Korea",
+    "KR": "South Korea",
+    "XK": "Kosovo",
+    "KW": "Kuwait",
+    "KG": "Kyrgyzstan",
+    "LA": "Lao",
+    "LV": "Latvia",
+    "LB": "Lebanon",
+    "LS": "Lesotho",
+    "LR": "Liberia",
+    "LY": "Libya",
+    "LT": "Lithuania",
+    "LU": "Luxembourg",
+    "MG": "Madagascar",
+    "MW": "Malawi",
+    "MY": "Malaysia",
+    "1C_554": "West Malaysia",
+    "MV": "Maldives",
+    "ML": "Mali",
+    "MT": "Malta",
+    "MH": "Marshall islands",
+    "MR": "Mauritania",
+    "MU": "Mauritius",
+    "MX": "Mexico",
+    "FM": "Micronesia",
+    "F979": "Middle East and Central Asia not specified",
+    "MD": "Moldova",
+    "MN": "Mongolia",
+    "ME": "Montenegro",
+    "MS": "Montserrat",
+    "MA": "Morocco",
+    "MZ": "Mozambique",
+    "MM": "Myanmar",
+    "NA": "Namibia",
+    "NR": "Nauru",
+    "NP": "Nepal",
+    "AN": "Antilles",
+    "NL": "Netherlands",
+    "NC": "New Caledonia",
+    "NZ": "New Zealand",
+    "NI": "Nicaragua",
+    "NE": "Niger",
+    "NG": "Nigeria",
+    "MK": "North Macedonia",
+    "1C_958": "North Vietnam",
+    "NO": "Norway",
+    "OM": "Oman",
+    "PK": "Pakistan",
+    "PW": "Palau",
+    "PA": "Panama",
+    "PG": "Papua New Guinea",
+    "PY": "Paraguay",
+    "PE": "Peru",
+    "PH": "Philippines",
+    "PL": "Poland",
+    "PT": "Portugal",
+    "QA": "Qatar",
+    "RO": "Romania",
+    "RU": "Russia",
+    "RW": "Rwanda",
+    "WS": "Samoa",
+    "SM": "San Marino",
+    "ST": "Sao Tome and Principe",
+    "SA": "Saudi Arabia",
+    "SN": "Senegal",
+    "CS": "Serbia and Montenegro",
+    "RS": "Serbia",
+    "SC": "Seychelles",
+    "SL": "Sierra Leone",
+    "SG": "Singapore",
+    "SX": "Sint Maarten (Dutch part)",
+    "SK": "Slovakia",
+    "SI": "Slovenia",
+    "SB": "Solomon Islands",
+    "SO": "Somalia",
+    "ZA": "South Africa",
+    "1C_198": "South African Common Customs Area",
+    "SS": "South Sudan",
+    "ES": "Spain",
+    "LK": "Sri Lanka",
+    "KN": "Saint Kitts and Nevis",
+    "LC": "Saint Lucia",
+    "VC": "Saint Vincent and the Grenadines",
+    "SD": "Sudan",
+    "SR": "Suriname",
+    "SE": "Sweden",
+    "CH": "Switzerland",
+    "SY": "Syria",
+    "TW": "Taiwan",
+    "TJ": "Tajikistan",
+    "TZ": "Tanzania",
+    "TH": "Thailand",
+    "TL": "Timor-Leste",
+    "TG": "Togo",
+    "TO": "Tonga",
+    "TT": "Trinidad and Tobago",
+    "TN": "Tunisia",
+    "TR": "Turkey",
+    "TM": "Turkmenistan",
+    "TV": "Tuvalu",
+    "UG": "Uganda",
+    "UA": "Ukraine",
+    "AE": "United Arab Emirates",
+    "GB": "United Kingdom",
+    "US": "United States",
+    "UY": "Uruguay",
+    "SUH": "Former USSR",
+    "UZ": "Uzbekistan",
+    "VU": "Vanuatu",
+    "VE": "Venezuela",
+    "VN": "Viet Nam",
+    "PS": "Palestine",
+    "YE": "Yemen",
+    "YUC": "Former Yugoslavia",
+    "ZM": "Zambia",
+    "ZW": "Zimbabwe",
+    "R14": "Community of Independent States",
+    "U2": "Euro Area",
+    "E1": "Europe",
+    "B0": "European Union",
+    "F97": "Middle East",
+    "XS5": "Middle East and Central Asia",
+    "X88": "Other Countries n.i.e. (IMF)",
+    "F1": "Africa",
+    "F6": "Sub-Saharan Africa",
+    "F19": "Africa not allocated",
+    "A10": "Western Hemisphere",
+    "A109": "Western Hemisphere not allocated",
+    "W00": "World",
+    "XR99": "Special Categories and Economic Zones",
+    "XS25": "Developing Asia (IMF)",
+    "XR43": "Emerging and Developing Countries",
+    "XR29": "Advanced Economies (IMF)",
+    "1C_ALLC": "All Countries",
+    "1C_ALL": "All Countries and Country Groups",
+    "1C_ALLG": "All Country Groups",
+    "1C_903": "Emerging and Developing Europe",
+    "1C_080": "Export Earnings: Fuel",
+    "1C_092": "Export Earnings: Nonfuel",
+    "1C_440": "Middle East, North Africa, Afghanistan, and Pakistan",
+    "1C_473": "Yemen Arab Rep",
+    "1C_459": "Yemen P.D. Rep",
+    "1C_All_Reporting_Countries_Data": "All Reporting Countries, Data",
+    "1C_All_Reporting_Countries_Metadata": "All Reporting Countries, Metadata",
+    "1C_Daily_Reporters": "Daily Reporters",
+    "1C_Dual_Reporters": "Dual Reporters",
+    "1C_Monthly_Reporters": "Monthly Reporters",
+    "1C_Single_Reporters": "Single Reporters",
+    "1C_Single_Reporters_USA_and_Peru": "Single Reporters - USA and Peru",
+    "_X": "Unspecified"
+}

openbb_platform/providers/imf/openbb_imf/models/__init__.py

@@ -0,0 +1 @@
+"""OpenBB IMF Provider Models."""

openbb_platform/providers/imf/openbb_imf/models/available_indicators.py

@@ -0,0 +1,126 @@
+"""IMF Available Indicators."""
+
+# pylint: disable=unused-argument
+
+from typing import Any, Optional, Union
+
+from openbb_core.app.model.abstract.error import OpenBBError
+from openbb_core.provider.abstract.fetcher import Fetcher
+from openbb_core.provider.standard_models.available_indicators import (
+    AvailableIndicatorsData,
+    AvailableIndicesQueryParams,
+)
+from pydantic import Field
+
+
+class ImfAvailableIndicatorsQueryParams(AvailableIndicesQueryParams):
+    """IMF Available Indicators Query Parameters."""
+
+    __json_schema_extra__ = {"query": {"multiple_items_allowed": True}}
+
+    query: Optional[str] = Field(
+        default=None,
+        description="The query string to search through the available indicators."
+        + " Use semicolons to separate multiple terms.",
+    )
+
+
+class ImfAvailableIndicatorsData(AvailableIndicatorsData):
+    """IMF Available Indicators Data."""
+
+    __alias_dict__ = {
+        "symbol_root": "parent",
+        "description": "title",
+    }
+    dataset: Optional[str] = Field(
+        default=None,
+        description="The IMF dataset associated with the symbol.",
+    )
+    table: Optional[str] = Field(
+        default=None,
+        description="The name of the table associated with the symbol.",
+    )
+    level: Optional[int] = Field(
+        default=None,
+        description="The indentation level of the data, relative to the table and symbol_root",
+    )
+    order: Optional[Union[int, float]] = Field(
+        default=None,
+        description="Order of the data, relative to the table.",
+    )
+    children: Optional[str] = Field(
+        default=None,
+        description="The symbol of the child data, if any.",
+    )
+    unit: Optional[str] = Field(
+        default=None,
+        description="The unit of the data.",
+    )
+
+
+class ImfAvailableIndicatorsFetcher(
+    Fetcher[ImfAvailableIndicatorsQueryParams, list[ImfAvailableIndicatorsData]]
+):
+    """IMF Available Indicators Fetcher."""
+
+    @staticmethod
+    def transform_query(params: dict[str, Any]) -> ImfAvailableIndicatorsQueryParams:
+        """Transform the query."""
+        return ImfAvailableIndicatorsQueryParams(**params)
+
+    @staticmethod
+    def extract_data(
+        query: ImfAvailableIndicatorsQueryParams,
+        credentials: Optional[dict[str, Any]] = None,
+        **kwargs: Any,
+    ) -> list[dict]:
+        """Fetch the data."""
+        # pylint: disable=import-outside-toplevel
+        from numpy import nan
+        from openbb_core.provider.utils.errors import EmptyDataError
+        from openbb_imf.utils.constants import load_symbols
+        from pandas import DataFrame, Series
+
+        try:
+            all_symbols = load_symbols("all")
+        except OpenBBError as e:
+            raise OpenBBError(f"Failed to load IMF symbols static file: {e}") from e
+
+        terms = [term.strip() for term in query.query.split(";")] if query.query else []
+
+        df = (
+            DataFrame(all_symbols)
+            .T.reset_index()
+            .rename(columns={"index": "symbol"})
+            .replace({nan: None})
+        )
+
+        if not terms:
+            records = df.to_dict(orient="records")
+        else:
+            combined_mask = Series([True] * len(df))
+            for term in terms:
+                mask = df.apply(
+                    lambda row, term=term: row.astype(str).str.contains(
+                        term, case=False, regex=True, na=False
+                    )
+                ).any(axis=1)
+                combined_mask &= mask
+
+            matches = df[combined_mask]
+
+            if matches.empty:
+                raise EmptyDataError("No results found for the provided query.")
+
+            records = matches.to_dict(orient="records")
+
+        return records
+
+    @staticmethod
+    def transform_data(
+        query: ImfAvailableIndicatorsQueryParams,
+        data: list[dict],
+        **kwargs: Any,
+    ) -> list[ImfAvailableIndicatorsData]:
+        """Transform the data."""
+        return [ImfAvailableIndicatorsData.model_validate(d) for d in data]

openbb_platform/providers/imf/openbb_imf/models/direction_of_trade.py

@@ -0,0 +1,274 @@
+"""IMF Direction Of Trade Model."""
+
+# pylint: disable=unused-argument
+
+from datetime import datetime
+from typing import Any, Optional, Union
+
+from openbb_core.app.model.abstract.error import OpenBBError
+from openbb_core.provider.abstract.fetcher import Fetcher
+from openbb_core.provider.standard_models.direction_of_trade import (
+    DirectionOfTradeData,
+    DirectionOfTradeQueryParams,
+)
+from openbb_core.provider.utils.errors import EmptyDataError
+from openbb_imf.utils.dot_helpers import (
+    load_country_map,
+    load_country_to_code_map,
+    validate_countries,
+)
+
+dot_indicators_dict = {
+    "exports": "TXG_FOB_USD",
+    "imports": "TMG_CIF_USD",
+    "balance": "TBG_USD",
+    "all": "TXG_FOB_USD+TMG_CIF_USD+TBG_USD",
+}
+
+dot_titles_map = {
+    "TXG_FOB_USD": "Goods, Value of Exports, Free on board (FOB), US Dollars",
+    "TMG_CIF_USD": "Goods, Value of Imports, Cost, Insurance, Freight (CIF), US Dollars",
+    "TBG_USD": "Goods, Value of Trade Balance, US Dollars",
+}
+
+
+class ImfDirectionOfTradeQueryParams(DirectionOfTradeQueryParams):
+    """IMF Direction Of Trade Query Parameters."""
+
+    __json_schema_extra__ = {
+        "country": {
+            "multiple_items_allowed": True,
+            "choices": ["all"] + sorted(list(load_country_to_code_map())),
+        },
+        "counterpart": {
+            "multiple_items_allowed": True,
+            "choices": ["all"] + sorted(list(load_country_to_code_map())),
+        },
+    }
+
+
+class ImfDirectionOfTradeData(DirectionOfTradeData):
+    """IMF Direction Of Trade Data."""
+
+
+class ImfDirectionOfTradeFetcher(
+    Fetcher[ImfDirectionOfTradeQueryParams, list[ImfDirectionOfTradeData]]
+):
+    """IMF Direction Of Trade Fetcher."""
+
+    @staticmethod
+    def transform_query(params: dict[str, Any]) -> ImfDirectionOfTradeQueryParams:
+        """Transform query parameters."""
+        countries = params.get("country", "")
+        countries = countries.split(",") if countries else "all"
+        if countries != "all":
+            countries = validate_countries(countries)
+        counterparts = params.get("counterpart", "")
+        counterparts = counterparts.split(",") if params.get("counterpart") else "all"
+        if counterparts != "all":
+            counterparts = validate_countries(counterparts)
+        now = datetime.now().date()
+
+        if countries == "all" and counterparts == "all":
+            raise OpenBBError(
+                "Both 'country' and 'counterpart' cannot be None, or 'all'."
+                + " Please supply lowercase country names or two-letter ISO codes."
+            )
+        if countries == counterparts:
+            raise OpenBBError("The 'country' and 'counterpart' cannot be the same.")
+
+        params["country"] = countries
+        params["counterpart"] = counterparts
+
+        if not params.get("end_date"):
+            params["end_date"] = now.replace(month=12, day=31).strftime("%Y-%m-%d")
+
+        if (countries == "all" or counterparts == "all") and not params.get(
+            "start_date"
+        ):
+            params["start_date"] = now.replace(year=now.year - 1).strftime("%Y-%m-%d")
+
+        return ImfDirectionOfTradeQueryParams(**params)
+
+    @staticmethod
+    async def aextract_data(
+        query: ImfDirectionOfTradeQueryParams,
+        credentials: Optional[dict[str, str]],
+        **kwargs: Any,
+    ) -> list[dict]:
+        """Extract the data from the IMF API."""
+        # pylint: disable=import-outside-toplevel
+        from aiohttp.client_exceptions import ContentTypeError  # noqa
+        from json import JSONDecodeError
+        from openbb_core.provider.utils.helpers import amake_request
+        from pandas import to_datetime
+        from pandas.tseries import offsets
+
+        start_date = query.start_date
+        end_date = query.end_date
+        frequency = query.frequency[0].upper()
+        country = query.country if query.country != "all" else ""
+        counterpart = query.counterpart if query.counterpart != "all" else ""
+        indicator = dot_indicators_dict[query.direction]
+        # Adjust the dates to the date relative to frequency.
+        # The API does not accept arbitrary dates, so we need to adjust them.
+        if start_date:
+            start_date = to_datetime(start_date)
+            if frequency == "Q":
+                start_date = offsets.QuarterBegin(startingMonth=1).rollback(start_date)
+            elif frequency == "A":
+                start_date = offsets.YearBegin().rollback(start_date)
+            else:
+                start_date = offsets.MonthBegin().rollback(start_date)
+            start_date = start_date.strftime("%Y-%m-%d")  # type: ignore
+
+        if end_date:
+            end_date = to_datetime(end_date)
+            if frequency == "Q":
+                end_date = offsets.QuarterEnd().rollforward(end_date)
+            elif frequency == "A":
+                end_date = offsets.YearEnd().rollforward(end_date)
+            else:
+                end_date = offsets.MonthEnd().rollforward(end_date)
+            end_date = end_date.strftime("%Y-%m-%d")  # type: ignore
+
+        date_range = (  # type: ignore
+            f"?startPeriod={start_date}&endPeriod={end_date}"
+            if start_date and end_date
+            else ""
+        )
+        base_url = "http://dataservices.imf.org/REST/SDMX_JSON.svc/"
+        key = f"CompactData/DOT/{frequency}.{country}.{indicator}.{counterpart}"
+        url = f"{base_url}{key}{date_range}"
+
+        try:
+            response = await amake_request(url, timeout=20)
+        except (JSONDecodeError, ContentTypeError) as e:
+            raise OpenBBError(
+                "Error fetching data; This might be rate-limiting. Try again later."
+            ) from e
+
+        if "ErrorDetails" in response:
+            raise OpenBBError(
+                f"{response['ErrorDetails'].get('Code')} -> {response['ErrorDetails'].get('Message')}"  # type: ignore
+            )
+
+        series = response.get("CompactData", {}).get("DataSet", {}).pop("Series", {})  # type: ignore
+
+        if not series:
+            raise OpenBBError(f"No time series data found -> {url} -> {response}")
+
+        # If there is only one series, they ruturn a dict instead of a list.
+        if series and isinstance(series, dict):
+            series = [series]
+
+        return series
+
+    @staticmethod
+    def transform_data(
+        query: ImfDirectionOfTradeQueryParams,
+        data: list[dict],
+        **kwargs: Any,
+    ) -> list[ImfDirectionOfTradeData]:
+        """Transform the data."""
+        # pylint: disable=import-outside-toplevel
+        from openbb_imf.utils.constants import UNIT_MULTIPLIERS_MAP  # noqa
+        from pandas import Categorical, DataFrame, to_datetime
+        from pandas.tseries import offsets
+
+        if not data:
+            raise EmptyDataError()
+
+        dot_code_to_country = load_country_map()
+        series = data
+        results: list = []
+
+        for s in series:
+            if "Obs" not in s:
+                continue
+            meta = {
+                k.replace("@", "").lower(): (
+                    UNIT_MULTIPLIERS_MAP.get(str(v), v) if k == "@UNIT_MULT" else v
+                )
+                for k, v in s.items()
+                if k != "Obs"
+            }
+            _symbol = meta.get("indicator", "")
+            _title = None
+
+            _data = s.pop("Obs", [])
+
+            if isinstance(_data, dict):
+                _data = [_data]
+
+            for d in _data:
+                _date = d.pop("@TIME_PERIOD", None)
+                val: Union[float, None] = d.pop("@OBS_VALUE", None)
+                _ = d.pop("@OBS_STATUS", None)
+                val = float(val) if val else None
+                if not val:
+                    continue
+
+                if _date:
+                    offset = (
+                        offsets.QuarterEnd
+                        if "Q" in _date
+                        else (
+                            offsets.YearEnd
+                            if len(str(_date)) == 4
+                            else offsets.MonthEnd
+                        )
+                    )
+                    _date = to_datetime(_date)
+                    _date = _date + offset(0)
+                    _date = _date.strftime("%Y-%m-%d")
+                vals = {
+                    k: v
+                    for k, v in {
+                        "date": _date,
+                        "symbol": _symbol,
+                        "country": dot_code_to_country.get(
+                            meta.get("ref_area"), meta.get("ref_area")
+                        ),
+                        "counterpart": dot_code_to_country.get(
+                            meta.get("counterpart_area"), meta.get("counterpart_area")
+                        ),
+                        "title": dot_titles_map.get(_symbol),
+                        "scale": meta.get("unit_mult"),
+                        "value": val,
+                    }.items()
+                    if v
+                }
+
+                if (
+                    vals.get("value")
+                    and vals.get("date")
+                    and vals.get("country") != vals.get("counterpart")
+                ):
+                    d.update(vals)
+
+            if _data:
+                results.extend([d for d in _data if d])
+
+        df = DataFrame(results)
+        df["symbol"] = Categorical(
+            df["symbol"],
+            categories=list(dot_titles_map),
+            ordered=True,
+        )
+        df["country"] = Categorical(
+            df["country"],
+            categories=sorted(df.country.unique().tolist()),
+            ordered=True,
+        )
+        df["counterpart"] = Categorical(
+            df["counterpart"],
+            categories=sorted(df.counterpart.unique().tolist()),
+            ordered=True,
+        )
+        df = df.sort_values(by=["date", "country", "counterpart"])
+
+        return [
+            ImfDirectionOfTradeData.model_validate(r)
+            for r in df.to_dict(orient="records")
+        ]

openbb_platform/providers/imf/openbb_imf/models/economic_indicators.py

@@ -0,0 +1,303 @@
+"""IMF Economic Indicators Model."""
+
+# pylint: disable=unused-argument
+
+from datetime import datetime
+from typing import Any, Dict, List, Literal, Optional, Union
+
+from openbb_core.app.model.abstract.error import OpenBBError
+from openbb_core.provider.abstract.fetcher import Fetcher
+from openbb_core.provider.standard_models.economic_indicators import (
+    EconomicIndicatorsData,
+    EconomicIndicatorsQueryParams,
+)
+from openbb_core.provider.utils.descriptions import QUERY_DESCRIPTIONS
+from openbb_core.provider.utils.errors import EmptyDataError
+from openbb_imf.utils.constants import (
+    FSI_PRESETS,
+    IRFCL_PRESET,
+    IRFCL_TABLES,
+    load_symbols,
+)
+from openbb_imf.utils.irfcl_helpers import (
+    load_country_to_code_map,
+    validate_countries,
+)
+from pydantic import Field, field_validator
+
+
+class ImfEconomicIndicatorsQueryParams(EconomicIndicatorsQueryParams):
+    """IMF Economic Indicators Query."""
+
+    __json_schema_extra__ = {
+        "symbol": {
+            "multiple_items_allowed": True,
+        },
+        "country": {
+            "multiple_items_allowed": True,
+            "choices": ["all"] + list(list(load_country_to_code_map())),
+        },
+        "frequency": {
+            "choices": ["annual", "quarter", "month"],
+        },
+    }
+    symbol: str = Field(
+        default="irfcl_top_lines",
+        description=QUERY_DESCRIPTIONS.get("symbol", "")
+        + " Use `available_indicators()` to get the list of available symbols."
+        + " Use 'IRFCL' to get all the data from International Reserves & Foreign Currency Liquidity indicators."
+        + " Use 'core_fsi' to get the core Financial Soundness Indicators."
+        + " Use 'core_fsi_underlying' to include underlying data for the core Financial Soundness Indicators."
+        + " Complete tables are available only by single country, and are keyed as described below."
+        + " The default is 'irfcl_top_lines'. Available presets not listed in `available_indicators()` are:"
+        + """\n
+        'IRFCL': All the data from the set of indicators. Not compatible with multiple countries.
+        'irfcl_top_lines': The default, top line items from the IRFCL data. Compatible with multiple countries.
+        'reserve_assets_and_other_fx_assets': Table I of the IRFCL data. Not compatible with multiple countries.
+        'predetermined_drains_on_fx_assets': Table II of the IRFCL data. Not compatible with multiple countries.
+        'contingent_drains_fx_assets': Table III of the IRFCL data. Not compatible with multiple countries.
+        'memorandum_items': The memorandum items table of the IRFCL data. Not compatible with multiple countries.
+        'gold_reserves': Gold reserves as value in USD and Fine Troy Ounces. Compatible with multiple countries.
+        'derivative_assets': Net derivative assets as value in USD. Compatible with multipile countries.
+        'fsi_core': The core Financial Soundness Indicators. Compatible with multiple countries.
+        'fsi_core_underlying': The core FSIs underlying series data. Not compatible with country='all'.
+        'fsi_encouraged_set': The encouraged set of Financial Soundness Indicators. Not compatible with country='all'.
+        'fsi_other': The other Financial Soundness Indicators. Not compatible with country='all'.
+        'fsi_balance_sheets': Data categorized as Balance Sheets and Income Statements. Not compatible with country='all'.
+        'fsi_all': All the Financial Soundness Indicators. Not compatible with multiple countries.
+    """,
+    )
+    frequency: Literal["annual", "quarter", "month"] = Field(
+        default="quarter",
+        description="Frequency of the data, default is 'quarter'.",
+    )
+
+    @field_validator("symbol", mode="before", check_fields=False)
+    @classmethod
+    def _count_presets(cls, v):
+        """Validate the symbol."""
+        if not v:
+            return v
+        presets = list(IRFCL_PRESET) + FSI_PRESETS
+        n_preset = 0
+        symbols = v.split(",")
+        for symbol in symbols:
+            n_preset += 1 if symbol in presets else 0
+        if n_preset > 1:
+            raise ValueError("only one preset symbol can be used at a time.")
+        return v
+
+
+class ImfEconomicIndicatorsData(EconomicIndicatorsData):
+    """IMF Economic Indicators Data."""
+
+    __alias_dict__ = {
+        "symbol_root": "parent",
+    }
+
+    unit: Optional[str] = Field(
+        default=None,
+        description="The unit of the value.",
+    )
+    scale: Optional[str] = Field(
+        default=None,
+        description="The scale of the value.",
+    )
+    table: Optional[str] = Field(
+        default=None,
+        description="The name of the table associated with the symbol.",
+    )
+    level: Optional[int] = Field(
+        default=None,
+        description="The indentation level of the data, relative to the table and symbol_root",
+    )
+    order: Optional[Union[int, float]] = Field(
+        default=None,
+        description="Order of the data, relative to the table.",
+    )
+    reference_sector: Optional[str] = Field(
+        default=None,
+        description="The reference sector for the data.",
+    )
+    title: Optional[str] = Field(
+        default=None,
+        description="The title of the series associated with the symbol.",
+    )
+
+
+class ImfEconomicIndicatorsFetcher(
+    Fetcher[ImfEconomicIndicatorsQueryParams, List[ImfEconomicIndicatorsData]]
+):
+    """IMF Economic Indicators Fetcher."""
+
+    @staticmethod
+    def transform_query(params: Dict[str, Any]) -> ImfEconomicIndicatorsQueryParams:
+        """Transform the query."""
+        symbols = params.get("symbol", "")
+        countries = params.get("country")
+        now = datetime.now().date()
+        symbols = (
+            "IRFCL"
+            if (("all" in symbols or "IRFCL" in symbols) and "fsi_all" not in symbols)
+            else symbols if symbols else "irfcl_top_lines"
+        )
+        incompatible = (
+            "fsi_other" in symbols
+            or "fsi_encouraged_set" in symbols
+            or "fsi_all" in symbols
+            or "fsi_core_underlying" in symbols
+            or "fsi_balance_sheets" in symbols
+        )
+        if (symbols == "IRFCL" or incompatible) and not (
+            countries or countries == "all"
+        ):
+            raise OpenBBError(
+                f"The selected symbol(s), {params.get('symbol')}, is not compatible with the all-countries group."
+                " Please provide country names or two-letter ISO country codes."
+            )
+
+        if countries:
+            params["country"] = validate_countries(countries)
+
+        if symbols and symbols in IRFCL_PRESET:
+            params["symbol"] = IRFCL_PRESET[symbols]
+            if symbols in IRFCL_TABLES and countries and countries.split(",") > 1:
+                raise OpenBBError(
+                    f"Symbol '{symbols}' is a table and can only be used with one country."
+                )
+        elif symbols:
+            params["symbol"] = symbols
+
+        if not params.get("start_date") and (not countries or countries == "all"):
+            params["start_date"] = now.replace(
+                year=now.year - 1, month=1, day=1
+            ).strftime("%Y-%m-%d")
+
+        if not params.get("end_date"):
+            params["end_date"] = now.replace(month=12, day=31).strftime("%Y-%m-%d")
+
+        if (not symbols or symbols == "all") and not params.get("start_date"):
+            params["start_date"] = now.replace(year=now.year - 1).strftime("%Y-%m-%d")
+
+        return ImfEconomicIndicatorsQueryParams(**params)
+
+    @staticmethod
+    async def aextract_data(
+        query: ImfEconomicIndicatorsQueryParams,
+        credentials: Optional[Dict[str, Any]] = None,
+        **kwargs: Any,
+    ) -> List[Dict]:
+        """Extract the data."""
+        # pylint: disable = import-outside-toplevel
+        from openbb_imf.utils.fsi_helpers import _get_fsi_data  # noqa
+        from openbb_imf.utils.irfcl_helpers import _get_irfcl_data
+        from warnings import warn
+
+        fsi_symbols = load_symbols("FSI")
+        irfcl_symbols = load_symbols("IRFCL")
+        symbols = query.symbol.split(",")
+        new_symbols_irfcl: Union[list, str] = []
+        new_symbols_fsi: Union[list, str] = []
+        for symbol in symbols:
+            if symbol in list(IRFCL_PRESET) + ["all", "IRFCL"]:
+                new_symbols_irfcl = symbol
+            elif symbol in FSI_PRESETS:
+                new_symbols_fsi = symbol
+            elif symbol.upper() in fsi_symbols:
+                new_symbols_fsi.append(symbol.upper())  # type: ignore
+            elif symbol.upper() in irfcl_symbols:
+                new_symbols_irfcl.append(symbol.upper())  # type: ignore
+
+        if not new_symbols_irfcl and not new_symbols_fsi:
+            raise OpenBBError(
+                f"No valid symbols found -> {query.symbol} -> "
+                "Use 'available_indicators(provider='imf')' to get the list of available symbols."
+            )
+
+        results: list = []
+        exceptions: list = []
+        try:
+            try:
+                if new_symbols_irfcl:
+                    _kwargs = query.model_dump(exclude_none=True)
+                    _kwargs["symbol"] = new_symbols_irfcl
+                    results.extend(await _get_irfcl_data(**_kwargs))
+            except (EmptyDataError, OpenBBError) as e:
+                if new_symbols_fsi:
+                    exceptions.append(
+                        f"IRFCL dataset error -> {e.__class__.__name__}: {e}"
+                    )
+                else:
+                    raise
+            if new_symbols_fsi:
+                try:
+                    _kwargs = query.model_dump(exclude_none=True)
+                    _kwargs["symbol"] = new_symbols_fsi
+                    results.extend(await _get_fsi_data(**_kwargs))
+                except (EmptyDataError, OpenBBError) as e:
+                    if new_symbols_irfcl and len(results) > 0:
+                        exceptions.append(
+                            f"FSI dataset error -> {e.__class__.__name__}: {e}"
+                        )
+                    elif not new_symbols_irfcl:
+                        raise
+        except OpenBBError as exc:
+            raise exc from exc
+
+        if not results:
+            raise EmptyDataError("No results returned for the query.")
+
+        if results and exceptions:
+            msgs = "\n".join(exceptions)
+            warn("An error occurred while fetching the data -> " + msgs)
+
+        return results
+
+    @staticmethod
+    def transform_data(
+        query: ImfEconomicIndicatorsQueryParams,
+        data: List[Dict],
+        **kwargs: Any,
+    ) -> List[ImfEconomicIndicatorsData]:
+        """Transform the data."""
+        # pylint: disable = import-outside-toplevel
+        from numpy import nan
+        from pandas import Categorical, DataFrame
+
+        if not data:
+            raise EmptyDataError("The data is empty.")
+
+        all_symbols = {
+            **load_symbols("all"),
+        }
+        df = DataFrame(data)
+
+        if df.empty:
+            raise EmptyDataError("The data is empty.")
+
+        df = df[df["symbol"].isin(all_symbols)]
+
+        if len(df) == 0:
+            raise OpenBBError("The data has a length of 0.")
+
+        df["symbol"] = Categorical(
+            df["symbol"],
+            categories=all_symbols,
+            ordered=True,
+        )
+        df["parent"] = Categorical(
+            df["parent"],
+            categories=all_symbols,
+            ordered=True,
+        )
+        df = df.sort_values(
+            by=["date", "parent", "symbol", "value"],
+            ascending=[True, True, True, False],
+        ).reset_index(drop=True)
+
+        df.loc[:, "title"] = df.symbol.apply(
+            lambda x: all_symbols.get(x, {}).get("title")
+        )
+        records = df.replace({nan: None}).to_dict(orient="records")
+
+        return [ImfEconomicIndicatorsData.model_validate(r) for r in records]

openbb_platform/providers/imf/openbb_imf/utils/__init__.py

@@ -0,0 +1 @@
+"""IMF Utilities."""

openbb_platform/providers/imf/openbb_imf/utils/constants.py

@@ -0,0 +1,125 @@
+"""IMF Constants."""
+
+# pylint: disable=line-too-long
+# flake8: noqa: E501
+
+FSI_PRESETS = [
+    "fsi_core",
+    "fsi_core_underlying",
+    "fsi_other",
+    "fsi_encouraged_set",
+    "fsi_balance_sheets",
+    "fsi_all",
+]
+
+IRFCL_HEADLINE = "RAF_USD,RAFA_USD,RAFAFX_USD,RAOFA_USD,RAPFA_USD,RAFAIMF_USD,RAFASDR_USD,RAFAGOLD_USD,RACFA_USD,RAMDCD_USD,RAMFIFC_USD,RAMSR_USD"
+
+RESERVE_ASSETS_AND_OTHER_FX_ASSETS = "RAF_USD,RAFA_USD,RAFAFX_USD,RAFAFXS_USD,RAFAFXSI_USD,RAFAFXCD_USD,RAFAFXCDN_USD,RAFAFXCDBI_USD,RAFAFXCDBIA_USD,RAFAFXCDBO_USD,RAFAFXCDBOA_USD,RAFAIMF_USD,RAFASDR_USD,RAFAGOLD_USD,RAFAGOLDV_OZT,RAFAO_USD,RAFAOF_USD,RAFAOL_USD,RAFAOO_USD,RAOFA_USD,RAOFAS_USD,RAOFAD_USD,RAOFAL_USD,RAOFAF_USD,RAOFAG_USD"
+
+PREDETERMINED_DRAINS_ON_FX_ASSETS = "RAPFA_USD,RAPFALSD_USD,RAPFALSD_1M_USD,RAPFALSD_1M_3M_USD,RAPFALSD_3M_1Y_USD,RAPFALSDOP_USD,RAPFALSDOP_1M_USD,RAPFALSDOP_1M_3M_USD,RAPFALSDOP_3M_1Y_USD,RAPFALSDOI_USD,RAPFALSDOI_1M_USD,RAPFALSDOI_1M_3M_USD,RAPFALSDOI_3M_1Y_USD,RAPFALSDIP_USD,RAPFALSDIP_1M_USD,RAPFALSDIP_1M_3M_USD,RAPFALSDIP_3M_1Y_USD,RAPFALSDII_USD,RAPFALSDII_1M_USD,RAPFALSDII_1M_3M_USD,RAPFALSDII_3M_1Y_USD,RAPFAFFS_USD,RAPFAFFS_1M_USD,RAPFAFFS_1M_3M_USD,RAPFAFFS_3M_1Y_USD,RAPFAFFL_USD,RAPFAFFL_1M_USD,RAPFAFFL_1M_3M_USD,RAPFAFFL_3M_1Y_USD,RAPFAO_USD,RAPFAO_1M_USD,RAPFAO_1M_3M_USD,RAPFAO_3M_1Y_USD,RAPFAOOR_USD,RAPFAOOR_1M_USD,RAPFAOOR_1M_3M_USD,RAPFAOOR_3M_1Y_USD,RAPFAOIRR_USD,RAPFAOIRR_1M_USD,RAPFAOIRR_1M_3M_USD,RAPFAOIRR_3M_1Y_USD,RAPFAOOC_USD,RAPFAOOC_1M_USD,RAPFAOOC_1M_3M_USD,RAPFAOOC_3M_1Y_USD,RAPFAOIC_USD,RAPFAOIC_1M_USD,RAPFAOIC_1M_3M_USD,RAPFAOIC_3M_1Y_USD,RAPFAOOP_USD,RAPFAOOP_1M_USD,RAPFAOOP_1M_3M_USD,RAPFAOOP_3M_1Y_USD,RAPFAOIR_USD,RAPFAOIR_1M_USD,RAPFAOIR_1M_3M_USD,RAPFAOIR_3M_1Y_USD,RAFA_RAPFA_RO"
+
+CONTINGENT_DRAINS_FX_ASSETS = "RACFA_USD,RACFAL_USD,RACFAL_1M_USD,RACFAL_1M_3M_USD,RACFAL_3M_1Y_USD,RACFALG_USD,RACFALG_1M_USD,RACFALG_1M_3M_USD,RACFALO_USD,RACFALO_1M_USD,RACFALO_1M_3M_USD,RACFALO_3M_1Y_USD,RACFAS_USD,RACFACB_USD,RACFACB_1M_USD,RACFACB_1M_3M_USD,RACFACB_3M_1Y_USD,RACFACBA_USD,RACFACBA_1M_USD,RACFACBA_1M_3M_USD,RACFACBA_3M_1Y_USD,RACFACBAOI_USD,RACFACBAOI_1M_USD,RACFACBAOI_1M_3M_USD,RACFACBAON_USD,RACFACBAON_1M_USD,RACFACBAON_1M_3M_USD,RACFACBAON_3M_1Y_USD,RACFACBABIS_USD,RACFACBAIMF_1M_USD,RACFACBAIMF_1M_3M_USD,RACFACBAIMF_3M_1Y_USD,RACFACBAIMF_USD,RACFACBFIR_USD,RACFACBFIR_1M_USD,RACFACBFIR_1M_3M_USD,RACFACBFIR_3M_1Y_USD,RACFACBFIO_USD,RACFACBFIO_1M_USD,RACFACBFIO_1M_3M_USD,RACFACBFIO_3M_1Y_USD,RACFACT_USD,RACFACT_1M_USD,RACFACT_1M_3M_USD,RACFACT_3M_1Y_USD,RACFACTA_USD,RACFACTA_1M_USD,RACFACTA_1M_3M_USD,RACFACTA_3M_1Y_USD,RACFACTAOI_USD,RACFACTAOI_1M_USD,RACFACTAOI_1M_3M_USD,RACFACTAOI_3M_1Y_USD,RACFACTAON_USD,RACFACTAON_1M_USD,RACFACTAON_1M_3M_USD,RACFACTAON_3M_1Y_USD,RACFACTABIS_USD,RACFACTABIS_1M_USD,RACFACTABIS_1M_3M_USD,RACFACTABIS_3M_1Y_USD,RACFACTAIMF_USD,RACFACTAIMF_1M_USD,RACFACTFIR_USD,RACFACTFIR_1M_USD,RACFACTFIR_1M_3M_USD,RACFACTFIR_3M_1Y_USD,RACFACTFIO_USD,RACFACTFIO_1M_USD,RACFACTFIO_1M_3M_USD,RACFACTFIO_3M_1Y_USD,RACFAPPS_USD,RACFAPPS_1M_USD,RACFAPPS_1M_3M_USD,RACFAPPS_3M_1Y_USD,RACFAPPSBP_USD,RACFAPPSBP_1M_USD,RACFAPPSBP_1M_3M_USD,RACFAPPSBP_3M_1Y_USD,RACFAPPSWC_USD,RACFAPPSWC_1M_USD,RACFAPPSWC_1M_3M_USD,RACFAPPSWC_3M_1Y_USD,RACFAPPL_USD,RACFAPPL_1M_USD,RACFAPPL_1M_3M_USD,RACFAPPL_3M_1Y_USD,RACFAPPLBC_USD,RACFAPPLBC_1M_USD,RACFAPPLBC_1M_3M_USD,RACFAPPLBC_3M_1Y_USD,RACFAPPLWP_USD,RACFAPPLWP_1M_USD,RACFAPPLWP_1M_3M_USD,RACFAPPLWP_3M_1Y_USD,RACFAMPAS_USD,RACFAMPAS_1M_USD,RACFAMPAS_1M_3M_USD,RACFAMPAS_3M_1Y_USD,RACFAMPAL_USD,RACFAMPAL_1M_USD,RACFAMPAL_1M_3M_USD,RACFAMPAL_3M_1Y_USD,RACFAMPBS_USD,RACFAMPBS_1M_USD,RACFAMPBS_1M_3M_USD,RACFAMPBS_3M_1Y_USD,RACFAMPBL_USD,RACFAMPBL_1M_USD,RACFAMPBL_1M_3M_USD,RACFAMPBL_3M_1Y_USD,RACFAMPCS_USD,RACFAMPCS_1M_USD,RACFAMPCS_1M_3M_USD,RACFAMPCS_3M_1Y_USD,RACFAMPCL_USD,RACFAMPCL_1M_USD,RACFAMPCL_1M_3M_USD,RACFAMPCL_3M_1Y_USD,RACFAMPDS_USD,RACFAMPDS_1M_USD,RACFAMPDS_1M_3M_USD,RACFAMPDS_3M_1Y_USD,RACFAMPDL_USD,RACFAMPDL_1M_USD,RACFAMPDL_1M_3M_USD,RACFAMPDL_3M_1Y_USD,RACFAMPES_USD,RACFAMPES_1M_USD,RACFAMPES_1M_3M_USD,RACFAMPES_3M_1Y_USD,RACFAMPEL_USD,RACFAMPEL_1M_USD,RACFAMPEL_1M_3M_USD,RACFAMPEL_3M_1Y_USD,RACFAMPFS_USD,RACFAMPFS_1M_USD,RACFAMPFS_1M_3M_USD,RACFAMPFS_3M_1Y_USD,RACFAMPFL_USD,RACFAMPFL_1M_USD,RACFAMPFL_1M_3M_USD,RACFAMPFL_3M_1Y_USD"
+
+IRFCL_MEMORANDUM_ITEMS = "RAMDCD_USD,RAMFIFC_USD,RAMPA_USD,RAMFFS_USD,RAMPAOA_USD,RAMSR_USD,RAMSRLRI_USD,RAMSRLRN_USD,RAMSRBRI_USD,RAMSRBAN_USD,RAMFDA_USD,RAMFDAF_USD,RAMFDAU_USD,RAMFDAW_USD,RAMFDAP_USD,RAMFDAO_USD,RAMFFL_USD,RAMPPS_USD,RAMPPSBP_USD,RAMPPSWC_USD,RAMPPL_USD,RAMPPLBP_USD,RAMPPLWC_USD,RAMCR_USD,RAMCRISDR_USD,RAMCRIC_USD_USD,RAMCRIC_EUR_USD,RAMCRIC_CNY_USD,RAMCRIC_JPY_USD,RAMCRIC_GBP_USD,RAMCROSDR_USD"
+
+IRFCL_TABLES = {
+    "reserve_assets_and_other_fx_assets": RESERVE_ASSETS_AND_OTHER_FX_ASSETS,
+    "predetermined_drains_on_fx_assets": PREDETERMINED_DRAINS_ON_FX_ASSETS,
+    "contingent_drains_fx_assets": CONTINGENT_DRAINS_FX_ASSETS,
+    "memorandum_items": IRFCL_MEMORANDUM_ITEMS,
+}
+
+IRFCL_PRESET = {
+    "irfcl_top_lines": IRFCL_HEADLINE,
+    **IRFCL_TABLES,
+    "gold_reserves": "RAFAGOLD_USD,RAFAGOLDV_OZT",
+    "derivative_assets": "RAMFDA_USD",
+}
+
+FREQUENCY_DICT = {
+    "month": "M",
+    "quarter": "Q",
+    "annual": "A",
+}
+REF_SECTORS_DICT = {
+    "government_ex_social_security": "S1311",
+    "central_bank": "S121",
+    "monetary_authorities": "S1X",
+    "all_sectors": "",
+}
+
+SECTOR_MAP = {v: k for k, v in REF_SECTORS_DICT.items()}
+
+UNIT_MULTIPLIERS_MAP = {
+    "0": "Units",
+    "2": "Hundreds",
+    "3": "Thousands",
+    "6": "Millions",
+    "9": "Billions",
+    "12": "Trillions",
+    "N15": "Quadrillionths",
+    "N14": "Hundred Trillionths",
+    "N13": "Ten Trillionths",
+    "N12": "Trillionths",
+    "N11": "Hundred Billionths",
+    "N10": "Ten Billionths",
+    "N9": "Billionths",
+    "N8": "Hundred Millionths",
+    "N7": "Ten Millionths",
+    "N6": "Millionths",
+    "N5": "Hundred Thousandths",
+    "N4": "Ten Thousandths",
+    "N3": "Thousandths",
+    "N2": "Hundredths",
+    "N1": "Tenths",
+    "1": "Tens",
+    "4": "Ten Thousands",
+    "5": "Hundred Thousands",
+    "7": "Ten Millions",
+    "8": "Hundred Millions",
+    "10": "Ten Billions",
+    "11": "Hundred Billions",
+    "13": "Ten Trillions",
+    "14": "Hundred Trillions",
+    "15": "Quadrillions",
+}
+
+TIME_FORMAT_MAP = {
+    "P1Y": "Annual",
+    "P6M": "Bi-annual",
+    "P3M": "Quarterly",
+    "P1M": "Monthly",
+    "P7D": "Weekly",
+    "P1D": "Daily",
+}
+
+REF_SECTOR_MAP = {
+    "S1311": "Central government excluding social security",
+    "S121": "Central Bank",
+    "S1X": "Monetary Authorities",
+    "1C_AS": "All Sectors",
+    "AllSectorsIncludingAllSectors": "All Sectors Including All Sectors",
+}
+
+
+def load_symbols(dataset: str) -> dict:
+    """Load IMF symbol list."""
+    # pylint: disable=import-outside-toplevel
+    import json  # noqa
+    from json.decoder import JSONDecodeError
+    from pathlib import Path
+    from openbb_core.app.model.abstract.error import OpenBBError
+
+    try:
+        symbols_file = Path(__file__).parents[1].joinpath("assets", "imf_symbols.json")
+        with symbols_file.open(encoding="utf-8") as file:
+            symbols = json.load(file)
+    except (FileNotFoundError, JSONDecodeError) as e:
+        raise OpenBBError(
+            f"Failed to load IMF symbols from the static file: {e}"
+        ) from e
+
+    if dataset == "all":
+        return symbols
+
+    return {k: v for k, v in symbols.items() if v["dataset"] == dataset}

openbb_platform/providers/imf/openbb_imf/utils/dot_helpers.py

@@ -0,0 +1,87 @@
+"""Direction Of Trade Utilities."""
+
+from openbb_core.app.model.abstract.error import OpenBBError
+
+
+def load_country_map() -> dict:
+    """Load IMF IRFCL country map."""
+    # pylint: disable=import-outside-toplevel
+    import json  # noqa
+    from json.decoder import JSONDecodeError
+    from pathlib import Path
+
+    try:
+        country_map_file = (
+            Path(__file__).parents[1].joinpath("assets", "imf_country_map.json")
+        )
+        with country_map_file.open(encoding="utf-8") as file:
+            country_map_dict = json.load(file)
+    except (FileNotFoundError, JSONDecodeError) as e:
+        raise OpenBBError(f"Failed to load IMF DOT country map: {e}") from e
+
+    return country_map_dict
+
+
+def load_country_to_code_map() -> dict:
+    """Load a map of lowercase country name to 2-letter ISO symbol."""
+    # pylint: disable=import-outside-toplevel
+    from warnings import warn  # noqa
+
+    try:
+        return {
+            (
+                "euro_area"
+                if k == "U2"
+                else v.lower()
+                .replace(".", "")
+                .replace(",", "")
+                .replace(":", "")
+                .split("(")[0]
+                .strip()
+                .replace(" ", "_")
+            ): k
+            for k, v in load_country_map().items()
+            if not k.startswith("1C_ALL")
+            and "Report" not in v
+            and k not in ("GW", "_X")
+        }
+    except OpenBBError:
+        warn(f"Failed to load country to code map. -> {OpenBBError}")
+        return {}
+
+
+def validate_countries(countries: list[str]) -> str:
+    """Validate the list of countries."""
+    # pylint: disable=import-outside-toplevel
+    from warnings import warn
+
+    try:
+        country_to_code_map = load_country_to_code_map()
+    except OpenBBError as e:
+        raise OpenBBError(f"Failed to load country to code map: {e}") from e
+    if not country_to_code_map:
+        raise OpenBBError("Failed to load country to code map.")
+
+    new_countries: list = []
+
+    for country in countries:
+        if country == "all":
+            return country
+        if country in country_to_code_map:
+            new_countries.append(country_to_code_map.get(country))
+        elif country.upper() in country_to_code_map.values():
+            new_countries.append(country.upper())
+        elif country.lower() == "eu":
+            new_countries.append(country_to_code_map.get("european_union"))
+        elif country.lower() == "ea":
+            new_countries.append(country_to_code_map.get("euro_area"))
+        else:
+            warn(f"Invalid country {country}")
+            continue
+
+    if not new_countries:
+        raise OpenBBError(
+            f"No valid countries found. Please choose from {list(country_to_code_map)}"
+        )
+
+    return "+".join(new_countries)

openbb_platform/providers/imf/openbb_imf/utils/fsi_helpers.py

@@ -0,0 +1,247 @@
+"""IMF FSI Data Set Helpers."""
+
+from typing import Optional
+
+
+def load_fsi_symbols() -> dict:
+    """Load IMF FSI symbols."""
+    # pylint: disable=import-outside-toplevel
+    from openbb_imf.utils.constants import load_symbols
+
+    return load_symbols("FSI")
+
+
+def validate_symbols(symbols) -> str:
+    """Validate the IMF FSI symbols."""
+    # pylint: disable=import-outside-toplevel
+    from warnings import warn  # noqa
+    from openbb_core.app.model.abstract.error import OpenBBError
+    from openbb_imf.utils.constants import FSI_PRESETS
+
+    fsi_symbols = load_fsi_symbols()
+
+    if isinstance(symbols, str):
+        symbols = symbols.split(",")
+    elif not isinstance(symbols, list):
+        raise OpenBBError("Invalid symbols list.")
+
+    new_symbols: list = []
+
+    for symbol in symbols:
+        if symbol in FSI_PRESETS:
+            return symbol
+        if symbol.upper() not in fsi_symbols:
+            warn(f"Unsupported IMF FSI symbol: {symbol}")
+        new_symbols.append(symbol.upper())
+
+    return "+".join(new_symbols) if len(new_symbols) > 1 else new_symbols[0]
+
+
+# pylint: disable=too-many-branches,too-many-statements,too-many-locals
+async def _get_fsi_data(**kwargs) -> list[dict]:  # noqa:PLR0912
+    """Get IMF FSI data.
+    This function is not intended to be called directly,
+    but through the `ImfEconomicIndicatorsFetcher` class.
+    """
+    # pylint: disable=import-outside-toplevel
+    from datetime import date  # noqa
+    from openbb_core.app.model.abstract.error import OpenBBError
+    from openbb_imf.utils.helpers import get_data
+    from openbb_imf.utils.irfcl_helpers import load_country_to_code_map
+    from openbb_imf.utils import constants
+    from pandas import to_datetime
+    from pandas.tseries import offsets
+
+    countries = kwargs.get("country", "")
+    countries = (
+        "" if countries == "all" else countries.replace(",", "+") if countries else ""
+    )
+    frequency = constants.FREQUENCY_DICT.get(kwargs.get("frequency", "quarter"), "Q")
+    start_date = kwargs.get("start_date", "")
+    end_date = kwargs.get("end_date", "")
+    all_symbols = load_fsi_symbols()
+    core_only = [k for k, v in all_symbols.items() if v.get("table") == "fsi_core"]
+    encouraged_set = [
+        k for k, v in all_symbols.items() if v.get("table") == "fsi_encouraged_set"
+    ]
+    indicator = kwargs.get("symbol")
+    indicators = (
+        "+".join(core_only if indicator == "fsi_core" else encouraged_set)
+        if indicator in ["fsi_core", "fsi_encouraged_set"]
+        else (
+            ""
+            if indicator
+            in ["fsi_other", "fsi_all", "fsi_core_underlying", "fsi_balance_sheets"]
+            else validate_symbols(indicator)
+        )
+    )
+
+    if not indicators and not countries:
+        raise OpenBBError(
+            "All countries not supported for this group of indicators. Please supply a country."
+        )
+
+    if not start_date and not end_date and not countries:
+        start_date = (
+            date.today().replace(year=date.today().year - 1).strftime("%Y-%m-%d")
+        )
+
+    if start_date and not end_date:
+        end_date = date.today().strftime("%Y-%m-%d")
+
+    # Adjust the dates to the date relative to frequency.
+    # The API does not accept arbitrary dates, so we need to adjust them.
+    if start_date:
+        start_date = to_datetime(start_date)
+        if frequency == "Q":
+            start_date = offsets.QuarterBegin(startingMonth=1).rollback(start_date)
+        elif frequency == "A":
+            start_date = offsets.YearBegin().rollback(start_date)
+        else:
+            start_date = offsets.MonthBegin().rollback(start_date)
+        start_date = start_date.strftime("%Y-%m-%d")
+
+    if end_date:
+        end_date = to_datetime(end_date)
+        if frequency == "Q":
+            end_date = offsets.QuarterEnd().rollforward(end_date)
+        elif frequency == "A":
+            end_date = offsets.YearEnd().rollforward(end_date)
+        else:
+            end_date = offsets.MonthEnd().rollforward(end_date)
+        end_date = end_date.strftime("%Y-%m-%d")
+
+    date_range = (
+        f"?startPeriod={start_date}&endPeriod={end_date}"
+        if start_date and end_date
+        else ""
+    )
+    base_url = "http://dataservices.imf.org/REST/SDMX_JSON.svc/"
+    key = f"CompactData/FSI/{frequency}.{countries}.{indicators}"
+    url = f"{base_url}{key}{date_range}"
+    series = await get_data(url)
+    data: list = []
+    all_symbols = load_fsi_symbols()
+
+    if indicator in ["fsi_core", "fsi_encouraged_set"]:
+        all_symbols = {
+            k: v for k, v in all_symbols.items() if v.get("table") == indicator
+        }
+    elif indicator == "fsi_core_underlying":
+        all_symbols = {
+            k: v
+            for k, v in all_symbols.items()
+            if "core set" in v.get("title", "").lower() and v.get("unit") != "Percent"
+        }
+    elif indicator == "fsi_balance_sheets":
+        all_symbols = {
+            k: v
+            for k, v in all_symbols.items()
+            if "balance sheets" in v.get("title", "").lower()
+        }
+    elif indicator == "fsi_other":
+        all_symbols = {
+            k: v
+            for k, v in all_symbols.items()
+            if "Additional FSIs" in v.get("title", "")
+        }
+
+    country_map_dict = {
+        v: k.replace("_", " ").title().replace("Ecb", "ECB")
+        for k, v in load_country_to_code_map().items()
+    }
+    # Iterate over the series to extract observations and map the metadata.
+    for s in series:
+        if "Obs" not in s:
+            continue
+        meta = {
+            k.replace("@", "").lower(): (
+                constants.UNIT_MULTIPLIERS_MAP.get(str(v), v)
+                if k == "@UNIT_MULT"
+                else v
+            )
+            for k, v in s.items()
+            if k != "Obs"
+        }
+        _symbol = meta.get("indicator")
+        _parent: Optional[str] = None
+        _order: Optional[str] = None
+        _level: Optional[str] = None
+        _table: Optional[str] = None
+        _title: Optional[str] = None
+        _unit: Optional[str] = None
+
+        if _symbol not in all_symbols:
+            continue
+
+        _table = all_symbols.get(_symbol, {}).get("table", "")
+        if _table and indicator == "fsi_core_underlying":
+            _table = _table.replace("fsi_other", "fsi_core_underlying")  # type: ignore
+        _parent = all_symbols.get(_symbol, {}).get("parent", "")
+        _order = all_symbols.get(_symbol, {}).get("order", "")
+        _level = all_symbols.get(_symbol, {}).get("level", "")
+        _title = all_symbols.get(_symbol, {}).get("title", "")
+        if _title:
+            _title = " - ".join(_title.split(", ")[1:-1]).replace(
+                "Financial Soundness Indicators - ", ""
+            )
+        _unit = all_symbols.get(_symbol, {}).get("unit", "")
+
+        _data = s.pop("Obs", [])
+
+        if isinstance(_data, dict):
+            _data = [_data]
+
+        for d in _data:
+            _date = d.pop("@TIME_PERIOD", None)
+            val = d.pop("@OBS_VALUE", None)
+            _ = d.pop("@OBS_STATUS", None)
+            if not val:
+                continue
+            val = float(val)
+            if _unit and _unit.lower() == "percent":
+                val = val / 100
+            if _date:
+                offset = (
+                    offsets.QuarterEnd
+                    if "Q" in _date
+                    else offsets.YearEnd if len(str(_date)) == 4 else offsets.MonthEnd
+                )
+                _date = to_datetime(_date)
+                _date = _date + offset(0)
+                _date = _date.strftime("%Y-%m-%d")
+            vals = {
+                k: v
+                for k, v in {
+                    "date": _date,
+                    "table": _table,
+                    "symbol": _symbol,
+                    "parent": _parent if _parent else _symbol,
+                    "level": _level,
+                    "order": _order,
+                    "country": country_map_dict.get(
+                        meta.get("ref_area"), meta.get("ref_area")
+                    ),
+                    "reference_sector": None,
+                    "title": _title,
+                    "value": val,
+                    "unit": (
+                        _unit.upper() if _unit and _unit in ["usd", "eur"] else _unit
+                    ),
+                    "scale": (
+                        "Basis Points"
+                        if _unit and _unit.lower() == "percent"
+                        else meta.get("unit_mult")
+                    ),
+                }.items()
+                if v
+            }
+
+            if vals.get("value") and vals.get("date"):
+                d.update(vals)
+                data.append(d)
+
+    if not data:
+        raise OpenBBError(f"No data found for, '{indicator}', in, '{countries}'.")
+
+    return data

openbb_platform/providers/imf/openbb_imf/utils/helpers.py

@@ -0,0 +1,34 @@
+"""IMF Helper Utilities."""
+
+
+async def get_data(url: str) -> list[dict]:
+    """Get data from the IMF API."""
+    # pylint: disable=import-outside-toplevel
+
+    from aiohttp.client_exceptions import ContentTypeError  # noqa
+    from json.decoder import JSONDecodeError
+    from openbb_core.provider.utils.helpers import amake_request
+    from openbb_core.app.model.abstract.error import OpenBBError
+
+    try:
+        response = await amake_request(url, timeout=20)
+    except (JSONDecodeError, ContentTypeError) as e:
+        raise OpenBBError(
+            "Error fetching data; This might be rate-limiting. Try again later."
+        ) from e
+
+    if "ErrorDetails" in response:
+        raise OpenBBError(
+            f"{response['ErrorDetails'].get('Code')} -> {response['ErrorDetails'].get('Message')}"  # type: ignore
+        )
+
+    series = response.get("CompactData", {}).get("DataSet", {}).pop("Series", {})  # type: ignore
+
+    if not series:
+        raise OpenBBError(f"No time series data found -> {response}")
+
+    # If there is only one series, they ruturn a dict instead of a list.
+    if series and isinstance(series, dict):
+        series = [series]
+
+    return series

openbb_platform/providers/imf/openbb_imf/utils/irfcl_helpers.py

@@ -0,0 +1,283 @@
+"""IMF IRFCL Data Set Helpers."""
+
+from typing import Optional
+
+
+def load_irfcl_symbols() -> dict:
+    """Load IMF IRFCL symbols."""
+    # pylint: disable=import-outside-toplevel
+    from openbb_imf.utils.constants import load_symbols
+
+    return load_symbols("IRFCL")
+
+
+def load_country_map() -> dict:
+    """Load IMF IRFCL country map."""
+    # pylint: disable=import-outside-toplevel
+    import json  # noqa
+    from json.decoder import JSONDecodeError
+    from pathlib import Path
+    from openbb_core.app.model.abstract.error import OpenBBError
+
+    try:
+        country_map_file = (
+            Path(__file__).parents[1].joinpath("assets", "imf_country_map.json")
+        )
+        with country_map_file.open(encoding="utf-8") as file:
+            country_map_dict = json.load(file)
+    except (FileNotFoundError, JSONDecodeError) as e:
+        raise OpenBBError(f"Failed to load IMF IRFCL country map: {e}") from e
+
+    return {
+        k: v.split(",")[0].split("_(")[0]
+        for k, v in country_map_dict.items()
+        if len(k) == 2
+        and k[0] not in ("5", "1", "7")
+        and k not in ("X0", "R1", "GW", "F1", "F6")
+    }
+
+
+def load_country_to_code_map() -> dict:
+    """Load a map of lowercase country name to 2-letter ISO symbol."""
+    return {
+        (
+            "euro_area"
+            if k == "U2"
+            else v.lower()
+            .replace(" ", "_")
+            .replace("`", "")
+            .split(",")[0]
+            .split("_(")[0]
+        ): k
+        for k, v in load_country_map().items()
+    }
+
+
+def validate_countries(countries) -> str:
+    """Validate the country and convert to a 2-letter ISO country code."""
+    # pylint: disable=import-outside-toplevel
+    from warnings import warn  # noqa
+    from openbb_core.app.model.abstract.error import OpenBBError
+
+    country_map_dict = load_country_to_code_map()
+
+    if isinstance(countries, str):
+        countries = countries.split(",")
+    elif not isinstance(countries, list):
+        raise OpenBBError("Invalid countries list.")
+
+    new_countries: list = []
+
+    if "all" in countries or "ALL" in countries:
+        return "all"
+
+    for country in countries:
+        if country.lower() not in country_map_dict and country.upper() not in list(
+            country_map_dict.values()
+        ):
+            warn(f"Invalid IMF IRFCL country: {country}")
+            continue
+
+        if country.upper() in list(country_map_dict.values()):
+            new_countries.append(country.upper())
+        else:
+            new_countries.append(country_map_dict.get(country, country).upper())
+
+    new_countries = [c for c in new_countries if c]
+
+    if not new_countries:
+        raise OpenBBError("No valid countries found in the supplied list.")
+
+    return ",".join(new_countries)
+
+
+def validate_symbols(symbols) -> str:
+    """Validate the IMF IRFCL symbols."""
+    # pylint: disable=import-outside-toplevel
+    from warnings import warn  # noqa
+    from openbb_core.app.model.abstract.error import OpenBBError
+    from openbb_imf.utils.constants import IRFCL_PRESET
+
+    irfcl_symbols = load_irfcl_symbols()
+
+    if isinstance(symbols, str):
+        symbols = symbols.split(",")
+    elif not isinstance(symbols, list):
+        raise OpenBBError("Invalid symbols list.")
+
+    if "IRFCL" in symbols or "all" in symbols:
+        return "all"
+
+    new_symbols: list = []
+
+    for symbol in symbols:
+        if symbol in IRFCL_PRESET:
+            return IRFCL_PRESET[symbol].replace(",", "+")
+        if symbol.upper() not in irfcl_symbols:
+            warn(f"Invalid IMF IRFCL symbol: {symbol}")
+        new_symbols.append(symbol.upper())
+
+    return "+".join(new_symbols) if len(new_symbols) > 1 else new_symbols[0]
+
+
+# We use this as a helper to allow future expansion of the supported IMF indicators.
+# Each database has its own nuances with URL construction and schemas.
+
+
+# pylint: disable=too-many-branches,too-many-statements,too-many-locals
+async def _get_irfcl_data(**kwargs) -> list[dict]:
+    """Get IMF IRFCL data.
+    This function is not intended to be called directly,
+    but through the `ImfEconomicIndicatorsFetcher` class.
+    """
+    # pylint: disable=import-outside-toplevel
+    from openbb_core.app.model.abstract.error import OpenBBError
+    from openbb_imf.utils import constants
+    from openbb_imf.utils.helpers import get_data
+    from pandas import to_datetime
+    from pandas.tseries import offsets
+
+    countries = kwargs.get("country", "")
+    countries = (
+        "" if countries == "all" else countries.replace(",", "+") if countries else ""
+    )
+
+    frequency = constants.FREQUENCY_DICT.get(kwargs.get("frequency", "quarter"), "Q")
+    sector = kwargs.get("sector", "monetary_authorities")
+    sector = constants.REF_SECTORS_DICT.get(sector, "")
+    start_date = kwargs.get("start_date", "")
+    end_date = kwargs.get("end_date", "")
+
+    # Adjust the dates to the date relative to frequency.
+    # The API does not accept arbitrary dates, so we need to adjust them.
+    if start_date:
+        start_date = to_datetime(start_date)
+        if frequency == "Q":
+            start_date = offsets.QuarterBegin(startingMonth=1).rollback(start_date)
+        elif frequency == "A":
+            start_date = offsets.YearBegin().rollback(start_date)
+        else:
+            start_date = offsets.MonthBegin().rollback(start_date)
+        start_date = start_date.strftime("%Y-%m-%d")
+
+    if end_date:
+        end_date = to_datetime(end_date)
+        if frequency == "Q":
+            end_date = offsets.QuarterEnd().rollforward(end_date)
+        elif frequency == "A":
+            end_date = offsets.YearEnd().rollforward(end_date)
+        else:
+            end_date = offsets.MonthEnd().rollforward(end_date)
+        end_date = end_date.strftime("%Y-%m-%d")
+
+    indicator = kwargs.get("symbol")
+    indicators = validate_symbols(indicator) if indicator else ""
+    indicators = "" if indicators == "all" else indicators
+
+    if not indicators and not countries:
+        raise OpenBBError("Country is required when returning the complete dataset.")
+
+    date_range = (
+        f"?startPeriod={start_date}&endPeriod={end_date}"
+        if start_date and end_date
+        else ""
+    )
+    base_url = "http://dataservices.imf.org/REST/SDMX_JSON.svc/"
+    key = f"CompactData/IRFCL/{frequency}.{countries}.{indicators}.{sector}"
+    url = f"{base_url}{key}{date_range}"
+
+    series = await get_data(url)
+
+    data: list = []
+    all_symbols = load_irfcl_symbols()
+    country_map_dict = {
+        v: k.replace("_", " ").title().replace("Ecb", "ECB")
+        for k, v in load_country_to_code_map().items()
+    }
+    # Iterate over the series to extract observations and map the metadata.
+    for s in series:
+        if "Obs" not in s:
+            continue
+        meta = {
+            k.replace("@", "").lower(): (
+                constants.UNIT_MULTIPLIERS_MAP.get(str(v), v)
+                if k == "@UNIT_MULT"
+                else v
+            )
+            for k, v in s.items()
+            if k != "Obs"
+        }
+        _symbol = meta.get("indicator")
+        _parent: Optional[str] = None
+        _order: Optional[str] = None
+        _level: Optional[str] = None
+        _table: Optional[str] = None
+        _title: Optional[str] = None
+        _unit: Optional[str] = None
+
+        if _symbol not in all_symbols:
+            continue
+
+        _table = all_symbols.get(_symbol, {}).get("table")
+        _parent = all_symbols.get(_symbol, {}).get("parent", "")
+        _order = all_symbols.get(_symbol, {}).get("order", "")
+        _level = all_symbols.get(_symbol, {}).get("level", "")
+        _title = all_symbols.get(_symbol, {}).get("title", "").replace(", ", " - ")
+        _unit = all_symbols.get(_symbol, {}).get("unit", "")
+
+        if _title:
+            _title = " - ".join(_title.split(", ")[:-1])
+
+        _data = s.pop("Obs", [])
+
+        if isinstance(_data, dict):
+            _data = [_data]
+
+        for d in _data:
+            _date = d.pop("@TIME_PERIOD", None)
+            val = d.pop("@OBS_VALUE", None)
+            _ = d.pop("@OBS_STATUS", None)
+
+            if not val:
+                continue
+
+            if _date:
+                offset = (
+                    offsets.QuarterEnd
+                    if "Q" in _date
+                    else offsets.YearEnd if len(str(_date)) == 4 else offsets.MonthEnd
+                )
+                _date = to_datetime(_date)
+                _date = _date + offset(0)
+                _date = _date.strftime("%Y-%m-%d")
+            vals = {
+                k: v
+                for k, v in {
+                    "date": _date,
+                    "table": _table,
+                    "symbol": _symbol,
+                    "parent": _parent,
+                    "order": _order,
+                    "level": _level,
+                    "country": country_map_dict.get(
+                        meta.get("ref_area"), meta.get("ref_area")
+                    ),
+                    "reference_sector": constants.SECTOR_MAP.get(
+                        meta.get("ref_sector"), meta.get("ref_sector")
+                    ),
+                    "title": _title,
+                    "value": float(val) if val else None,
+                    "unit": _unit,
+                    "scale": meta.get("unit_mult"),
+                }.items()
+                if v
+            }
+
+            if vals.get("value") and vals.get("date"):
+                d.update(vals)
+                data.append(d)
+
+    if not data:
+        raise OpenBBError(f"No data found for '{indicator}' in '{countries}'.")
+
+    return data

openbb_platform/providers/imf/pyproject.toml

@@ -0,0 +1,19 @@
+[tool.poetry]
+name = "openbb-imf"
+version = "1.1.1"
+description = "https://datahelp.imf.org/knowledgebase/articles/630877-api"
+authors = ["OpenBB Team <hello@openbb.co>"]
+license = "AGPL-3.0-only"
+readme = "README.md"
+packages = [{ include = "openbb_imf" }]
+
+[tool.poetry.dependencies]
+python = ">=3.9.21,<3.13"
+openbb-core = "^1.4.6"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.poetry.plugins."openbb_provider_extension"]
+imf = "openbb_imf:imf_provider"

openbb_platform/providers/imf/tests/__init__.py

@@ -0,0 +1 @@
+"""IMF Provider Fetcher Tests."""

openbb_platform/providers/imf/tests/record/http/test_imf_fetchers/test_imf_direction_of_trade_fetcher_urllib3_v1.yaml

@@ -0,0 +1,55 @@
+interactions:
+- request:
+    body: null
+    headers:
+      Accept:
+      - application/json
+      Accept-Encoding:
+      - gzip, deflate
+      Connection:
+      - keep-alive
+    method: GET
+    uri: http://dataservices.imf.org/REST/SDMX_JSON.svc/CompactData/DOT/A.US.TXG_FOB_USD.W00+B0?startPeriod=2020-01-01&endPeriod=2023-12-31
+  response:
+    body:
+      string: !!binary |
+        H4sIAAAAAAAEA6SSX6+aQBDFv4qhL216gQVRlCdRsCURsfxprH0gK4xeEgHDbtXG3O/e2dWm1zRp
+        btIXEs6e35nZmb0qs7Y+0oJ7lFPFuSqTS31omHNhleIoz5wfHV0/n8/aua+13V43CTH0dbhIimeo
+        qVo1jNOmAOXpD1i+AZR+VjlMxizagvKqbR7BxAvXsmYHrP3RFcB0IYUL/UYx/WTmRK+BMbqHnuiV
+        YbMd7CvGu58aK+uL5B/sMuKGaBdWSgypEq/PoDtVWEar6p0Ei9todC9K3+oTmfJyYor/cx8M+Qy0
+        hE4sJfAwqrBKwzQGoI6GI1u1LPyMh9uhurUte0TtHRkbBKkUGEf3jh6YWMuqgyPtoETJJKalkrFq
+        ktQYOQPiWBb6E2hKkFUmlXAZM4LqktYgKovn4Bxos0ceGjx4x+HC8ScI58rLkzJrG46vR1izOEBd
+        rAHnKZ7MfYwIpXCA43PbABo+9ozee2zlQ29o9tWhaRLlBYNiKKA6vW5ks9mICh5uJgEuR4CLeCWJ
+        oqK/hmHsvW6JbvaPPWIzCXQVIPL9qkzmsf8FYRflSezPczf2XfzPEiEESy+YuWkUo5KuP+XzaJpn
+        iSeOZlG2TP145cbpb2ZKxEG2DNI8zBYpMkMhpEHoIxmHrpBWxjcUo+29vDxc+XEQeeg3iSkzommS
+        f3UXmS+0ft8eWJpt2wbeHDv+CzEwcPKA2L9ao3cbBoIQiqK9OLYQjz+VONpS6N1jhx6N5GALuAIO
+        0gVKlNehkd9GHVVGZrCQQ6RbFJ0elMEm8Zhrnmu/G0Vf/OW4mxQm3e1kbIw+HLupIj1LQB7Z/Ler
+        cDiWUSdM5TBrg5W1lzso1ltUP7LXzLwBuF028KsFAAA=
+    headers:
+      Cache-Control:
+      - private
+      Connection:
+      - Keep-Alive
+      Content-Encoding:
+      - gzip
+      Content-Length:
+      - '659'
+      Content-Type:
+      - application/json; charset=utf-8
+      Date:
+      - Fri, 20 Sep 2024 22:50:44 GMT
+      Set-Cookie: null
+      Vary:
+      - Accept-Encoding
+      X-Content-Type-Options:
+      - nosniff
+      X-Frame-Options:
+      - SAMEORIGIN
+      X-Permitted-Cross-Domain-Policies:
+      - none
+      X-XSS-Protection:
+      - 1; mode=block
+    status:
+      code: 200
+      message: OK
+version: 1

openbb_platform/providers/imf/tests/record/http/test_imf_fetchers/test_imf_direction_of_trade_fetcher_urllib3_v2.yaml

@@ -0,0 +1,55 @@
+interactions:
+- request:
+    body: null
+    headers:
+      Accept:
+      - application/json
+      Accept-Encoding:
+      - gzip, deflate
+      Connection:
+      - keep-alive
+    method: GET
+    uri: http://dataservices.imf.org/REST/SDMX_JSON.svc/CompactData/DOT/A.US.TXG_FOB_USD.W00+B0?startPeriod=2020-01-01&endPeriod=2023-12-31
+  response:
+    body:
+      string: !!binary |
+        H4sIAAAAAAAEA6SSX6+aQBDFv4qhL216gWVBUJ5EwZZExPKnsfaBbGFUEgHDUrUx97t3Fm3uNU2T
+        m/Rxz57fmZmdvUqzpjqyvHNZxyT7Kk0u1aHm9oWXki3tu+5oq+r5fFbOutK0O5USoqnrYBHne6iY
+        XNa8Y3UO0tMLWLwB7P28tHkfs2hy1pVN/QjGbrDua7bAm59tDlwVUrBQbxRXTzQjagWcsx0MRK8c
+        m21hV/Ku/aXworr0/IO9j7ghyoUXPYZUgeNzaE8lllHKatuD+e1pVDdM3uoTmf1w4hX/Zx4M+Qys
+        gFYsxXcxKtcLTaNkLBcFMWVDHxGZWflQHm1Nczg2iAHWFqkEeIfuLTtwsZZVC0fWQoESJdSQkack
+        0Ua2MbIJQX8MdXGrMimFS5sJdckqEJXFd7APrN4hDzXa33Vw6fDgB3Pp+UmaNXWHv0dY08hHff/y
+        Ze7PiFACBzjumxrQ8HGgDd5jKx8GJtVlk1IiPWNQBDmUp9eNbDYbUcHFzcTQ9U+Ai3gliaKiv5pj
+        7L1ugW4O/94jNhNDWwIi36/SZB55XxB2UJ5E3jxzIs/BcxoLwV+6/sxJwgiVZP0pm4fTLI1dcTUL
+        02XiRSsnSv4wUyIu0qWfZEG6SJAxhZD4gYdkFDhCWmnfUAx/3Mv3lysv8kMX/ZTQPiOcxtlXZ5F6
+        QtN1a2golmVpODl2/BeiYeDkAbHo+Her9G7DMAwDAXSX1AHBo/jtskUqj8LdLbuMICCFBzjw+MgE
+        BdJyk5HfzDBkKqlCXTahsYS8wpzCWcVfffR79ntQ9Hv/5+dpUqhUlZGyMmqz7KKKsEgBmUfx367C
+        bphGFdAhm1kLrMxeZiCfZxnjkj26+wT887SyqwUAAA==
+    headers:
+      Cache-Control:
+      - private
+      Connection:
+      - Keep-Alive
+      Content-Encoding:
+      - gzip
+      Content-Length:
+      - '658'
+      Content-Type:
+      - application/json; charset=utf-8
+      Date:
+      - Fri, 20 Sep 2024 22:48:00 GMT
+      Set-Cookie: null
+      Vary:
+      - Accept-Encoding
+      X-Content-Type-Options:
+      - nosniff
+      X-Frame-Options:
+      - SAMEORIGIN
+      X-Permitted-Cross-Domain-Policies:
+      - none
+      X-XSS-Protection:
+      - 1; mode=block
+    status:
+      code: 200
+      message: OK
+version: 1

openbb_platform/providers/imf/tests/record/http/test_imf_fetchers/test_imf_economic_indicators_fetcher_urllib3_v1.yaml

@@ -0,0 +1,54 @@
+interactions:
+- request:
+    body: null
+    headers:
+      Accept:
+      - application/json
+      Accept-Encoding:
+      - gzip, deflate
+      Connection:
+      - keep-alive
+    method: GET
+    uri: http://dataservices.imf.org/REST/SDMX_JSON.svc/CompactData/IRFCL/M.JP.RAMFDA_USD.S1X?startPeriod=2023-01-01&endPeriod=2023-12-31
+  response:
+    body:
+      string: !!binary |
+        H4sIAAAAAAAEA6SSX4+aQBTFv4qhL226yICiC09S/qQ0oBawMfaBTJmrkggYZlZtzH733hlNttuk
+        zSZ9nHPP7557Z+aq+V1zpJUIqKCae9Vml+bQcvfCa83V9kIcXcM4n8/D82jY9TvDIsQ01mmSV3to
+        qF63XNC2Au3hBWRvAJWf1y5XbZKuoqLu2tdgHqRrldkD7576CrghpTQxbhQ3TlZJjAY4pzsYyFk5
+        DtvDruai/znkrLko/pVdtbghwwtnCkOK4foc+lONMcO62Sqwul2NEWeRn7zdKfuqBeVN/s9O2OQz
+        UAa9fJg4wFbjEXu02cTW2eN2pI8dRnUHto5Ox4wSx7bNCiykCuAC3Vt64PJplj0caQ8MJYtYY504
+        ukkKc+qatmvZ6M+hvafMaukyfYLqnDYgk+WXcA+03SEPLRbeCbgIPMRppD0/aH7XCvxB0rrKYtT3
+        L9/mfpUIFXCA475rAQ0fB+bgPY7yYTCxRvrEsoj2jI0yqKA+gVp3VjM0bjYbmRBQQXMQcYCSeozf
+        RBkrJ2w5Fu/JDP38n6+JA+XQ14DQVZtFWfgV6RTVWRZGpZeFHp6/LKUQz4PY94pFhkrmpVHglas8
+        kBVpzUP/VsrNtdRW87go01VSoHsihSJOwzJaZKknpaUpQxY/MPc7BqviMsziRYB+i+BtEFNSi095
+        +c1LViHK+tQZ48J/sVt/2m0y/dXnHNwADIMwFN2l90oBAnGG6SjZvTmDjM9P1ufaslYfXM+ssY1r
+        z1pMGx6Fo2tZhesCj0HhNjfnu3BfQbmMwrt3kcwxJj/XrF8NPOc7dz97tJr2sAUAAA==
+    headers:
+      Cache-Control:
+      - private
+      Connection:
+      - Keep-Alive
+      Content-Encoding:
+      - gzip
+      Content-Length:
+      - '619'
+      Content-Type:
+      - application/json; charset=utf-8
+      Date:
+      - Tue, 10 Sep 2024 21:15:25 GMT
+      Set-Cookie: null
+      Vary:
+      - Accept-Encoding
+      X-Content-Type-Options:
+      - nosniff
+      X-Frame-Options:
+      - SAMEORIGIN
+      X-Permitted-Cross-Domain-Policies:
+      - none
+      X-XSS-Protection:
+      - 1; mode=block
+    status:
+      code: 200
+      message: OK
+version: 1

openbb_platform/providers/imf/tests/record/http/test_imf_fetchers/test_imf_economic_indicators_fetcher_urllib3_v2.yaml

@@ -0,0 +1,54 @@
+interactions:
+- request:
+    body: null
+    headers:
+      Accept:
+      - application/json
+      Accept-Encoding:
+      - gzip, deflate
+      Connection:
+      - keep-alive
+    method: GET
+    uri: http://dataservices.imf.org/REST/SDMX_JSON.svc/CompactData/IRFCL/M.JP.RAMFDA_USD.S1X?startPeriod=2023-01-01&endPeriod=2023-12-31
+  response:
+    body:
+      string: !!binary |
+        H4sIAAAAAAAEA6SSXY+aQBSG/4qhN226yDB+ULmS8pHSgFrAxtgLMg5HJREwDKs2Zv97z4w27W6y
+        zSa95J3nPe/54Kq5TXVkvPNYxzT7qk0v1aEW9kWUmq3tu+5oG8b5fO6fB/2m3RmUENNYxVHK91Ax
+        vaxFx2oO2sMfY/EGo+JFaQtVJmo468qmfm5MvXilMlsQzWPLQRhSiiPj5hLGiebEqEAItoOe7FVg
+        sy3sStG1P/uiqC7K/wxXJW6W/kUUyoauAscX0J5KjOmX1VYZ+W01RpgEbvR2UtZVA8pN/s9MWOQL
+        sAJaeZjQw1IFZeaWTLjOh9ZAH47ISN8UfKOTicVhY32a8BFFVwaiQ3rLDkKeZtHCkbVQoEQJHSKt
+        EyszB/aQ2qMx8inU95RpKSnTJajOWAUyWf4S9oHVO/RDjQ/vOrh0+BHGgfb0oLlN3TGOwlVbJiHq
+        8hS4U/nb3FeJpgwOcNw3NSDwsWf23mMrH3pjOtDHlBLtCQslwKE8gRp3WhYIrtdrmeDhdVLo1ArU
+        Mf4Sf3dYC+TvyQXy4p/XxIZSaEtA01WbBon/Dd0xqtPED3In8R38/rqQQjjzQtfJ5gkqiRMHnpMv
+        U0++SDT13dtTaq6ktpyFWR4vowzpsRSyMPbzYJ7EjpQWpgyZbzD3Bwarx4WfhHMPeUpwG8SUrvnn
+        NP/uREsfZd2aDHHgV3D6Eh8R63V68JL+1eecmwAMxEAU7cW5QfdRjEvZ3r2xhDTxY/ikMGupOpJn
+        rVUj08Kt8dhavHHymGOicZaceTaubiNHaHx7R6w8QOZzqvoli+d85+4HilPlVbAFAAA=
+    headers:
+      Cache-Control:
+      - private
+      Connection:
+      - Keep-Alive
+      Content-Encoding:
+      - gzip
+      Content-Length:
+      - '620'
+      Content-Type:
+      - application/json; charset=utf-8
+      Date:
+      - Sat, 07 Sep 2024 17:42:56 GMT
+      Set-Cookie: null
+      Vary:
+      - Accept-Encoding
+      X-Content-Type-Options:
+      - nosniff
+      X-Frame-Options:
+      - SAMEORIGIN
+      X-Permitted-Cross-Domain-Policies:
+      - none
+      X-XSS-Protection:
+      - 1; mode=block
+    status:
+      code: 200
+      message: OK
+version: 1

openbb_platform/providers/imf/tests/test_imf_fetchers.py

@@ -0,0 +1,78 @@
+"""IMF Fetcher Tests."""
+
+from datetime import date
+
+import pytest
+from openbb_core.app.service.user_service import UserService
+from openbb_imf.models.available_indicators import ImfAvailableIndicatorsFetcher
+from openbb_imf.models.direction_of_trade import ImfDirectionOfTradeFetcher
+from openbb_imf.models.economic_indicators import ImfEconomicIndicatorsFetcher
+
+test_credentials = UserService().default_user_settings.credentials.model_dump(
+    mode="json"
+)
+
+
+def scrub_string(key):
+    """Scrub a string from the response."""
+
+    def before_record_response(response):
+        response["headers"][key] = response["headers"].update({key: None})
+        return response
+
+    return before_record_response
+
+
+@pytest.fixture(scope="module")
+def vcr_config():
+    """VCR configuration."""
+    return {
+        "filter_headers": [("User-Agent", None)],
+        "before_record_response": [
+            scrub_string("Set-Cookie"),
+        ],
+    }
+
+
+@pytest.mark.record_http
+def test_imf_economic_indicators_fetcher(credentials=test_credentials):
+    """Test the IMF EconomicIndicators fetcher."""
+    params = {
+        "country": "JP",
+        "frequency": "month",
+        "symbol": "RAMFDA_USD",
+        "start_date": date(2023, 1, 1),
+        "end_date": date(2023, 12, 31),
+    }
+
+    fetcher = ImfEconomicIndicatorsFetcher()
+    result = fetcher.test(params, credentials)
+    assert result is None
+
+
+# The data for this request are local files, so we can't record them.
+def test_imf_available_indicators_fetcher(credentials=test_credentials):
+    """Test the IMF Available Indicators fetcher."""
+    params = {}
+
+    fetcher = ImfAvailableIndicatorsFetcher()
+    result = fetcher.test(params, credentials)
+    assert result is None
+
+
+@pytest.mark.record_http
+def test_imf_direction_of_trade_fetcher(credentials=test_credentials):
+    """Test the ImfDirectionOfTrade fetcher."""
+    params = {
+        "provider": "imf",
+        "country": "us",
+        "counterpart": "world,eu",
+        "frequency": "annual",
+        "direction": "exports",
+        "start_date": date(2020, 1, 1),
+        "end_date": date(2023, 1, 1),
+    }
+
+    fetcher = ImfDirectionOfTradeFetcher()
+    result = fetcher.test(params, credentials)
+    assert result is None

openbb_platform/providers/intrinio/README.md

@@ -0,0 +1,13 @@
+# OpenBB Intrinio Provider
+
+This extension integrates the [Intrinio](https://intrinio.com/) data provider into the OpenBB Platform.
+
+## Installation
+
+To install the extension:
+
+```bash
+pip install openbb-intrinio
+```
+
+Documentation available [here](https://docs.openbb.co/platform/developer_guide/contributing).

openbb_platform/providers/intrinio/__init__.py

@@ -0,0 +1 @@
+"""Intrinio provider."""

openbb_platform/providers/intrinio/openbb_intrinio/__init__.py

@@ -0,0 +1,116 @@
+"""Intrinio Provider Modules."""
+
+from openbb_core.provider.abstract.provider import Provider
+from openbb_intrinio.models.balance_sheet import IntrinioBalanceSheetFetcher
+from openbb_intrinio.models.calendar_ipo import IntrinioCalendarIpoFetcher
+from openbb_intrinio.models.cash_flow import IntrinioCashFlowStatementFetcher
+from openbb_intrinio.models.company_filings import IntrinioCompanyFilingsFetcher
+from openbb_intrinio.models.company_news import IntrinioCompanyNewsFetcher
+from openbb_intrinio.models.currency_pairs import IntrinioCurrencyPairsFetcher
+from openbb_intrinio.models.equity_historical import IntrinioEquityHistoricalFetcher
+from openbb_intrinio.models.equity_info import IntrinioEquityInfoFetcher
+from openbb_intrinio.models.equity_quote import IntrinioEquityQuoteFetcher
+from openbb_intrinio.models.equity_search import IntrinioEquitySearchFetcher
+from openbb_intrinio.models.etf_holdings import IntrinioEtfHoldingsFetcher
+from openbb_intrinio.models.etf_info import IntrinioEtfInfoFetcher
+from openbb_intrinio.models.etf_price_performance import (
+    IntrinioEtfPricePerformanceFetcher,
+)
+from openbb_intrinio.models.etf_search import IntrinioEtfSearchFetcher
+from openbb_intrinio.models.financial_ratios import IntrinioFinancialRatiosFetcher
+from openbb_intrinio.models.forward_ebitda_estimates import (
+    IntrinioForwardEbitdaEstimatesFetcher,
+)
+from openbb_intrinio.models.forward_eps_estimates import (
+    IntrinioForwardEpsEstimatesFetcher,
+)
+from openbb_intrinio.models.forward_pe_estimates import (
+    IntrinioForwardPeEstimatesFetcher,
+)
+from openbb_intrinio.models.forward_sales_estimates import (
+    IntrinioForwardSalesEstimatesFetcher,
+)
+from openbb_intrinio.models.fred_series import IntrinioFredSeriesFetcher
+from openbb_intrinio.models.historical_attributes import (
+    IntrinioHistoricalAttributesFetcher,
+)
+from openbb_intrinio.models.historical_dividends import (
+    IntrinioHistoricalDividendsFetcher,
+)
+from openbb_intrinio.models.historical_market_cap import (
+    IntrinioHistoricalMarketCapFetcher,
+)
+from openbb_intrinio.models.income_statement import IntrinioIncomeStatementFetcher
+from openbb_intrinio.models.index_historical import IntrinioIndexHistoricalFetcher
+from openbb_intrinio.models.insider_trading import IntrinioInsiderTradingFetcher
+
+# from openbb_intrinio.models.institutional_ownership import (
+#     IntrinioInstitutionalOwnershipFetcher,
+# )
+from openbb_intrinio.models.key_metrics import IntrinioKeyMetricsFetcher
+from openbb_intrinio.models.latest_attributes import IntrinioLatestAttributesFetcher
+from openbb_intrinio.models.market_snapshots import IntrinioMarketSnapshotsFetcher
+from openbb_intrinio.models.options_chains import IntrinioOptionsChainsFetcher
+from openbb_intrinio.models.options_snapshots import IntrinioOptionsSnapshotsFetcher
+from openbb_intrinio.models.options_unusual import IntrinioOptionsUnusualFetcher
+from openbb_intrinio.models.price_target_consensus import (
+    IntrinioPriceTargetConsensusFetcher,
+)
+from openbb_intrinio.models.reported_financials import IntrinioReportedFinancialsFetcher
+from openbb_intrinio.models.search_attributes import (
+    IntrinioSearchAttributesFetcher,
+)
+from openbb_intrinio.models.share_statistics import IntrinioShareStatisticsFetcher
+from openbb_intrinio.models.world_news import IntrinioWorldNewsFetcher
+
+intrinio_provider = Provider(
+    name="intrinio",
+    website="https://intrinio.com",
+    description="""Intrinio is a financial data platform that provides real-time and
+historical financial market data to businesses and developers through an API.""",
+    credentials=["api_key"],
+    fetcher_dict={
+        "BalanceSheet": IntrinioBalanceSheetFetcher,
+        "CalendarIpo": IntrinioCalendarIpoFetcher,
+        "CashFlowStatement": IntrinioCashFlowStatementFetcher,
+        "CompanyFilings": IntrinioCompanyFilingsFetcher,
+        "CompanyNews": IntrinioCompanyNewsFetcher,
+        "CurrencyPairs": IntrinioCurrencyPairsFetcher,
+        "EquityHistorical": IntrinioEquityHistoricalFetcher,
+        "EquityInfo": IntrinioEquityInfoFetcher,
+        "EquityQuote": IntrinioEquityQuoteFetcher,
+        "EquitySearch": IntrinioEquitySearchFetcher,
+        "EtfHistorical": IntrinioEquityHistoricalFetcher,
+        "EtfHoldings": IntrinioEtfHoldingsFetcher,
+        "EtfInfo": IntrinioEtfInfoFetcher,
+        "EtfPricePerformance": IntrinioEtfPricePerformanceFetcher,
+        "EtfSearch": IntrinioEtfSearchFetcher,
+        "FinancialRatios": IntrinioFinancialRatiosFetcher,
+        "ForwardEbitdaEstimates": IntrinioForwardEbitdaEstimatesFetcher,
+        "ForwardEpsEstimates": IntrinioForwardEpsEstimatesFetcher,
+        "ForwardPeEstimates": IntrinioForwardPeEstimatesFetcher,
+        "ForwardSalesEstimates": IntrinioForwardSalesEstimatesFetcher,
+        "FredSeries": IntrinioFredSeriesFetcher,
+        "HistoricalAttributes": IntrinioHistoricalAttributesFetcher,
+        "HistoricalDividends": IntrinioHistoricalDividendsFetcher,
+        "HistoricalMarketCap": IntrinioHistoricalMarketCapFetcher,
+        "IncomeStatement": IntrinioIncomeStatementFetcher,
+        "IndexHistorical": IntrinioIndexHistoricalFetcher,
+        "InsiderTrading": IntrinioInsiderTradingFetcher,
+        # "InstitutionalOwnership": IntrinioInstitutionalOwnershipFetcher, # Disabled due to unreliable Intrinio endpoint
+        "KeyMetrics": IntrinioKeyMetricsFetcher,
+        "LatestAttributes": IntrinioLatestAttributesFetcher,
+        "MarketSnapshots": IntrinioMarketSnapshotsFetcher,
+        "OptionsChains": IntrinioOptionsChainsFetcher,
+        "OptionsSnapshots": IntrinioOptionsSnapshotsFetcher,
+        "OptionsUnusual": IntrinioOptionsUnusualFetcher,
+        "PriceTargetConsensus": IntrinioPriceTargetConsensusFetcher,
+        "ReportedFinancials": IntrinioReportedFinancialsFetcher,
+        "SearchAttributes": IntrinioSearchAttributesFetcher,
+        "ShareStatistics": IntrinioShareStatisticsFetcher,
+        "WorldNews": IntrinioWorldNewsFetcher,
+    },
+    repr_name="Intrinio",
+    deprecated_credentials={"API_INTRINIO_KEY": "intrinio_api_key"},
+    instructions="Go to: https://intrinio.com/starter-plan\n\n![Intrinio](https://user-images.githubusercontent.com/85772166/219207556-fcfee614-59f1-46ae-bff4-c63dd2f6991d.png)\n\nAn API key will be issued with a subscription. Find the token value within the account dashboard.",  # noqa: E501  pylint: disable=line-too-long
+)

openbb_platform/providers/intrinio/openbb_intrinio/models/__init__.py

@@ -0,0 +1 @@
+"""Intrinio models directory."""

openbb_platform/providers/intrinio/openbb_intrinio/models/balance_sheet.py

@@ -0,0 +1,506 @@
+"""Intrinio Balance Sheet Model."""
+
+# pylint: disable=unused-argument
+
+from typing import Any, Dict, List, Literal, Optional
+from warnings import warn
+
+from openbb_core.provider.abstract.fetcher import Fetcher
+from openbb_core.provider.standard_models.balance_sheet import (
+    BalanceSheetData,
+    BalanceSheetQueryParams,
+)
+from openbb_core.provider.utils.descriptions import QUERY_DESCRIPTIONS
+from openbb_core.provider.utils.helpers import ClientResponse, amake_requests
+from openbb_intrinio.utils.helpers import get_data_one
+from pydantic import Field, field_validator, model_validator
+
+
+class IntrinioBalanceSheetQueryParams(BalanceSheetQueryParams):
+    """Intrinio Balance Sheet Query.
+
+    Source: https://docs.intrinio.com/documentation/web_api/get_company_fundamentals_v2
+    Source: https://docs.intrinio.com/documentation/web_api/get_fundamental_standardized_financials_v2
+    """
+
+    __json_schema_extra__ = {
+        "period": {
+            "choices": ["annual", "quarter"],
+        }
+    }
+
+    period: Literal["annual", "quarter"] = Field(
+        default="annual",
+        description=QUERY_DESCRIPTIONS.get("period", ""),
+    )
+    fiscal_year: Optional[int] = Field(
+        default=None,
+        description="The specific fiscal year.  Reports do not go beyond 2008.",
+    )
+
+    @field_validator("symbol", mode="after", check_fields=False)
+    @classmethod
+    def handle_symbol(cls, v) -> str:
+        """Handle symbols with a dash and replace it with a dot for Intrinio."""
+        return v.replace("-", ".")
+
+
+class IntrinioBalanceSheetData(BalanceSheetData):
+    """Intrinio Balance Sheet Data."""
+
+    __alias_dict__ = {
+        "cash_and_cash_equivalents": "cashandequivalents",
+        "restricted_cash": "restrictedcash",
+        "short_term_investments": "shortterminvestments",
+        "federal_funds_sold": "fedfundssold",
+        "note_and_lease_receivable": "notereceivable",
+        "interest_bearing_deposits_at_other_banks": "interestbearingdepositsatotherbanks",
+        "accounts_receivable": "accountsreceivable",
+        "time_deposits_placed_and_other_short_term_investments": "timedepositsplaced",
+        "inventories": "netinventory",
+        "trading_account_securities": "tradingaccountsecurities",
+        "prepaid_expenses": "prepaidexpenses",
+        "loans_and_leases": "loansandleases",
+        "allowance_for_loan_and_lease_losses": "allowanceforloanandleaselosses",
+        "current_deferred_refundable_income_taxes": "currentdeferredtaxassets",
+        "other_current_assets": "othercurrentassets",
+        "loans_and_leases_net_of_allowance": "netloansandleases",
+        "other_current_non_operating_assets": "othercurrentnonoperatingassets",
+        "loans_held_for_sale": "loansheldforsale",
+        "total_current_assets": "totalcurrentassets",
+        "accrued_investment_income": "accruedinvestmentincome",
+        "plant_property_equipment_gross": "grossppe",
+        "customer_and_other_receivables": "customerandotherreceivables",
+        "accumulated_depreciation": "accumulateddepreciation",
+        "premises_and_equipment_net": "netpremisesandequipment",
+        "plant_property_equipment_net": "netppe",
+        "mortgage_servicing_rights": "mortgageservicingrights",
+        "long_term_investments": "longterminvestments",
+        "unearned_premiums_asset": "unearnedpremiumsdebit",
+        "non_current_note_lease_receivables": "noncurrentnotereceivables",
+        "deferred_acquisition_cost": "deferredacquisitioncost",
+        "goodwill": "goodwill",
+        "separate_account_business_assets": "separateaccountbusinessassets",
+        "intangible_assets": "intangibleassets",
+        "non_current_deferred_refundable_income_taxes": "noncurrentdeferredtaxassets",
+        "employee_benefit_assets": "employeebenefitassets",
+        "other_assets": "otherassets",
+        "other_non_current_operating_assets": "othernoncurrentassets",
+        "total_assets": "totalassets",
+        "other_non_current_non_operating_assets": "othernoncurrentnonoperatingassets",
+        "non_interest_bearing_deposits": "noninterestbearingdeposits",
+        "interest_bearing_deposits": "interestbearingdeposits",
+        "total_non_current_assets": "totalnoncurrentassets",
+        "federal_funds_purchased_and_securities_sold": "fedfundspurchased",
+        "short_term_debt": "shorttermdebt",
+        "bankers_acceptance_out_standing": "bankersacceptances",
+        "accrued_interest_payable": "accruedinterestpayable",
+        "accounts_payable": "accountspayable",
+        "accrued_expenses": "accruedexpenses",
+        "other_short_term_payables": "othershorttermpayables",
+        "long_term_debt": "longtermdebt",
+        "customer_deposits": "customerdeposits",
+        "capital_lease_obligations": "capitalleaseobligations",
+        "dividends_payable": "dividendspayable",
+        "claims_and_claim_expense": "claimsandclaimexpenses",
+        "current_deferred_revenue": "currentdeferredrevenue",
+        "future_policy_benefits": "futurepolicybenefits",
+        "current_deferred_payable_income_tax_liabilities": "currentdeferredtaxliabilities",
+        "current_employee_benefit_liabilities": "currentemployeebenefitliabilities",
+        "unearned_premiums_liability": "unearnedpremiumscredit",
+        "other_taxes_payable": "othertaxespayable",
+        "policy_holder_funds": "policyholderfunds",
+        "other_current_liabilities": "othercurrentliabilities",
+        "participating_policy_holder_equity": "participatingpolicyholderequity",
+        "other_current_non_operating_liabilities": "othercurrentnonoperatingliabilities",
+        "separate_account_business_liabilities": "separateaccountbusinessliabilities",
+        "total_current_liabilities": "totalcurrentliabilities",
+        "other_long_term_liabilities": "otherlongtermliabilities",
+        "total_liabilities": "totalliabilities",
+        "commitments_contingencies": "commitmentsandcontingencies",
+        "asset_retirement_reserve_litigation_obligation": "assetretirementandlitigationobligation",
+        "redeemable_non_controlling_interest": "redeemablenoncontrollinginterest",
+        "non_current_deferred_revenue": "noncurrentdeferredrevenue",
+        "preferred_stock": "totalpreferredequity",
+        "common_stock": "commonequity",
+        "non_current_deferred_payable_income_tax_liabilities": "noncurrentdeferredtaxliabilities",
+        "non_current_employee_benefit_liabilities": "noncurrentemployeebenefitliabilities",
+        "retained_earnings": "retainedearnings",
+        "other_non_current_operating_liabilities": "othernoncurrentliabilities",
+        "treasury_stock": "treasurystock",
+        "accumulated_other_comprehensive_income": "aoci",
+        "other_non_current_non_operating_liabilities": "othernoncurrentnonoperatingliabilities",
+        "other_equity_adjustments": "otherequity",
+        "total_non_current_liabilities": "totalnoncurrentliabilities",
+        "total_common_equity": "totalcommonequity",
+        "total_preferred_common_equity": "totalequity",
+        "non_controlling_interest": "noncontrollinginterests",
+        "total_equity_non_controlling_interests": "totalequityandnoncontrollinginterests",
+        "total_liabilities_shareholders_equity": "totalliabilitiesandequity",
+    }
+    reported_currency: Optional[str] = Field(
+        description="The currency in which the balance sheet is reported.",
+        default=None,
+    )
+    cash_and_cash_equivalents: Optional[float] = Field(
+        description="Cash and cash equivalents.", default=None
+    )
+    cash_and_due_from_banks: Optional[float] = Field(
+        description="Cash and due from banks.", default=None
+    )
+    restricted_cash: Optional[float] = Field(
+        description="Restricted cash.", default=None
+    )
+    short_term_investments: Optional[float] = Field(
+        description="Short term investments.", default=None
+    )
+    federal_funds_sold: Optional[float] = Field(
+        description="Federal funds sold.", default=None
+    )
+    accounts_receivable: Optional[float] = Field(
+        description="Accounts receivable.", default=None
+    )
+    note_and_lease_receivable: Optional[float] = Field(
+        description="Note and lease receivable. (Vendor non-trade receivables)",
+        default=None,
+    )
+    inventories: Optional[float] = Field(description="Net Inventories.", default=None)
+    customer_and_other_receivables: Optional[float] = Field(
+        description="Customer and other receivables.", default=None
+    )
+    interest_bearing_deposits_at_other_banks: Optional[float] = Field(
+        description="Interest bearing deposits at other banks.", default=None
+    )
+    time_deposits_placed_and_other_short_term_investments: Optional[float] = Field(
+        description="Time deposits placed and other short term investments.",
+        default=None,
+    )
+    trading_account_securities: Optional[float] = Field(
+        description="Trading account securities.", default=None
+    )
+    loans_and_leases: Optional[float] = Field(
+        description="Loans and leases.", default=None
+    )
+    allowance_for_loan_and_lease_losses: Optional[float] = Field(
+        description="Allowance for loan and lease losses.", default=None
+    )
+    current_deferred_refundable_income_taxes: Optional[float] = Field(
+        description="Current deferred refundable income taxes.", default=None
+    )
+    other_current_assets: Optional[float] = Field(
+        description="Other current assets.", default=None
+    )
+    loans_and_leases_net_of_allowance: Optional[float] = Field(
+        description="Loans and leases net of allowance.", default=None
+    )
+    accrued_investment_income: Optional[float] = Field(
+        description="Accrued investment income.", default=None
+    )
+    other_current_non_operating_assets: Optional[float] = Field(
+        description="Other current non-operating assets.", default=None
+    )
+    loans_held_for_sale: Optional[float] = Field(
+        description="Loans held for sale.", default=None
+    )
+    prepaid_expenses: Optional[float] = Field(
+        description="Prepaid expenses.", default=None
+    )
+    total_current_assets: Optional[float] = Field(
+        description="Total current assets.", default=None
+    )
+    plant_property_equipment_gross: Optional[float] = Field(
+        description="Plant property equipment gross.", default=None
+    )
+    accumulated_depreciation: Optional[float] = Field(
+        description="Accumulated depreciation.", default=None
+    )
+    premises_and_equipment_net: Optional[float] = Field(
+        description="Net premises and equipment.", default=None
+    )
+    plant_property_equipment_net: Optional[float] = Field(
+        description="Net plant property equipment.", default=None
+    )
+    long_term_investments: Optional[float] = Field(
+        description="Long term investments.", default=None
+    )
+    mortgage_servicing_rights: Optional[float] = Field(
+        description="Mortgage servicing rights.", default=None
+    )
+    unearned_premiums_asset: Optional[float] = Field(
+        description="Unearned premiums asset.", default=None
+    )
+    non_current_note_lease_receivables: Optional[float] = Field(
+        description="Non-current note lease receivables.", default=None
+    )
+    deferred_acquisition_cost: Optional[float] = Field(
+        description="Deferred acquisition cost.", default=None
+    )
+    goodwill: Optional[float] = Field(description="Goodwill.", default=None)
+    separate_account_business_assets: Optional[float] = Field(
+        description="Separate account business assets.", default=None
+    )
+    non_current_deferred_refundable_income_taxes: Optional[float] = Field(
+        description="Noncurrent deferred refundable income taxes.", default=None
+    )
+    intangible_assets: Optional[float] = Field(
+        description="Intangible assets.", default=None
+    )
+    employee_benefit_assets: Optional[float] = Field(
+        description="Employee benefit assets.", default=None
+    )
+    other_assets: Optional[float] = Field(description="Other assets.", default=None)
+    other_non_current_operating_assets: Optional[float] = Field(
+        description="Other noncurrent operating assets.", default=None
+    )
+    other_non_current_non_operating_assets: Optional[float] = Field(
+        description="Other noncurrent non-operating assets.", default=None
+    )
+    interest_bearing_deposits: Optional[float] = Field(
+        description="Interest bearing deposits.", default=None
+    )
+    total_non_current_assets: Optional[float] = Field(
+        description="Total noncurrent assets.", default=None
+    )
+    total_assets: Optional[float] = Field(description="Total assets.", default=None)
+    non_interest_bearing_deposits: Optional[float] = Field(
+        description="Non interest bearing deposits.", default=None
+    )
+    federal_funds_purchased_and_securities_sold: Optional[float] = Field(
+        description="Federal funds purchased and securities sold.", default=None
+    )
+    bankers_acceptance_outstanding: Optional[float] = Field(
+        description="Bankers acceptance outstanding.", default=None
+    )
+    short_term_debt: Optional[float] = Field(
+        description="Short term debt.", default=None
+    )
+    accounts_payable: Optional[float] = Field(
+        description="Accounts payable.", default=None
+    )
+    current_deferred_revenue: Optional[float] = Field(
+        description="Current deferred revenue.", default=None
+    )
+    current_deferred_payable_income_tax_liabilities: Optional[float] = Field(
+        description="Current deferred payable income tax liabilities.", default=None
+    )
+    accrued_interest_payable: Optional[float] = Field(
+        description="Accrued interest payable.", default=None
+    )
+    accrued_expenses: Optional[float] = Field(
+        description="Accrued expenses.", default=None
+    )
+    other_short_term_payables: Optional[float] = Field(
+        description="Other short term payables.", default=None
+    )
+    customer_deposits: Optional[float] = Field(
+        description="Customer deposits.", default=None
+    )
+    dividends_payable: Optional[float] = Field(
+        description="Dividends payable.", default=None
+    )
+    claims_and_claim_expense: Optional[float] = Field(
+        description="Claims and claim expense.", default=None
+    )
+    future_policy_benefits: Optional[float] = Field(
+        description="Future policy benefits.", default=None
+    )
+    current_employee_benefit_liabilities: Optional[float] = Field(
+        description="Current employee benefit liabilities.", default=None
+    )
+    unearned_premiums_liability: Optional[float] = Field(
+        description="Unearned premiums liability.", default=None
+    )
+    other_taxes_payable: Optional[float] = Field(
+        description="Other taxes payable.", default=None
+    )
+    policy_holder_funds: Optional[float] = Field(
+        description="Policy holder funds.", default=None
+    )
+    other_current_liabilities: Optional[float] = Field(
+        description="Other current liabilities.", default=None
+    )
+    other_current_non_operating_liabilities: Optional[float] = Field(
+        description="Other current non-operating liabilities.", default=None
+    )
+    separate_account_business_liabilities: Optional[float] = Field(
+        description="Separate account business liabilities.", default=None
+    )
+    total_current_liabilities: Optional[float] = Field(
+        description="Total current liabilities.", default=None
+    )
+    long_term_debt: Optional[float] = Field(description="Long term debt.", default=None)
+    other_long_term_liabilities: Optional[float] = Field(
+        description="Other long term liabilities.", default=None
+    )
+    non_current_deferred_revenue: Optional[float] = Field(
+        description="Non-current deferred revenue.", default=None
+    )
+    non_current_deferred_payable_income_tax_liabilities: Optional[float] = Field(
+        description="Non-current deferred payable income tax liabilities.", default=None
+    )
+    non_current_employee_benefit_liabilities: Optional[float] = Field(
+        description="Non-current employee benefit liabilities.", default=None
+    )
+    other_non_current_operating_liabilities: Optional[float] = Field(
+        description="Other non-current operating liabilities.", default=None
+    )
+    other_non_current_non_operating_liabilities: Optional[float] = Field(
+        description="Other non-current, non-operating liabilities.", default=None
+    )
+    total_non_current_liabilities: Optional[float] = Field(
+        description="Total non-current liabilities.", default=None
+    )
+    capital_lease_obligations: Optional[float] = Field(
+        description="Capital lease obligations.", default=None
+    )
+    asset_retirement_reserve_litigation_obligation: Optional[float] = Field(
+        description="Asset retirement reserve litigation obligation.", default=None
+    )
+    total_liabilities: Optional[float] = Field(
+        description="Total liabilities.", default=None
+    )
+    commitments_contingencies: Optional[float] = Field(
+        description="Commitments contingencies.", default=None
+    )
+    redeemable_non_controlling_interest: Optional[float] = Field(
+        description="Redeemable non-controlling interest.", default=None
+    )
+    preferred_stock: Optional[float] = Field(
+        description="Preferred stock.", default=None
+    )
+    common_stock: Optional[float] = Field(description="Common stock.", default=None)
+    retained_earnings: Optional[float] = Field(
+        description="Retained earnings.", default=None
+    )
+    treasury_stock: Optional[float] = Field(description="Treasury stock.", default=None)
+    accumulated_other_comprehensive_income: Optional[float] = Field(
+        description="Accumulated other comprehensive income.", default=None
+    )
+    participating_policy_holder_equity: Optional[float] = Field(
+        description="Participating policy holder equity.", default=None
+    )
+    other_equity_adjustments: Optional[float] = Field(
+        description="Other equity adjustments.", default=None
+    )
+    total_common_equity: Optional[float] = Field(
+        description="Total common equity.", default=None
+    )
+    total_preferred_common_equity: Optional[float] = Field(
+        description="Total preferred common equity.", default=None
+    )
+    non_controlling_interest: Optional[float] = Field(
+        description="Non-controlling interest.", default=None
+    )
+    total_equity_non_controlling_interests: Optional[float] = Field(
+        description="Total equity non-controlling interests.", default=None
+    )
+    total_liabilities_shareholders_equity: Optional[float] = Field(
+        description="Total liabilities and shareholders equity.", default=None
+    )
+
+    @model_validator(mode="before")
+    @classmethod
+    def replace_zero(cls, values):  # pylint: disable=no-self-argument
+        """Check for zero values and replace with None."""
+        return (
+            {k: None if v == 0 else v for k, v in values.items()}
+            if isinstance(values, dict)
+            else values
+        )
+
+
+class IntrinioBalanceSheetFetcher(
+    Fetcher[
+        IntrinioBalanceSheetQueryParams,
+        List[IntrinioBalanceSheetData],
+    ]
+):
+    """Transform the query, extract and transform the data from the Intrinio endpoints."""
+
+    @staticmethod
+    def transform_query(params: Dict[str, Any]) -> IntrinioBalanceSheetQueryParams:
+        """Transform the query params."""
+        return IntrinioBalanceSheetQueryParams(**params)
+
+    @staticmethod
+    async def aextract_data(
+        query: IntrinioBalanceSheetQueryParams,
+        credentials: Optional[Dict[str, str]],
+        **kwargs: Any,
+    ) -> List[Dict]:
+        """Return the raw data from the Intrinio endpoint."""
+        api_key = credentials.get("intrinio_api_key") if credentials else ""
+        statement_code = "balance_sheet_statement"
+        fundamentals_data: Dict = {}
+        base_url = "https://api-v2.intrinio.com"
+        period = "FY" if query.period == "annual" else "QTR"
+        fundamentals_url = (
+            f"{base_url}/companies/{query.symbol}/fundamentals?"
+            f"statement_code={statement_code}&type={period}"
+        )
+        if query.fiscal_year is not None:
+            if query.fiscal_year < 2008:
+                warn("Financials data is only available from 2008 and later.")
+                query.fiscal_year = 2008
+            fundamentals_url = fundamentals_url + f"&fiscal_year={query.fiscal_year}"
+        fundamentals_url = fundamentals_url + f"&api_key={api_key}"
+        fundamentals_data = (await get_data_one(fundamentals_url, **kwargs)).get(
+            "fundamentals", []
+        )
+        fiscal_periods = [
+            f"{item['fiscal_year']}-{item['fiscal_period']}"
+            for item in fundamentals_data
+        ]
+        fiscal_periods = fiscal_periods[: query.limit]
+
+        async def callback(response: ClientResponse, _: Any) -> Dict:
+            """Return the response."""
+            statement_data = await response.json()  # type: ignore
+            return {
+                "period_ending": statement_data["fundamental"]["end_date"],  # type: ignore
+                "fiscal_year": statement_data["fundamental"]["fiscal_year"],  # type: ignore
+                "fiscal_period": statement_data["fundamental"]["fiscal_period"],  # type: ignore
+                "financials": statement_data["standardized_financials"],  # type: ignore
+            }
+
+        urls = [
+            f"{base_url}/fundamentals/{query.symbol}-{statement_code}-{p}/standardized_financials?api_key={api_key}"
+            for p in fiscal_periods
+        ]
+
+        return await amake_requests(urls, callback, **kwargs)  # type: ignore
+
+    @staticmethod
+    def transform_data(
+        query: IntrinioBalanceSheetQueryParams, data: List[Dict], **kwargs: Any
+    ) -> List[IntrinioBalanceSheetData]:
+        """Return the transformed data."""
+        transformed_data: List[IntrinioBalanceSheetData] = []
+        period = "FY" if query.period == "annual" else "QTR"
+        units = []
+        for item in data:
+            sub_dict: Dict[str, Any] = {}
+
+            for sub_item in item["financials"]:
+                field_name = sub_item["data_tag"]["tag"]
+                unit = sub_item["data_tag"].get("unit", "")
+                if unit and len(unit) == 3:
+                    units.append(unit)
+                sub_dict[field_name] = (
+                    float(sub_item["value"])
+                    if sub_item["value"] and sub_item["value"] != 0
+                    else None
+                )
+
+            sub_dict["period_ending"] = item["period_ending"]
+            sub_dict["fiscal_year"] = item["fiscal_year"]
+            sub_dict["fiscal_period"] = item["fiscal_period"]
+            sub_dict["reported_currency"] = list(set(units))[0]
+
+            # Intrinio does not return Q4 data but FY data instead
+            if period == "QTR" and item["fiscal_period"] == "FY":
+                sub_dict["fiscal_period"] = "Q4"
+
+            transformed_data.append(IntrinioBalanceSheetData(**sub_dict))
+
+        return transformed_data

openbb_platform/providers/intrinio/openbb_intrinio/models/calendar_ipo.py

@@ -0,0 +1,193 @@
+"""Intrinio IPO Calendar Model."""
+
+# pylint: disable=unused-argument
+
+from typing import Any, Dict, List, Literal, Optional
+
+from openbb_core.provider.abstract.fetcher import Fetcher
+from openbb_core.provider.standard_models.calendar_ipo import (
+    CalendarIpoData,
+    CalendarIpoQueryParams,
+)
+from openbb_core.provider.utils.errors import EmptyDataError
+from openbb_core.provider.utils.helpers import get_querystring
+from openbb_intrinio.utils.helpers import get_data_one
+from openbb_intrinio.utils.references import IntrinioCompany, IntrinioSecurity
+from pydantic import Field
+
+
+class IntrinioCalendarIpoQueryParams(CalendarIpoQueryParams):
+    """Intrinio IPO Calendar Query.
+
+    Source: https://docs.intrinio.com/documentation/web_api/get_company_ipos_v2
+    """
+
+    __alias_dict__ = {
+        "symbol": "ticker",
+        "limit": "page_size",
+        "min_value": "offer_amount_greater_than",
+        "max_value": "offer_amount_less_than",
+    }
+
+    status: Optional[Literal["upcoming", "priced", "withdrawn"]] = Field(
+        description="Status of the IPO. [upcoming, priced, or withdrawn]", default=None
+    )
+    min_value: Optional[int] = Field(
+        description="Return IPOs with an offer dollar amount greater than the given amount.",
+        default=None,
+    )
+    max_value: Optional[int] = Field(
+        description="Return IPOs with an offer dollar amount less than the given amount.",
+        default=None,
+    )
+
+
+class IntrinioCalendarIpoData(CalendarIpoData):
+    """Intrinio IPO Calendar Data."""
+
+    __alias_dict__ = {"symbol": "ticker", "ipo_date": "date"}
+
+    status: Optional[Literal["upcoming", "priced", "withdrawn"]] = Field(
+        description=(
+            "The status of the IPO. Upcoming IPOs have not taken place yet but are expected to. "
+            "Priced IPOs have taken place. Withdrawn IPOs were expected to take place, but were subsequently withdrawn."
+        ),
+        default=None,
+    )
+    exchange: Optional[str] = Field(
+        description=(
+            "The acronym of the stock exchange that the company is going to trade publicly on. "
+            "Typically NYSE or NASDAQ."
+        ),
+        default=None,
+    )
+    offer_amount: Optional[float] = Field(
+        description="The total dollar amount of shares offered in the IPO. Typically this is share price * share count",
+        default=None,
+    )
+    share_price: Optional[float] = Field(
+        description="The price per share at which the IPO was offered.", default=None
+    )
+    share_price_lowest: Optional[float] = Field(
+        description=(
+            "The expected lowest price per share at which the IPO will be offered. "
+            "Before an IPO is priced, companies typically provide a range of prices per share at which "
+            "they expect to offer the IPO (typically available for upcoming IPOs)."
+        ),
+        default=None,
+    )
+    share_price_highest: Optional[float] = Field(
+        description=(
+            "The expected highest price per share at which the IPO will be offered. "
+            "Before an IPO is priced, companies typically provide a range of prices per share at which "
+            "they expect to offer the IPO (typically available for upcoming IPOs)."
+        ),
+        default=None,
+    )
+    share_count: Optional[int] = Field(
+        description="The number of shares offered in the IPO.", default=None
+    )
+    share_count_lowest: Optional[int] = Field(
+        description=(
+            "The expected lowest number of shares that will be offered in the IPO. Before an IPO is priced, "
+            "companies typically provide a range of shares that they expect to offer in the IPO "
+            "(typically available for upcoming IPOs)."
+        ),
+        default=None,
+    )
+    share_count_highest: Optional[int] = Field(
+        description=(
+            "The expected highest number of shares that will be offered in the IPO. Before an IPO is priced, "
+            "companies typically provide a range of shares that they expect to offer in the IPO "
+            "(typically available for upcoming IPOs)."
+        ),
+        default=None,
+    )
+    announcement_url: Optional[str] = Field(
+        description="The URL to the company's announcement of the IPO", default=None
+    )
+    sec_report_url: Optional[str] = Field(
+        description=(
+            "The URL to the company's S-1, S-1/A, F-1, or F-1/A SEC filing, which is required to be filed "
+            "before an IPO takes place."
+        ),
+        default=None,
+    )
+    open_price: Optional[float] = Field(
+        description="The opening price at the beginning of the first trading day (only available for priced IPOs).",
+        default=None,
+    )
+    close_price: Optional[float] = Field(
+        description="The closing price at the end of the first trading day (only available for priced IPOs).",
+        default=None,
+    )
+    volume: Optional[int] = Field(
+        description="The volume at the end of the first trading day (only available for priced IPOs).",
+        default=None,
+    )
+    day_change: Optional[float] = Field(
+        description=(
+            "The percentage change between the open price and the close price on the first trading day "
+            "(only available for priced IPOs)."
+        ),
+        default=None,
+    )
+    week_change: Optional[float] = Field(
+        description=(
+            "The percentage change between the open price on the first trading day and the close price approximately "
+            "a week after the first trading day (only available for priced IPOs)."
+        ),
+        default=None,
+    )
+    month_change: Optional[float] = Field(
+        description=(
+            "The percentage change between the open price on the first trading day and the close price approximately "
+            "a month after the first trading day (only available for priced IPOs)."
+        ),
+        default=None,
+    )
+    id: Optional[str] = Field(description="The Intrinio ID of the IPO.", default=None)
+    company: Optional[IntrinioCompany] = Field(
+        description="The company that is going public via the IPO.", default=None
+    )
+    security: Optional[IntrinioSecurity] = Field(
+        description="The primary Security for the Company that is going public via the IPO",
+        default=None,
+    )
+
+
+class IntrinioCalendarIpoFetcher(
+    Fetcher[IntrinioCalendarIpoQueryParams, List[IntrinioCalendarIpoData]]
+):
+    """Transform the query, extract and transform the data from the Intrinio endpoints."""
+
+    @staticmethod
+    def transform_query(params: Dict[str, Any]) -> IntrinioCalendarIpoQueryParams:
+        """Transform the query params."""
+        return IntrinioCalendarIpoQueryParams(**params)
+
+    @staticmethod
+    async def aextract_data(
+        query: IntrinioCalendarIpoQueryParams,
+        credentials: Optional[Dict[str, str]],
+        **kwargs: Any,
+    ) -> List[Dict]:
+        """Return the raw data from the Intrinio endpoint."""
+        api_key = credentials.get("intrinio_api_key") if credentials else ""
+
+        base_url = "https://api-v2.intrinio.com/companies/ipos"
+        query_str = get_querystring(query.model_dump(by_alias=True), [])
+        url = f"{base_url}?{query_str}&api_key={api_key}"
+
+        data = await get_data_one(url, **kwargs)
+
+        return data.get("initial_public_offerings", [])
+
+    @staticmethod
+    def transform_data(
+        query: IntrinioCalendarIpoQueryParams, data: List[Dict], **kwargs: Any
+    ) -> List[IntrinioCalendarIpoData]:
+        """Return the transformed data."""
+        if not data:
+            raise EmptyDataError("The request was returned empty.")
+        return [IntrinioCalendarIpoData.model_validate(d) for d in data]

openbb_platform/providers/intrinio/openbb_intrinio/models/cash_flow.py

@@ -0,0 +1,338 @@
+"""Intrinio Cash Flow Statement Model."""
+
+# pylint: disable=unused-argument
+
+from typing import Any, Dict, List, Literal, Optional
+from warnings import warn
+
+from openbb_core.app.model.abstract.error import OpenBBError
+from openbb_core.provider.abstract.fetcher import Fetcher
+from openbb_core.provider.standard_models.cash_flow import (
+    CashFlowStatementData,
+    CashFlowStatementQueryParams,
+)
+from openbb_core.provider.utils.descriptions import QUERY_DESCRIPTIONS
+from openbb_core.provider.utils.helpers import ClientResponse, amake_requests
+from openbb_intrinio.utils.helpers import get_data_one
+from pydantic import Field, field_validator, model_validator
+
+
+class IntrinioCashFlowStatementQueryParams(CashFlowStatementQueryParams):
+    """Intrinio Cash Flow Statement Query.
+
+    Source: https://docs.intrinio.com/documentation/web_api/get_company_fundamentals_v2
+    Source: https://docs.intrinio.com/documentation/web_api/get_fundamental_standardized_financials_v2
+    """
+
+    __json_schema_extra__ = {
+        "period": {
+            "choices": ["annual", "quarter", "ttm", "ytd"],
+        }
+    }
+
+    period: Literal["annual", "quarter", "ttm", "ytd"] = Field(
+        default="annual",
+        description=QUERY_DESCRIPTIONS.get("period", ""),
+    )
+    fiscal_year: Optional[int] = Field(
+        default=None,
+        description="The specific fiscal year.  Reports do not go beyond 2008.",
+    )
+
+    @field_validator("symbol", mode="after", check_fields=False)
+    @classmethod
+    def handle_symbol(cls, v) -> str:
+        """Handle symbols with a dash and replace it with a dot for Intrinio."""
+        return v.replace("-", ".")
+
+
+class IntrinioCashFlowStatementData(CashFlowStatementData):
+    """Intrinio Cash Flow Statement Data."""
+
+    __alias_dict__ = {
+        "cash_and_equivalents": "cashandequivalents",
+        "acquisitions": "acquisitions",
+        "amortization_expense": "amortizationexpense",
+        "cash_income_taxes_paid": "cashincometaxespaid",
+        "cash_interest_paid": "cashinterestpaid",
+        "cash_interest_received": "cashinterestreceived",
+        "depreciation_expense": "depreciationexpense",
+        "divestitures": "divestitures",
+        "effect_of_exchange_rate_changes": "effectofexchangeratechanges",
+        "changes_in_operating_assets_and_liabilities": "increasedecreaseinoperatingcapital",
+        "issuance_of_common_equity": "issuanceofcommonequity",
+        "issuance_of_debt": "issuanceofdebt",
+        "issuance_of_preferred_equity": "issuanceofpreferredequity",
+        "loans_held_for_sale": "loansheldforsalenet",
+        "net_cash_from_continuing_financing_activities": "netcashfromcontinuingfinancingactivities",
+        "net_cash_from_continuing_investing_activities": "netcashfromcontinuinginvestingactivities",
+        "net_cash_from_continuing_operating_activities": "netcashfromcontinuingoperatingactivities",
+        "net_cash_from_discontinued_financing_activities": "netcashfromdiscontinuedfinancingactivities",
+        "net_cash_from_discontinued_investing_activities": "netcashfromdiscontinuedinvestingactivities",
+        "net_cash_from_discontinued_operating_activities": "netcashfromdiscontinuedoperatingactivities",
+        "net_cash_from_financing_activities": "netcashfromfinancingactivities",
+        "net_cash_from_investing_activities": "netcashfrominvestingactivities",
+        "net_cash_from_operating_activities": "netcashfromoperatingactivities",
+        "net_change_in_cash_and_equivalents": "netchangeincash",
+        "net_change_in_deposits": "netchangeindeposits",
+        "net_income": "netincome",
+        "net_income_continuing_operations": "netincomecontinuing",
+        "net_income_discontinued_operations": "netincomediscontinued",
+        "net_increase_in_fed_funds_sold": "netincreaseinfedfundssold",
+        "non_cash_adjustments_to_reconcile_net_income": "noncashadjustmentstonetincome",
+        "other_financing_activities": "otherfinancingactivitiesnet",
+        "other_investing_activities": "otherinvestingactivitiesnet",
+        "other_net_changes_in_cash": "othernetchangesincash",
+        "payment_of_dividends": "paymentofdividends",
+        "provision_for_loan_losses": "provisionforloanlosses",
+        "purchase_of_investments": "purchaseofinvestments",
+        "purchase_of_investment_securities": "purchaseofinvestments",
+        "purchase_of_property_plant_and_equipment": "purchaseofplantpropertyandequipment",
+        "repayment_of_debt": "repaymentofdebt",
+        "repurchase_of_common_equity": "repurchaseofcommonequity",
+        "repurchase_of_preferred_equity": "repurchaseofpreferredequity",
+        "sale_and_maturity_of_investments": "saleofinvestments",
+        "sale_of_property_plant_and_equipment": "saleofplantpropertyandequipment",
+    }
+
+    reported_currency: Optional[str] = Field(
+        description="The currency in which the balance sheet is reported.",
+        default=None,
+    )
+    net_income_continuing_operations: Optional[float] = Field(
+        default=None, description="Net Income (Continuing Operations)"
+    )
+    net_income_discontinued_operations: Optional[float] = Field(
+        default=None, description="Net Income (Discontinued Operations)"
+    )
+    net_income: Optional[float] = Field(
+        default=None, description="Consolidated Net Income."
+    )
+    provision_for_loan_losses: Optional[float] = Field(
+        default=None, description="Provision for Loan Losses"
+    )
+    provision_for_credit_losses: Optional[float] = Field(
+        default=None, description="Provision for credit losses"
+    )
+    depreciation_expense: Optional[float] = Field(
+        default=None, description="Depreciation Expense."
+    )
+    amortization_expense: Optional[float] = Field(
+        default=None, description="Amortization Expense."
+    )
+    share_based_compensation: Optional[float] = Field(
+        default=None, description="Share-based compensation."
+    )
+    non_cash_adjustments_to_reconcile_net_income: Optional[float] = Field(
+        default=None, description="Non-Cash Adjustments to Reconcile Net Income."
+    )
+    changes_in_operating_assets_and_liabilities: Optional[float] = Field(
+        default=None, description="Changes in Operating Assets and Liabilities (Net)"
+    )
+    net_cash_from_continuing_operating_activities: Optional[float] = Field(
+        default=None, description="Net Cash from Continuing Operating Activities"
+    )
+    net_cash_from_discontinued_operating_activities: Optional[float] = Field(
+        default=None, description="Net Cash from Discontinued Operating Activities"
+    )
+    net_cash_from_operating_activities: Optional[float] = Field(
+        default=None, description="Net Cash from Operating Activities"
+    )
+    divestitures: Optional[float] = Field(default=None, description="Divestitures")
+    sale_of_property_plant_and_equipment: Optional[float] = Field(
+        default=None, description="Sale of Property, Plant, and Equipment"
+    )
+    acquisitions: Optional[float] = Field(default=None, description="Acquisitions")
+    purchase_of_investments: Optional[float] = Field(
+        default=None, description="Purchase of Investments"
+    )
+    purchase_of_investment_securities: Optional[float] = Field(
+        default=None, description="Purchase of Investment Securities"
+    )
+    sale_and_maturity_of_investments: Optional[float] = Field(
+        default=None, description="Sale and Maturity of Investments"
+    )
+    loans_held_for_sale: Optional[float] = Field(
+        default=None, description="Loans Held for Sale (Net)"
+    )
+    purchase_of_property_plant_and_equipment: Optional[float] = Field(
+        default=None, description="Purchase of Property, Plant, and Equipment"
+    )
+    other_investing_activities: Optional[float] = Field(
+        default=None, description="Other Investing Activities (Net)"
+    )
+    net_cash_from_continuing_investing_activities: Optional[float] = Field(
+        default=None, description="Net Cash from Continuing Investing Activities"
+    )
+    net_cash_from_discontinued_investing_activities: Optional[float] = Field(
+        default=None, description="Net Cash from Discontinued Investing Activities"
+    )
+    net_cash_from_investing_activities: Optional[float] = Field(
+        default=None, description="Net Cash from Investing Activities"
+    )
+    payment_of_dividends: Optional[float] = Field(
+        default=None, description="Payment of Dividends"
+    )
+    repurchase_of_common_equity: Optional[float] = Field(
+        default=None, description="Repurchase of Common Equity"
+    )
+    repurchase_of_preferred_equity: Optional[float] = Field(
+        default=None, description="Repurchase of Preferred Equity"
+    )
+    issuance_of_common_equity: Optional[float] = Field(
+        default=None, description="Issuance of Common Equity"
+    )
+    issuance_of_preferred_equity: Optional[float] = Field(
+        default=None, description="Issuance of Preferred Equity"
+    )
+    issuance_of_debt: Optional[float] = Field(
+        default=None, description="Issuance of Debt"
+    )
+    repayment_of_debt: Optional[float] = Field(
+        default=None, description="Repayment of Debt"
+    )
+    other_financing_activities: Optional[float] = Field(
+        default=None, description="Other Financing Activities (Net)"
+    )
+    cash_interest_received: Optional[float] = Field(
+        default=None, description="Cash Interest Received"
+    )
+    net_change_in_deposits: Optional[float] = Field(
+        default=None, description="Net Change in Deposits"
+    )
+    net_increase_in_fed_funds_sold: Optional[float] = Field(
+        default=None, description="Net Increase in Fed Funds Sold"
+    )
+    net_cash_from_continuing_financing_activities: Optional[float] = Field(
+        default=None, description="Net Cash from Continuing Financing Activities"
+    )
+    net_cash_from_discontinued_financing_activities: Optional[float] = Field(
+        default=None, description="Net Cash from Discontinued Financing Activities"
+    )
+    net_cash_from_financing_activities: Optional[float] = Field(
+        default=None, description="Net Cash from Financing Activities"
+    )
+    effect_of_exchange_rate_changes: Optional[float] = Field(
+        default=None, description="Effect of Exchange Rate Changes"
+    )
+    other_net_changes_in_cash: Optional[float] = Field(
+        default=None, description="Other Net Changes in Cash"
+    )
+    net_change_in_cash_and_equivalents: Optional[float] = Field(
+        default=None, description="Net Change in Cash and Equivalents"
+    )
+    cash_income_taxes_paid: Optional[float] = Field(
+        default=None, description="Cash Income Taxes Paid"
+    )
+    cash_interest_paid: Optional[float] = Field(
+        default=None, description="Cash Interest Paid"
+    )
+
+    @model_validator(mode="before")
+    @classmethod
+    def replace_zero(cls, values):
+        """Check for zero values and replace with None."""
+        return (
+            {k: None if v == 0 else v for k, v in values.items()}
+            if isinstance(values, dict)
+            else values
+        )
+
+
+class IntrinioCashFlowStatementFetcher(
+    Fetcher[
+        IntrinioCashFlowStatementQueryParams,
+        List[IntrinioCashFlowStatementData],
+    ]
+):
+    """Transform the query, extract and transform the data from the Intrinio endpoints."""
+
+    @staticmethod
+    def transform_query(params: Dict[str, Any]) -> IntrinioCashFlowStatementQueryParams:
+        """Transform the query params."""
+        return IntrinioCashFlowStatementQueryParams(**params)
+
+    @staticmethod
+    async def aextract_data(
+        query: IntrinioCashFlowStatementQueryParams,
+        credentials: Optional[Dict[str, str]],
+        **kwargs: Any,
+    ) -> List[Dict]:
+        """Return the raw data from the Intrinio endpoint."""
+        api_key = credentials.get("intrinio_api_key") if credentials else ""
+        statement_code = "cash_flow_statement"
+        if query.period in ["quarter", "annual"]:
+            period_type = "FY" if query.period == "annual" else "QTR"
+        elif query.period in ["ttm", "ytd"]:
+            period_type = query.period.upper()
+        else:
+            raise OpenBBError(f"Period '{query.period}' not supported.")
+
+        base_url = "https://api-v2.intrinio.com"
+        fundamentals_url = (
+            f"{base_url}/companies/{query.symbol}/fundamentals?"
+            f"statement_code={statement_code}&type={period_type}"
+        )
+        if query.fiscal_year is not None:
+            if query.fiscal_year < 2008:
+                warn("Financials data is only available from 2008 and later.")
+                query.fiscal_year = 2008
+            fundamentals_url = fundamentals_url + f"&fiscal_year={query.fiscal_year}"
+        fundamentals_url = fundamentals_url + f"&api_key={api_key}"
+        fundamentals_data = (await get_data_one(fundamentals_url, **kwargs)).get(
+            "fundamentals", []
+        )
+
+        fiscal_periods = [
+            f"{item['fiscal_year']}-{item['fiscal_period']}"
+            for item in fundamentals_data
+        ]
+        fiscal_periods = fiscal_periods[: query.limit]
+
+        async def callback(response: ClientResponse, _: Any) -> Dict:
+            """Return the response."""
+            statement_data = await response.json()
+            return {
+                "period_ending": statement_data["fundamental"]["end_date"],  # type: ignore
+                "fiscal_period": statement_data["fundamental"]["fiscal_period"],  # type: ignore
+                "fiscal_year": statement_data["fundamental"]["fiscal_year"],  # type: ignore
+                "financials": statement_data["standardized_financials"],  # type: ignore
+            }
+
+        intrinio_id = f"{query.symbol}-{statement_code}"
+        urls = [
+            f"{base_url}/fundamentals/{intrinio_id}-{period}/standardized_financials?api_key={api_key}"
+            for period in fiscal_periods
+        ]
+
+        return await amake_requests(urls, callback, **kwargs)
+
+    @staticmethod
+    def transform_data(
+        query: IntrinioCashFlowStatementQueryParams, data: List[Dict], **kwargs: Any
+    ) -> List[IntrinioCashFlowStatementData]:
+        """Return the transformed data."""
+        transformed_data: List[IntrinioCashFlowStatementData] = []
+        units = []
+        for item in data:
+            sub_dict: Dict[str, Any] = {}
+
+            for sub_item in item["financials"]:
+                unit = sub_item["data_tag"].get("unit", "")
+                if unit and len(unit) == 3:
+                    units.append(unit)
+                field_name = sub_item["data_tag"]["tag"]
+                sub_dict[field_name] = (
+                    float(sub_item["value"])
+                    if sub_item["value"] and sub_item["value"] != 0
+                    else None
+                )
+
+            sub_dict["period_ending"] = item["period_ending"]
+            sub_dict["fiscal_year"] = item["fiscal_year"]
+            sub_dict["fiscal_period"] = item["fiscal_period"]
+            sub_dict["reported_currency"] = list(set(units))[0]
+
+            transformed_data.append(IntrinioCashFlowStatementData(**sub_dict))
+
+        return transformed_data

openbb_platform/providers/intrinio/openbb_intrinio/models/company_filings.py

@@ -0,0 +1,175 @@
+"""Intrinio Company Filings Model."""
+
+# pylint: disable=unused-argument
+
+from datetime import (
+    date as dateType,
+    datetime,
+)
+from typing import Any, Optional
+
+from dateutil.relativedelta import relativedelta
+from openbb_core.provider.abstract.annotated_result import AnnotatedResult
+from openbb_core.provider.abstract.fetcher import Fetcher
+from openbb_core.provider.standard_models.company_filings import (
+    CompanyFilingsData,
+    CompanyFilingsQueryParams,
+)
+from openbb_core.provider.utils.descriptions import QUERY_DESCRIPTIONS
+from pydantic import Field, field_validator
+
+
+class IntrinioCompanyFilingsQueryParams(CompanyFilingsQueryParams):
+    """Intrinio Company Filings Query.
+
+    Source: https://docs.intrinio.com/documentation/web_api/get_company_filings_v2
+    """
+
+    __alias_dict__ = {"form_type": "report_type", "limit": "page_size"}
+
+    form_type: Optional[str] = Field(
+        default=None, description="SEC form type to filter by."
+    )
+    start_date: Optional[dateType] = Field(
+        default=None,
+        description=QUERY_DESCRIPTIONS["start_date"],
+    )
+    end_date: Optional[dateType] = Field(
+        default=None,
+        description=QUERY_DESCRIPTIONS["end_date"],
+    )
+    limit: Optional[int] = Field(
+        default=None,
+        description=QUERY_DESCRIPTIONS["limit"],
+    )
+    thea_enabled: Optional[bool] = Field(
+        default=None,
+        description="Return filings that have been read by Intrinio's Thea NLP.",
+    )
+
+    @field_validator("symbol", mode="before", check_fields=False)
+    @classmethod
+    def _validate_symbol(cls, v):
+        """Validate symbol."""
+        if not v:
+            raise ValueError("Symbol is required for Intrinio.")
+        return v
+
+
+class IntrinioCompanyFilingsData(CompanyFilingsData):
+    """Intrinio Company Filings Data."""
+
+    id: str = Field(description="Intrinio ID of the filing.")
+    period_end_date: Optional[dateType] = Field(
+        default=None,
+        description="Ending date of the fiscal period for the filing.",
+    )
+    accepted_date: Optional[datetime] = Field(
+        default=None, description="Accepted date of the filing."
+    )
+    sec_unique_id: str = Field(description="SEC unique ID of the filing.")
+    filing_url: Optional[str] = Field(
+        default=None, description="URL to the filing page."
+    )
+    instance_url: Optional[str] = Field(
+        default=None,
+        description="URL for the XBRL filing for the report.",
+    )
+    industry_group: str = Field(description="Industry group of the company.")
+    industry_category: str = Field(description="Industry category of the company.")
+    word_count: Optional[int] = Field(
+        default=None, description="Number of words in the filing, if available."
+    )
+
+
+class IntrinioCompanyFilingsFetcher(
+    Fetcher[
+        IntrinioCompanyFilingsQueryParams,
+        list[IntrinioCompanyFilingsData],
+    ]
+):
+    """Transform the query, extract and transform the data from the Intrinio endpoints."""
+
+    @staticmethod
+    def transform_query(params: dict[str, Any]) -> IntrinioCompanyFilingsQueryParams:
+        """Transform the query."""
+        transformed_params = params
+
+        now = datetime.now().date()
+        if params.get("start_date") is None and params.get("form_type") is None:
+            transformed_params["start_date"] = now - relativedelta(years=1)
+        if params.get("end_date") is None and params.get("form_type") is None:
+            transformed_params["end_date"] = now
+
+        return IntrinioCompanyFilingsQueryParams(**transformed_params)
+
+    @staticmethod
+    async def aextract_data(
+        query: IntrinioCompanyFilingsQueryParams,
+        credentials: Optional[dict[str, str]],
+        **kwargs: Any,
+    ) -> dict:
+        """Return the raw data from the Intrinio endpoint."""
+        # pylint: disable=import-outside-toplevel
+        from openbb_core.provider.utils.errors import EmptyDataError, OpenBBError
+        from openbb_core.provider.utils.helpers import (
+            get_async_requests_session,
+            get_querystring,
+        )
+
+        api_key = credentials.get("intrinio_api_key") if credentials else ""
+
+        base_url = "https://api-v2.intrinio.com/companies"
+        query_str = get_querystring(
+            query.model_dump(by_alias=True), ["symbol", "limit", "page_size"]
+        )
+        url = f"{base_url}/{query.symbol}/filings?{query_str}&page_size={query.limit or 10000}&api_key={api_key}"
+        results: list = []
+        metadata: dict = {}
+        session = await get_async_requests_session()
+
+        async with await session.get(url) as response:
+            if response.status != 200:
+                raise OpenBBError(
+                    f"Error fetching data from Intrinio: {response.status} -> {response.text}"
+                )
+            result = await response.json()
+            if filings := result.get("filings", []):
+                results.extend(filings)
+
+            metadata = result.get("company", {})
+
+            while next_page := result.get("next_page"):
+                url += f"&next_page={next_page}"
+                async with await session.get(url) as next_response:
+                    if response.status != 200:
+                        raise OpenBBError(
+                            f"Error fetching data from Intrinio: {response.status} -> {response.text}"
+                        )
+                    result = await next_response.json()
+                    if filings := result.get("filings", []):
+                        results.extend(filings)
+
+        if not results:
+            raise EmptyDataError("No data was returned for the symbol provided.")
+
+        return {"data": results, "metadata": metadata}
+
+    @staticmethod
+    def transform_data(
+        query: IntrinioCompanyFilingsQueryParams, data: dict, **kwargs: Any
+    ) -> AnnotatedResult[list[IntrinioCompanyFilingsData]]:
+        """Return the transformed data."""
+        return AnnotatedResult(
+            result=[
+                IntrinioCompanyFilingsData.model_validate(
+                    {
+                        k: v
+                        for k, v in d.items()
+                        if k not in ["thea_enabled", "earnings_release"]
+                    }
+                )
+                for d in data.get("data", [])
+            ],
+            metadata=data.get("metadata", {}),
+        )

openbb_platform/providers/intrinio/openbb_intrinio/models/company_news.py

@@ -0,0 +1,295 @@
+"""Intrinio Company News Model."""
+
+import asyncio
+from datetime import datetime, timedelta
+from typing import Any, Dict, List, Literal, Optional
+from warnings import warn
+
+from openbb_core.app.model.abstract.error import OpenBBError
+from openbb_core.provider.abstract.fetcher import Fetcher
+from openbb_core.provider.standard_models.company_news import (
+    CompanyNewsData,
+    CompanyNewsQueryParams,
+)
+from openbb_core.provider.utils.errors import EmptyDataError, UnauthorizedError
+from openbb_core.provider.utils.helpers import (
+    amake_request,
+    get_querystring,
+)
+from openbb_intrinio.utils.helpers import get_data
+from openbb_intrinio.utils.references import IntrinioSecurity
+from pydantic import Field, field_validator
+
+
+class IntrinioCompanyNewsQueryParams(CompanyNewsQueryParams):
+    """Intrinio Company News Query.
+
+    Source: https://docs.intrinio.com/documentation/web_api/get_company_news_v2
+    """
+
+    __alias_dict__ = {
+        "limit": "page_size",
+        "source": "specific_source",
+    }
+    __json_schema_extra__ = {
+        "symbol": {"multiple_items_allowed": True},
+        "source": {
+            "choices": ["yahoo", "moody", "moody_us_news", "moody_us_press_releases"]
+        },
+        "sentiment": {"choices": ["positive", "neutral", "negative"]},
+    }
+
+    source: Optional[
+        Literal["yahoo", "moody", "moody_us_news", "moody_us_press_releases"]
+    ] = Field(
+        default=None,
+        description="The source of the news article.",
+    )
+    sentiment: Optional[Literal["positive", "neutral", "negative"]] = Field(
+        default=None,
+        description="Return news only from this source.",
+    )
+    language: Optional[str] = Field(
+        default=None,
+        description="Filter by language. Unsupported for yahoo source.",
+    )
+    topic: Optional[str] = Field(
+        default=None,
+        description="Filter by topic. Unsupported for yahoo source.",
+    )
+    word_count_greater_than: Optional[int] = Field(
+        default=None,
+        description="News stories will have a word count greater than this value."
+        + " Unsupported for yahoo source.",
+    )
+    word_count_less_than: Optional[int] = Field(
+        default=None,
+        description="News stories will have a word count less than this value."
+        + " Unsupported for yahoo source.",
+    )
+    is_spam: Optional[bool] = Field(
+        default=None,
+        description="Filter whether it is marked as spam or not."
+        + " Unsupported for yahoo source.",
+    )
+    business_relevance_greater_than: Optional[float] = Field(
+        default=None,
+        ge=0,
+        le=1,
+        description="News stories will have a business relevance score more than this value."
+        + " Unsupported for yahoo source. Value is a decimal between 0 and 1.",
+    )
+    business_relevance_less_than: Optional[float] = Field(
+        default=None,
+        ge=0,
+        le=1,
+        description="News stories will have a business relevance score less than this value."
+        + " Unsupported for yahoo source. Value is a decimal between 0 and 1.",
+    )
+
+    @field_validator("symbol", mode="before", check_fields=False)
+    @classmethod
+    def _symbol_mandatory(cls, v):
+        """Symbol mandatory validator."""
+        if not v:
+            raise OpenBBError("Required field missing -> symbol")
+        return v
+
+
+class IntrinioCompanyNewsData(CompanyNewsData):
+    """Intrinio Company News Data."""
+
+    __alias_dict__ = {
+        "date": "publication_date",
+        "sentiment": "article_sentiment",
+        "sentiment_confidence": "article_sentiment_confidence",
+        "symbols": "symbol",
+    }
+    source: Optional[str] = Field(
+        default=None,
+        description="The source of the news article.",
+    )
+    summary: Optional[str] = Field(
+        default=None,
+        description="The summary of the news article.",
+    )
+    topics: Optional[str] = Field(
+        default=None,
+        description="The topics related to the news article.",
+    )
+    word_count: Optional[int] = Field(
+        default=None,
+        description="The word count of the news article.",
+    )
+    business_relevance: Optional[float] = Field(
+        default=None,
+        description=" 	How strongly correlated the news article is to the business",
+    )
+    sentiment: Optional[str] = Field(
+        default=None,
+        description="The sentiment of the news article - i.e, negative, positive.",
+    )
+    sentiment_confidence: Optional[float] = Field(
+        default=None,
+        description="The confidence score of the sentiment rating.",
+    )
+    language: Optional[str] = Field(
+        default=None,
+        description="The language of the news article.",
+    )
+    spam: Optional[bool] = Field(
+        default=None,
+        description="Whether the news article is spam.",
+    )
+    copyright: Optional[str] = Field(
+        default=None,
+        description="The copyright notice of the news article.",
+    )
+    id: str = Field(description="Article ID.")
+    security: Optional[IntrinioSecurity] = Field(
+        default=None,
+        description="The Intrinio Security object. Contains the security details related to the news article.",
+    )
+
+    @field_validator("publication_date", mode="before", check_fields=False)
+    @classmethod
+    def date_validate(cls, v):
+        """Return the date as a datetime object."""
+        return datetime.strptime(v, "%Y-%m-%dT%H:%M:%S.000Z")
+
+    @field_validator("topics", mode="before", check_fields=False)
+    @classmethod
+    def topics_validate(cls, v):
+        """Parse the topics as a string."""
+        if v:
+            topics = [t.get("name") for t in v if t and t not in ["", " "]]
+            return ", ".join(topics)
+        return None
+
+    @field_validator("copyright", mode="before", check_fields=False)
+    @classmethod
+    def copyright_validate(cls, v):
+        """Clean empty strings."""
+        return None if v in ["", " "] else v
+
+
+class IntrinioCompanyNewsFetcher(
+    Fetcher[
+        IntrinioCompanyNewsQueryParams,
+        List[IntrinioCompanyNewsData],
+    ]
+):
+    """Transform the query, extract and transform the data from the Intrinio endpoints."""
+
+    @staticmethod
+    def transform_query(params: Dict[str, Any]) -> IntrinioCompanyNewsQueryParams:
+        """Transform the query params."""
+        transformed_params = params
+        if not transformed_params.get("start_date"):
+            transformed_params["start_date"] = (
+                datetime.now() - timedelta(days=365)
+            ).date()
+        if not transformed_params.get("end_date"):
+            transformed_params["end_date"] = (datetime.now() + timedelta(days=1)).date()
+        if transformed_params["start_date"] == transformed_params["end_date"]:
+            transformed_params["end_date"] = (
+                transformed_params["end_date"] + timedelta(days=1)
+            ).date()
+        return IntrinioCompanyNewsQueryParams(**transformed_params)
+
+    @staticmethod
+    async def aextract_data(
+        query: IntrinioCompanyNewsQueryParams,
+        credentials: Optional[Dict[str, str]],
+        **kwargs: Any,
+    ) -> List[Dict]:
+        """Return the raw data from the Intrinio endpoint."""
+        api_key = credentials.get("intrinio_api_key") if credentials else ""
+
+        base_url = "https://api-v2.intrinio.com/companies"
+        ignore = (
+            ["symbol", "page_size", "is_spam"]
+            if not query.source or query.source == "yahoo"
+            else ["symbol", "page_size"]
+        )
+        query_str = get_querystring(query.model_dump(by_alias=True), ignore)
+        symbols = query.symbol.split(",") if query.symbol else []
+        news: List = []
+
+        async def callback(response, session):
+            """Response callback."""
+            result = await response.json()
+
+            if isinstance(result, dict) and "error" in result:
+                if "api key" in result.get("message", "").lower():
+                    raise UnauthorizedError(
+                        f"Unauthorized Intrinio request -> {result.get('message')}"
+                    )
+                raise OpenBBError(f"Error in Intrinio request -> {result}")
+
+            symbol = response.url.parts[-2]
+            _data = result.get("news", [])
+            data = []
+            data.extend([{"symbol": symbol, **d} for d in _data])
+            articles = len(data)
+            next_page = result.get("next_page")
+            # query.limit can be None...
+            limit = query.limit or 2500
+            while next_page and limit > articles:
+                url = (
+                    f"{base_url}/{symbol}/news?{query_str}"
+                    + f"&page_size={query.limit}&api_key={api_key}&next_page={next_page}"
+                )
+                result = await get_data(url, session=session, **kwargs)
+                _data = result.get("news", [])
+                if _data:
+                    data.extend([{"symbol": symbol, **d} for d in _data])
+                    articles = len(data)
+                next_page = result.get("next_page")
+            return data
+
+        seen = set()
+
+        async def get_one(symbol):
+            """Get the data for one symbol."""
+            url = f"{base_url}/{symbol}/news?{query_str}&page_size={query.limit}&api_key={api_key}"
+            data = await amake_request(url, response_callback=callback, **kwargs)
+            if not data:
+                warn(f"No data found for: {symbol}")
+            if data:
+                data = [x for x in data if not (x["url"] in seen or seen.add(x["url"]))]  # type: ignore
+                news.extend(
+                    sorted(data, key=lambda x: x["publication_date"], reverse=True)[
+                        : query.limit
+                    ]
+                )
+
+        tasks = [get_one(symbol) for symbol in symbols]
+
+        await asyncio.gather(*tasks)
+
+        if not news:
+            raise EmptyDataError(
+                "Error: The request was returned as empty."
+                + " Try adjusting the requested date ranges, if applicable."
+            )
+
+        return news
+
+    # pylint: disable=unused-argument
+    @staticmethod
+    def transform_data(
+        query: IntrinioCompanyNewsQueryParams, data: List[Dict], **kwargs: Any
+    ) -> List[IntrinioCompanyNewsData]:
+        """Return the transformed data."""
+        results: List[IntrinioCompanyNewsData] = []
+        for item in data:
+            body = item.get("body", {})
+            if not body:
+                item["text"] = item.pop("summary")
+            if body:
+                _ = item.pop("body")
+                item["publication_date"] = body.get("publication_date", None)
+                item["text"] = body.get("body", None)
+            results.append(IntrinioCompanyNewsData.model_validate(item))
+        return results

openbb_platform/providers/intrinio/openbb_intrinio/models/currency_pairs.py

@@ -0,0 +1,90 @@
+"""Intrinio Currency Available Pairs Model."""
+
+# pylint: disable=unused-argument
+
+from typing import Any, Dict, List, Optional
+
+from openbb_core.provider.abstract.fetcher import Fetcher
+from openbb_core.provider.standard_models.currency_pairs import (
+    CurrencyPairsData,
+    CurrencyPairsQueryParams,
+)
+from openbb_core.provider.utils.errors import EmptyDataError
+from pydantic import Field
+
+
+class IntrinioCurrencyPairsQueryParams(CurrencyPairsQueryParams):
+    """Intrinio Currency Available Pairs Query.
+
+    Source: https://docs.intrinio.com/documentation/web_api/get_forex_pairs_v2
+    """
+
+
+class IntrinioCurrencyPairsData(CurrencyPairsData):
+    """Intrinio Currency Available Pairs Data."""
+
+    __alias_dict__ = {"symbol": "code"}
+
+    base_currency: str = Field(
+        description="ISO 4217 currency code of the base currency."
+    )
+    quote_currency: str = Field(
+        description="ISO 4217 currency code of the quote currency."
+    )
+
+
+class IntrinioCurrencyPairsFetcher(
+    Fetcher[
+        IntrinioCurrencyPairsQueryParams,
+        List[IntrinioCurrencyPairsData],
+    ]
+):
+    """Transform the query, extract and transform the data from the Intrinio endpoints."""
+
+    @staticmethod
+    def transform_query(params: Dict[str, Any]) -> IntrinioCurrencyPairsQueryParams:
+        """Transform the query params."""
+        return IntrinioCurrencyPairsQueryParams(**params)
+
+    @staticmethod
+    async def aextract_data(
+        query: IntrinioCurrencyPairsQueryParams,
+        credentials: Optional[Dict[str, str]],
+        **kwargs: Any,
+    ) -> List[Dict]:
+        """Return the raw data from the Intrinio endpoint."""
+        # pylint: disable=import-outside-toplevel
+        from openbb_intrinio.utils.helpers import get_data_many
+
+        api_key = credentials.get("intrinio_api_key") if credentials else ""
+
+        base_url = "https://api-v2.intrinio.com"
+        url = f"{base_url}/forex/pairs?api_key={api_key}"
+        return await get_data_many(url, "pairs", **kwargs)
+
+    @staticmethod
+    def transform_data(
+        query: IntrinioCurrencyPairsQueryParams, data: List[Dict], **kwargs: Any
+    ) -> List[IntrinioCurrencyPairsData]:
+        """Return the transformed data."""
+        # pylint: disable=import-outside-toplevel
+        from pandas import DataFrame
+
+        if not data:
+            raise EmptyDataError("The request was returned empty.")
+        df = DataFrame(data)
+        if query.query:
+            df = df[
+                df["code"].str.contains(query.query, case=False)
+                | df["base_currency"].str.contains(query.query, case=False)
+                | df["quote_currency"].str.contains(query.query, case=False)
+            ]
+        if len(df) == 0:
+            raise EmptyDataError(
+                f"No results were found with the query supplied. -> {query.query}"
+                + " Hint: Names and descriptions are not searchable from Intrinio, try 3-letter symbols."
+            )
+        return [
+            IntrinioCurrencyPairsData.model_validate(d)
+            for d in df.to_dict(orient="records")
+        ]

openbb_platform/providers/intrinio/openbb_intrinio/models/equity_historical.py

@@ -0,0 +1,274 @@
+"""Intrinio Equity Historical Price Model."""
+
+# pylint: disable = unused-argument
+
+from datetime import datetime, time
+from typing import Any, Dict, List, Literal, Optional
+
+from dateutil.relativedelta import relativedelta
+from openbb_core.app.model.abstract.error import OpenBBError
+from openbb_core.provider.abstract.fetcher import Fetcher
+from openbb_core.provider.standard_models.equity_historical import (
+    EquityHistoricalData,
+    EquityHistoricalQueryParams,
+)
+from openbb_core.provider.utils.descriptions import (
+    DATA_DESCRIPTIONS,
+    QUERY_DESCRIPTIONS,
+)
+from openbb_core.provider.utils.errors import EmptyDataError
+from openbb_core.provider.utils.helpers import (
+    ClientResponse,
+    ClientSession,
+    amake_request,
+    get_querystring,
+)
+from pydantic import Field, PrivateAttr, model_validator
+
+
+class IntrinioEquityHistoricalQueryParams(EquityHistoricalQueryParams):
+    """Intrinio Equity Historical Price Query.
+
+    Source: https://docs.intrinio.com/documentation/web_api/get_security_interval_prices_v2
+    """
+
+    __json_schema_extra__ = {
+        "interval": {
+            "choices": [
+                "1m",
+                "5m",
+                "10m",
+                "15m",
+                "30m",
+                "60m",
+                "1h",
+                "1d",
+                "1W",
+                "1M",
+                "1Q",
+                "1Y",
+            ],
+        },
+    }
+
+    symbol: str = Field(
+        description="A Security identifier (Ticker, FIGI, ISIN, CUSIP, Intrinio ID)."
+    )
+    interval: Literal[
+        "1m", "5m", "10m", "15m", "30m", "60m", "1h", "1d", "1W", "1M", "1Q", "1Y"
+    ] = Field(default="1d", description=QUERY_DESCRIPTIONS.get("interval", ""))
+    start_time: Optional[time] = Field(
+        default=None,
+        description="Return intervals starting at the specified time on the `start_date` formatted as 'HH:MM:SS'.",
+    )
+    end_time: Optional[time] = Field(
+        default=None,
+        description="Return intervals stopping at the specified time on the `end_date` formatted as 'HH:MM:SS'.",
+    )
+    timezone: Optional[str] = Field(
+        default="America/New_York",
+        description="Timezone of the data, in the IANA format (Continent/City).",
+    )
+    source: Literal["realtime", "delayed", "nasdaq_basic"] = Field(
+        default="realtime", description="The source of the data."
+    )
+    _interval_size: Literal["1m", "5m", "10m", "15m", "30m", "60m", "1h"] = PrivateAttr(
+        default=None
+    )
+    _frequency: Literal["daily", "weekly", "monthly", "quarterly", "yearly"] = (
+        PrivateAttr(default=None)
+    )
+
+    # pylint: disable=protected-access
+    @model_validator(mode="after")
+    @classmethod
+    def set_time_params(cls, values: "IntrinioEquityHistoricalQueryParams"):
+        """Set the default start & end date and time params for Intrinio API."""
+        frequency_dict = {
+            "1d": "daily",
+            "1W": "weekly",
+            "1M": "monthly",
+            "1Q": "quarterly",
+            "1Y": "yearly",
+        }
+
+        if values.interval in ["1m", "5m", "10m", "15m", "30m", "60m", "1h"]:
+            values._interval_size = values.interval  # type: ignore
+        elif values.interval in ["1d", "1W", "1M", "1Q", "1Y"]:
+            values._frequency = frequency_dict[values.interval]  # type: ignore
+
+        return values
+
+
+class IntrinioEquityHistoricalData(EquityHistoricalData):
+    """Intrinio Equity Historical Price Data."""
+
+    __alias_dict__ = {
+        "date": "time",
+        "change_percent": "percent_change",
+        "interval": "frequency",
+        "intra_period": "intraperiod",
+    }
+
+    average: Optional[float] = Field(
+        default=None,
+        description="Average trade price of an individual equity during the interval.",
+    )
+    change: Optional[float] = Field(
+        default=None,
+        description="Change in the price of the symbol from the previous day.",
+    )
+    change_percent: Optional[float] = Field(
+        default=None,
+        description="Percent change in the price of the symbol from the previous day.",
+        json_schema_extra={"x-unit_measurement": "percent", "x-frontend_multiply": 100},
+    )
+    adj_open: Optional[float] = Field(
+        default=None,
+        description="The adjusted open price.",
+    )
+    adj_high: Optional[float] = Field(
+        default=None,
+        description="The adjusted high price.",
+    )
+    adj_low: Optional[float] = Field(
+        default=None,
+        description="The adjusted low price.",
+    )
+    adj_close: Optional[float] = Field(
+        default=None,
+        description=DATA_DESCRIPTIONS.get("adj_close", ""),
+    )
+    adj_volume: Optional[float] = Field(
+        default=None,
+        description="The adjusted volume.",
+    )
+    fifty_two_week_high: Optional[float] = Field(
+        default=None,
+        description="52 week high price for the symbol.",
+    )
+    fifty_two_week_low: Optional[float] = Field(
+        default=None,
+        description="52 week low price for the symbol.",
+    )
+    factor: Optional[float] = Field(
+        default=None,
+        description="factor by which to multiply equity prices before this "
+        "date, in order to calculate historically-adjusted equity prices.",
+    )
+    split_ratio: Optional[float] = Field(
+        default=None,
+        description="Ratio of the equity split, if a split occurred.",
+    )
+    dividend: Optional[float] = Field(
+        default=None,
+        description="Dividend amount, if a dividend was paid.",
+    )
+    close_time: Optional[datetime] = Field(
+        default=None,
+        description="The timestamp that represents the end of the interval span.",
+    )
+    interval: Optional[str] = Field(
+        default=None,
+        description="The data time frequency.",
+    )
+    intra_period: Optional[bool] = Field(
+        default=None,
+        description="If true, the equity price represents an unfinished period "
+        "(be it day, week, quarter, month, or year), meaning that the close "
+        "price is the latest price available, not the official close price "
+        "for the period",
+    )
+
+
+class IntrinioEquityHistoricalFetcher(
+    Fetcher[
+        IntrinioEquityHistoricalQueryParams,
+        List[IntrinioEquityHistoricalData],
+    ]
+):
+    """Transform the query, extract and transform the data from the Intrinio endpoints."""
+
+    @staticmethod
+    def transform_query(params: Dict[str, Any]) -> IntrinioEquityHistoricalQueryParams:
+        """Transform the query params."""
+        transformed_params = params
+
+        now = datetime.now().date()
+        if params.get("start_date") is None:
+            transformed_params["start_date"] = now - relativedelta(years=1)
+
+        if params.get("end_date") is None:
+            transformed_params["end_date"] = now
+
+        if params.get("start_time") is None:
+            transformed_params["start_time"] = time(0, 0, 0)
+
+        if params.get("end_time") is None:
+            transformed_params["end_time"] = time(23, 59, 59)
+
+        return IntrinioEquityHistoricalQueryParams(**transformed_params)
+
+    # pylint: disable=protected-access
+    @staticmethod
+    async def aextract_data(
+        query: IntrinioEquityHistoricalQueryParams,
+        credentials: Optional[Dict[str, str]],
+        **kwargs: Any,
+    ) -> List[Dict]:
+        """Return the raw data from the Intrinio endpoint."""
+        api_key = credentials.get("intrinio_api_key") if credentials else ""
+        base_url = f"https://api-v2.intrinio.com/securities/{query.symbol}/prices"
+        query_str = get_querystring(
+            query.model_dump(by_alias=True), ["symbol", "interval"]
+        )
+
+        if query._interval_size:
+            base_url += f"/intervals?interval_size={query._interval_size}"
+            data_key = "intervals"
+        elif query._frequency:
+            base_url += f"?frequency={query._frequency}"
+            data_key = "stock_prices"
+
+        async def callback(response: ClientResponse, session: ClientSession) -> list:
+            """Return the response."""
+            init_response = await response.json()
+            if "error" in init_response:
+                raise OpenBBError(
+                    f"Intrinio Error Message -> {init_response['error']}: {init_response.get('message')}"  # type: ignore
+                )
+
+            all_data: list = init_response.get(data_key, [])  # type: ignore
+
+            next_page = init_response.get("next_page", None)  # type: ignore
+            while next_page:
+                url = response.url.update_query(next_page=next_page).human_repr()
+                response_data = await session.get_json(url)
+
+                all_data.extend(response_data.get(data_key, []))  # type: ignore
+                next_page = response_data.get("next_page", None)  # type: ignore
+
+            return all_data
+
+        url = f"{base_url}&{query_str}&api_key={api_key}"
+
+        return await amake_request(url, response_callback=callback, **kwargs)  # type: ignore
+
+    @staticmethod
+    def transform_data(
+        query: IntrinioEquityHistoricalQueryParams,
+        data: List[Dict],
+        **kwargs: Any,
+    ) -> List[IntrinioEquityHistoricalData]:
+        """Return the transformed data."""
+        if not data:
+            raise EmptyDataError("The request was returned empty.")
+        date_col = (
+            "time"
+            if query.interval in ["1m", "5m", "10m", "15m", "30m", "60m", "1h"]
+            else "date"
+        )
+        return [
+            IntrinioEquityHistoricalData.model_validate(d)
+            for d in sorted(data, key=lambda x: x[date_col], reverse=False)
+        ]

openbb_platform/providers/intrinio/openbb_intrinio/models/equity_info.py

@@ -0,0 +1,78 @@
+"""Intrinio Equity Info Model."""
+
+from typing import Any, Dict, List, Optional
+
+from openbb_core.provider.abstract.fetcher import Fetcher
+from openbb_core.provider.standard_models.equity_info import (
+    EquityInfoData,
+    EquityInfoQueryParams,
+)
+from openbb_core.provider.utils.helpers import (
+    amake_requests,
+)
+from openbb_intrinio.utils.helpers import response_callback
+from pydantic import Field
+
+
+class IntrinioEquityInfoQueryParams(EquityInfoQueryParams):
+    """Intrinio Equity Info Query.
+
+    Source: https://docs.intrinio.com/documentation/web_api/get_company_v2
+    """
+
+    __json_schema_extra__ = {"symbol": {"multiple_items_allowed": True}}
+
+
+class IntrinioEquityInfoData(EquityInfoData):
+    """Intrinio Equity Info Data."""
+
+    __alias_dict__ = {
+        "symbol": "ticker",
+    }
+
+    id: str = Field(default=None, description="Intrinio ID for the company.")
+    thea_enabled: Optional[bool] = Field(
+        default=None, description="Whether the company has been enabled for Thea."
+    )
+
+
+class IntrinioEquityInfoFetcher(
+    Fetcher[
+        IntrinioEquityInfoQueryParams,
+        List[IntrinioEquityInfoData],
+    ]
+):
+    """Transform the query, extract and transform the data from the Intrinio endpoints."""
+
+    @staticmethod
+    def transform_query(params: Dict[str, Any]) -> IntrinioEquityInfoQueryParams:
+        """Transform the query."""
+        return IntrinioEquityInfoQueryParams(**params)
+
+    # pylint: disable=W0613:unused-argument
+    @staticmethod
+    async def aextract_data(
+        query: IntrinioEquityInfoQueryParams,
+        credentials: Optional[Dict[str, str]],
+        **kwargs: Any,
+    ) -> Dict:
+        """Return the raw data from the Intrinio endpoint."""
+        api_key = credentials.get("intrinio_api_key") if credentials else ""
+        base_url = "https://api-v2.intrinio.com"
+
+        urls = [
+            f"{base_url}/companies/{s.strip()}?api_key={api_key}"
+            for s in query.symbol.split(",")
+        ]
+
+        return await amake_requests(urls, response_callback, **kwargs)
+
+    # pylint: disable=W0613:unused-argument
+    @staticmethod
+    def transform_data(
+        query: IntrinioEquityInfoQueryParams,
+        data: List[Dict],
+        **kwargs: Any,
+    ) -> List[IntrinioEquityInfoData]:
+        """Transform the data."""
+        return [IntrinioEquityInfoData.model_validate(d) for d in data]

openbb_platform/providers/intrinio/openbb_intrinio/models/equity_quote.py

@@ -0,0 +1,142 @@
+"""Intrinio Equity Quote Model."""
+
+# pylint: disable=unused-argument
+import re
+import warnings
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+
+from openbb_core.provider.abstract.fetcher import Fetcher
+from openbb_core.provider.standard_models.equity_quote import (
+    EquityQuoteData,
+    EquityQuoteQueryParams,
+)
+from openbb_core.provider.utils.helpers import (
+    ClientResponse,
+    amake_requests,
+)
+from openbb_intrinio.utils.references import SOURCES, VENUES, IntrinioSecurity
+from pydantic import Field, field_validator
+
+_warn = warnings.warn
+
+
+class IntrinioEquityQuoteQueryParams(EquityQuoteQueryParams):
+    """Intrinio Equity Quote Query.
+
+    Source: https://docs.intrinio.com/documentation/web_api/get_security_realtime_price_v2
+    """
+
+    __json_schema_extra__ = {"symbol": {"multiple_items_allowed": True}}
+
+    symbol: str = Field(
+        description="A Security identifier (Ticker, FIGI, ISIN, CUSIP, Intrinio ID)."
+    )
+    source: SOURCES = Field(default="iex", description="Source of the data.")
+
+
+class IntrinioEquityQuoteData(EquityQuoteData):
+    """Intrinio Equity Quote Data."""
+
+    __alias_dict__ = {
+        "exchange": "listing_venue",
+        "market_center": "market_center_code",
+        "bid": "bid_price",
+        "ask": "ask_price",
+        "open": "open_price",
+        "close": "close_price",
+        "low": "low_price",
+        "high": "high_price",
+        "last_timestamp": "last_time",
+        "volume": "market_volume",
+    }
+    is_darkpool: Optional[bool] = Field(
+        default=None, description="Whether or not the current trade is from a darkpool."
+    )
+    source: Optional[str] = Field(
+        default=None, description="Source of the Intrinio data."
+    )
+    updated_on: datetime = Field(
+        description="Date and Time when the data was last updated."
+    )
+    security: Optional[IntrinioSecurity] = Field(
+        default=None, description="Security details related to the quote."
+    )
+
+    @field_validator("last_time", "updated_on", mode="before", check_fields=False)
+    @classmethod
+    def date_validate(cls, v):  # pylint: disable=E0213
+        """Return the date as a datetime object."""
+        return (
+            datetime.fromisoformat(v.replace("Z", "+00:00"))
+            if v.endswith(("Z", "+00:00"))
+            else datetime.fromisoformat(v)
+        )
+
+    @field_validator("sales_conditions", mode="before", check_fields=False)
+    @classmethod
+    def validate_sales_conditions(cls, v):
+        """Validate sales conditions and remove empty strings."""
+        if v:
+            control_char_re = re.compile(r"[\x00-\x1f\x7f-\x9f]")
+            v = control_char_re.sub("", v).strip()
+            v = None if v == "" else v
+        return v if v else None
+
+    @field_validator("exchange", "market_center", mode="before", check_fields=False)
+    @classmethod
+    def validate_listing_venue(cls, v):
+        """Validate listing venue and remove empty strings."""
+        if v:
+            return VENUES.get(v, v)
+        return None
+
+
+class IntrinioEquityQuoteFetcher(
+    Fetcher[
+        IntrinioEquityQuoteQueryParams,
+        List[IntrinioEquityQuoteData],
+    ]
+):
+    """Transform the query, extract and transform the data from the Intrinio endpoints."""
+
+    @staticmethod
+    def transform_query(params: Dict[str, Any]) -> IntrinioEquityQuoteQueryParams:
+        """Transform the query params."""
+        return IntrinioEquityQuoteQueryParams(**params)
+
+    @staticmethod
+    async def aextract_data(
+        query: IntrinioEquityQuoteQueryParams,
+        credentials: Optional[Dict[str, str]],
+        **kwargs: Any,
+    ) -> List[Dict]:
+        """Return the raw data from the Intrinio endpoint."""
+        api_key = credentials.get("intrinio_api_key") if credentials else ""
+
+        base_url = "https://api-v2.intrinio.com"
+
+        async def callback(response: ClientResponse, _: Any) -> dict:
+            """Return the response."""
+            if response.status != 200:
+                return {}
+
+            response_data = await response.json()
+            response_data["symbol"] = response_data["security"].get("ticker", None)  # type: ignore
+            if "messages" in response_data and response_data.get("messages"):  # type: ignore
+                _message = list(response_data.pop("messages"))  # type: ignore
+                _warn(str(",".join(_message)))
+            return response_data  # type: ignore
+
+        urls = [
+            f"{base_url}/securities/{s.strip()}/prices/realtime?source={query.source}&api_key={api_key}"
+            for s in query.symbol.split(",")
+        ]
+        return await amake_requests(urls, callback, **kwargs)
+
+    @staticmethod
+    def transform_data(
+        query: IntrinioEquityQuoteQueryParams, data: List[Dict], **kwargs: Any
+    ) -> List[IntrinioEquityQuoteData]:
+        """Return the transformed data."""
+        return [IntrinioEquityQuoteData.model_validate(d) for d in data]

openbb_platform/providers/intrinio/openbb_intrinio/models/equity_search.py

@@ -0,0 +1,89 @@
+"""Intrinio Equity Search Model."""
+
+from typing import Any, Dict, List, Optional
+
+from openbb_core.provider.abstract.fetcher import Fetcher
+from openbb_core.provider.standard_models.equity_search import (
+    EquitySearchData,
+    EquitySearchQueryParams,
+)
+from openbb_core.provider.utils.descriptions import (
+    DATA_DESCRIPTIONS,
+    QUERY_DESCRIPTIONS,
+)
+from openbb_core.provider.utils.helpers import get_querystring
+from openbb_intrinio.utils.helpers import get_data_one
+from pydantic import Field
+
+
+class IntrinioEquitySearchQueryParams(EquitySearchQueryParams):
+    """Intrinio Equity Search Query.
+
+    Source: https://docs.intrinio.com/documentation/web_api/search_companies_v2
+    """
+
+    __alias_dict__ = {
+        "limit": "page_size",
+    }
+
+    active: bool = Field(
+        default=True,
+        description="When true, return companies that are actively traded (having stock prices within the past 14 days)."
+        + " When false, return companies that are not actively traded or never have been traded.",
+    )
+    limit: Optional[int] = Field(
+        default=10000,
+        description=QUERY_DESCRIPTIONS.get("limit", ""),
+    )
+
+
+class IntrinioEquitySearchData(EquitySearchData):
+    """Intrinio Equity Search Data."""
+
+    __alias_dict__ = {
+        "intrinio_id": "id",
+        "symbol": "ticker",
+    }
+
+    cik: Optional[str] = Field(description=DATA_DESCRIPTIONS.get("CIK", ""))
+    lei: Optional[str] = Field(
+        description="The Legal Entity Identifier (LEI) of the company."
+    )
+    intrinio_id: str = Field(description="The Intrinio ID of the company.")
+
+
+class IntrinioEquitySearchFetcher(
+    Fetcher[
+        IntrinioEquitySearchQueryParams,
+        List[IntrinioEquitySearchData],
+    ]
+):
+    """Transform the query, extract and transform the data from the Intrinio endpoints."""
+
+    @staticmethod
+    def transform_query(params: Dict[str, Any]) -> IntrinioEquitySearchQueryParams:
+        """Transform the query."""
+        return IntrinioEquitySearchQueryParams(**params)
+
+    @staticmethod
+    async def aextract_data(
+        query: IntrinioEquitySearchQueryParams,  # pylint: disable=unused-argument
+        credentials: Optional[Dict[str, str]],
+        **kwargs: Any,
+    ) -> List[Dict]:
+        """Return the raw data from the Intrinio endpoint."""
+
+        api_key = credentials.get("intrinio_api_key") if credentials else ""
+        query_str = get_querystring(query.model_dump(by_alias=True), ["is_symbol"])
+        base_url = "https://api-v2.intrinio.com/companies/search?"
+        url = f"{base_url}{query_str}&api_key={api_key}"
+        data = await get_data_one(url, **kwargs)
+        return data
+
+    @staticmethod
+    def transform_data(
+        query: IntrinioEquitySearchQueryParams, data: Dict, **kwargs: Any
+    ) -> List[IntrinioEquitySearchData]:
+        """Transform the data to the standard format."""
+
+        return [IntrinioEquitySearchData.model_validate(d) for d in data["companies"]]

openbb_platform/providers/intrinio/openbb_intrinio/models/etf_holdings.py

@@ -0,0 +1,214 @@
+"""Intrinio ETF Holdings Model."""
+
+# pylint: disable=unused-argument
+
+from datetime import date as dateType
+from typing import Any, Dict, List, Optional, Union
+
+from openbb_core.app.model.abstract.error import OpenBBError
+from openbb_core.provider.abstract.fetcher import Fetcher
+from openbb_core.provider.standard_models.etf_holdings import (
+    EtfHoldingsData,
+    EtfHoldingsQueryParams,
+)
+from openbb_core.provider.utils.descriptions import QUERY_DESCRIPTIONS
+from openbb_core.provider.utils.helpers import (
+    ClientResponse,
+    ClientSession,
+    amake_request,
+)
+from pydantic import Field, model_validator
+
+
+class IntrinioEtfHoldingsQueryParams(EtfHoldingsQueryParams):
+    """
+    Intrinio ETF Holdings Query Params.
+
+    Source: https://docs.intrinio.com/documentation/web_api/get_etf_holdings_v2
+    """
+
+    __alias_dict__ = {"date": "as_of_date"}
+
+    date: Optional[dateType] = Field(
+        default=None, description=QUERY_DESCRIPTIONS.get("date", "")
+    )
+
+
+class IntrinioEtfHoldingsData(EtfHoldingsData):
+    """Intrinio ETF Holdings Data."""
+
+    __alias_dict__ = {
+        "symbol": "ticker",
+        "security_type": "type",
+        "unit": "quantity_units",
+        "face_value": "face",
+        "balance": "quantity_held",
+        "value": "market_value_held",
+        "derivatives_value": "notional_value",
+        "units_per_share": "quantity_per_share",
+        "weight": "weighting",
+        "updated": "as_of_date",
+        "country": "location",
+        "maturity_date": "maturity",
+    }
+
+    name: Optional[str] = Field(
+        default=None,
+        description="The common name for the holding.",
+    )
+    security_type: Optional[str] = Field(
+        default=None,
+        description="The type of instrument for this holding. Examples(Bond='BOND', Equity='EQUI')",
+    )
+    isin: Optional[str] = Field(
+        default=None,
+        description="The International Securities Identification Number.",
+    )
+    ric: Optional[str] = Field(
+        default=None,
+        description="The Reuters Instrument Code.",
+    )
+    sedol: Optional[str] = Field(
+        default=None,
+        description="The Stock Exchange Daily Official List.",
+    )
+    share_class_figi: Optional[str] = Field(
+        default=None,
+        description="The OpenFIGI symbol for the holding.",
+    )
+    country: Optional[str] = Field(
+        default=None,
+        description="The country or region of the holding.",
+    )
+    maturity_date: Optional[dateType] = Field(
+        default=None,
+        description="The maturity date for the debt security, if available.",
+    )
+    contract_expiry_date: Optional[dateType] = Field(
+        default=None,
+        description="Expiry date for the futures contract held, if available.",
+    )
+    coupon: Optional[float] = Field(
+        default=None,
+        description="The coupon rate of the debt security, if available.",
+        json_schema_extra={"x-unit_measurement": "percent", "x-frontend_multiply": 100},
+    )
+    balance: Optional[Union[int, float]] = Field(
+        default=None,
+        description="The number of units of the security held, if available.",
+    )
+    unit: Optional[str] = Field(
+        default=None,
+        description="The units of the 'balance' field.",
+    )
+    units_per_share: Optional[float] = Field(
+        default=None,
+        description="Number of units of the security held per share outstanding of the ETF, if available.",
+    )
+    face_value: Optional[float] = Field(
+        default=None,
+        description="The face value of the debt security, if available.",
+        json_schema_extra={"x-unit_measurement": "currency"},
+    )
+    derivatives_value: Optional[float] = Field(
+        default=None,
+        description="The notional value of derivatives contracts held.",
+        json_schema_extra={"x-unit_measurement": "currency"},
+    )
+    value: Optional[float] = Field(
+        default=None,
+        description="The market value of the holding, on the 'as_of' date.",
+        json_schema_extra={"x-unit_measurement": "currency"},
+    )
+    weight: Optional[float] = Field(
+        default=None,
+        description="The weight of the holding, as a normalized percent.",
+        json_schema_extra={"x-unit_measurement": "percent", "x-frontend_multiply": 100},
+    )
+    updated: Optional[dateType] = Field(
+        default=None,
+        description="The 'as_of' date for the holding.",
+    )
+
+    @model_validator(mode="before")
+    @classmethod
+    def replace_zero(cls, values):
+        """Check for zero values and replace with None."""
+        return (
+            {k: None if v == 0 else v for k, v in values.items()}
+            if isinstance(values, dict)
+            else values
+        )
+
+
+class IntrinioEtfHoldingsFetcher(
+    Fetcher[IntrinioEtfHoldingsQueryParams, List[IntrinioEtfHoldingsData]]
+):
+    """Intrinio ETF Holdings Fetcher."""
+
+    @staticmethod
+    def transform_query(params: Dict[str, Any]) -> IntrinioEtfHoldingsQueryParams:
+        """Transform query."""
+        return IntrinioEtfHoldingsQueryParams(**params)
+
+    @staticmethod
+    async def aextract_data(
+        query: IntrinioEtfHoldingsQueryParams,
+        credentials: Optional[Dict[str, str]],
+        **kwargs: Any,
+    ) -> List[Dict]:
+        """Return the raw data from the Intrinio endpoint."""
+        api_key = credentials.get("intrinio_api_key") if credentials else ""
+        symbol = query.symbol + ":US" if ":" not in query.symbol else query.symbol
+        URL = f"https://api-v2.intrinio.com/etfs/{symbol}/holdings?page_size=10000&api_key={api_key}"
+        if query.date:
+            URL += f"&as_of_date={query.date}"
+        data: List = []
+
+        async def response_callback(response: ClientResponse, session: ClientSession):
+            """Async response callback."""
+            results = await response.json()
+
+            if results.get("error"):  # type: ignore
+                return results
+
+            if results.get("holdings") and len(results.get("holdings")) > 0:  # type: ignore
+                data.extend(results.get("holdings"))  # type: ignore
+                while results.get("next_page"):  # type: ignore
+                    next_page = results["next_page"]  # type: ignore
+                    next_url = f"{URL}&next_page={next_page}"
+                    results = await amake_request(next_url, session=session, **kwargs)
+                    if (
+                        "holdings" in results
+                        and len(results.get("holdings")) > 0  # type: ignore
+                    ):
+                        data.extend(results.get("holdings"))  # type: ignore
+            return data
+
+        return await amake_request(URL, response_callback=response_callback, **kwargs)  # type: ignore
+
+    @staticmethod
+    def transform_data(
+        query: IntrinioEtfHoldingsQueryParams,
+        data: List[Dict],
+        **kwargs: Any,
+    ) -> List[IntrinioEtfHoldingsData]:
+        """Transform data."""
+        if not data or isinstance(data, dict) and data.get("error"):
+            if isinstance(data, list) and data == []:
+                raise OpenBBError(
+                    str(
+                        f"No holdings were found for {query.symbol}, and the response from Intrinio was empty."
+                    )
+                )
+            raise OpenBBError(str(f"{data.get('message')} {query.symbol}: {data['error']}"))  # type: ignore
+
+        results: List[IntrinioEtfHoldingsData] = []
+        for d in sorted(data, key=lambda x: x["weighting"], reverse=True):
+            # This field is deprecated and is dupilcated in the response.
+            _ = d.pop("composite_figi", None)
+            if d.get("coupon"):
+                d["coupon"] = d["coupon"] / 100
+            results.append(IntrinioEtfHoldingsData.model_validate(d))
+
+        return results

openbb_platform/providers/intrinio/openbb_intrinio/models/etf_info.py

@@ -0,0 +1,655 @@
+"""Intrinio ETF Info Model."""
+
+# pylint: disable=unused-argument
+
+from datetime import date as dateType
+from typing import Any, Dict, List, Optional
+from warnings import warn
+
+from openbb_core.provider.abstract.fetcher import Fetcher
+from openbb_core.provider.standard_models.etf_info import (
+    EtfInfoData,
+    EtfInfoQueryParams,
+)
+from openbb_core.provider.utils.errors import EmptyDataError
+from openbb_core.provider.utils.helpers import amake_requests
+from pydantic import Field
+
+
+class IntrinioEtfInfoQueryParams(EtfInfoQueryParams):
+    """
+    Intrinio ETF Info Query Params.
+
+    Source: https://docs.intrinio.com/documentation/web_api/get_etf_v2
+    """
+
+    __json_schema_extra__ = {"symbol": {"multiple_items_allowed": True}}
+
+
+class IntrinioEtfInfoData(EtfInfoData):
+    """Intrinio ETF Info Data."""
+
+    __alias_dict__ = {
+        "symbol": "ticker",
+        "exchange": "exchange_mic",
+        "issuer": "sponsor",
+        "investment_style": "type",
+        "industry_group": "sub_industry",
+        "holds_mlp": "holds_ml_ps",
+        "holds_adr": "holds_ad_rs",
+        "index_symbol": "index_ticker",
+        "figi_symbol": "figi_ticker",
+        "intrinio_id": "id",
+        "is_listed": "is_live_listed",
+        "beta_type": "smartvs_traditional_beta",
+        "beta_details": "smartvs_traditional_beta_level2",
+        "listing_country": "primary_ticker_country_code",
+        "listing_region": "primary_listing_region",
+        "primary_symbol": "primary_ticker",
+        "intraday_nav_symbol": "intraday_nav_ticker",
+        "issuer_country": "issuing_entity_country_code",
+        "livestock_type": "livestock",
+    }
+
+    fund_listing_date: Optional[dateType] = Field(
+        default=None,
+        description="The date on which the Exchange Traded Product (ETP)"
+        + " or share class of the ETP is listed on a specific exchange.",
+    )
+    data_change_date: Optional[dateType] = Field(
+        default=None,
+        description="The last date on which there was a change in a classifications data field for this ETF.",
+    )
+    etn_maturity_date: Optional[dateType] = Field(
+        default=None,
+        description="If the product is an ETN, this field identifies the maturity date for the ETN.",
+    )
+    is_listed: Optional[bool] = Field(
+        default=None,
+        description="If true, the ETF is still listed on an exchange.",
+    )
+    close_date: Optional[dateType] = Field(
+        default=None,
+        description="The date on which the ETF was de-listed if it is no longer listed.",
+    )
+    exchange: Optional[str] = Field(
+        default=None,
+        description="The exchange Market Identifier Code (MIC).",
+    )
+    isin: Optional[str] = Field(
+        default=None,
+        description="International Securities Identification Number (ISIN).",
+    )
+    ric: Optional[str] = Field(
+        default=None,
+        description="Reuters Instrument Code (RIC).",
+    )
+    sedol: Optional[str] = Field(
+        default=None,
+        description="Stock Exchange Daily Official List (SEDOL).",
+    )
+    figi_symbol: Optional[str] = Field(
+        default=None,
+        description="Financial Instrument Global Identifier (FIGI) symbol.",
+    )
+    share_class_figi: Optional[str] = Field(
+        default=None,
+        description="Financial Instrument Global Identifier (FIGI).",
+    )
+    firstbridge_id: Optional[str] = Field(
+        default=None,
+        description="The FirstBridge unique identifier for the Exchange Traded Fund (ETF).",
+    )
+    firstbridge_parent_id: Optional[str] = Field(
+        default=None,
+        description="The FirstBridge unique identifier for the parent Exchange Traded Fund (ETF), if applicable.",
+    )
+    intrinio_id: Optional[str] = Field(
+        default=None,
+        description="Intrinio unique identifier for the security.",
+    )
+    intraday_nav_symbol: Optional[str] = Field(
+        default=None,
+        description="Intraday Net Asset Value (NAV) symbol.",
+    )
+    primary_symbol: Optional[str] = Field(
+        default=None,
+        description="The primary ticker field is used for Exchange Traded Products (ETPs)"
+        + " that have multiple listings and share classes."
+        + " If an ETP has multiple listings or share classes,"
+        + " the same primary ticker is assigned to all the listings and share classes.",
+    )
+    etp_structure_type: Optional[str] = Field(
+        default=None,
+        description="Classifies Exchange Traded Products (ETPs) into very broad categories based on its legal structure.",
+    )
+    legal_structure: Optional[str] = Field(
+        default=None,
+        description="Legal structure of the fund.",
+    )
+    issuer: Optional[str] = Field(
+        default=None,
+        description="Issuer of the ETF.",
+    )
+    etn_issuing_bank: Optional[str] = Field(
+        default=None,
+        description="If the product is an Exchange Traded Note (ETN), this field identifies the issuing bank.",
+    )
+    fund_family: Optional[str] = Field(
+        default=None,
+        description="This field identifies the fund family to which the ETF belongs, as categorized by the ETF Sponsor.",
+    )
+    investment_style: Optional[str] = Field(
+        default=None,
+        description="Investment style of the ETF.",
+    )
+    derivatives_based: Optional[str] = Field(
+        default=None,
+        description="This field is populated if the ETF holds either"
+        + " listed or over-the-counter derivatives in its portfolio.",
+    )
+    income_category: Optional[str] = Field(
+        default=None,
+        description="Identifies if an Exchange Traded Fund (ETF) falls into a category"
+        + " that is specifically designed to provide a high yield or income",
+    )
+    asset_class: Optional[str] = Field(
+        default=None,
+        description="Captures the underlying nature of the securities in the Exchanged Traded Product (ETP).",
+    )
+    other_asset_types: Optional[str] = Field(
+        default=None,
+        description="If 'asset_class' field is classified as 'Other Asset Types'"
+        + " this field captures the specific category of the underlying assets.",
+    )
+    single_category_designation: Optional[str] = Field(
+        default=None,
+        description="This categorization is created for those users who want every ETF to be 'forced'"
+        + " into a single bucket, so that the assets for all categories will always sum to the total market.",
+    )
+    beta_type: Optional[str] = Field(
+        default=None,
+        description="This field identifies whether an ETF provides 'Traditional' beta exposure or 'Smart' beta exposure."
+        + " ETFs that are active (i.e. non-indexed), leveraged / inverse or have a proprietary quant model"
+        + " (i.e. that don't provide indexed exposure to a targeted factor) are classified separately.",
+    )
+    beta_details: Optional[str] = Field(
+        default=None,
+        description="This field provides further detail within the traditional and smart beta categories.",
+    )
+    market_cap_range: Optional[str] = Field(
+        default=None,
+        description="Equity ETFs are classified as falling into categories"
+        + " based on the description of their investment strategy in the prospectus."
+        + " Examples ('Mega Cap', 'Large Cap', 'Mid Cap', etc.)",
+    )
+    market_cap_weighting_type: Optional[str] = Field(
+        default=None,
+        description="For ETFs that take the value 'Market Cap Weighted' in the 'index_weighting_scheme' field,"
+        + " this field provides detail on the market cap weighting type.",
+    )
+    index_weighting_scheme: Optional[str] = Field(
+        default=None,
+        description="For ETFs that track an underlying index,"
+        + " this field provides detail on the index weighting type.",
+    )
+    index_linked: Optional[str] = Field(
+        default=None,
+        description="This field identifies whether an ETF is index linked or active.",
+    )
+    index_name: Optional[str] = Field(
+        default=None,
+        description="This field identifies the name of the underlying index tracked by the ETF, if applicable.",
+    )
+    index_symbol: Optional[str] = Field(
+        default=None,
+        description="This field identifies the OpenFIGI ticker for the Index underlying the ETF.",
+    )
+    parent_index: Optional[str] = Field(
+        default=None,
+        description="This field identifies the name of the parent index, which represents"
+        + " the broader universe from which the index underlying the ETF is created, if applicable.",
+    )
+    index_family: Optional[str] = Field(
+        default=None,
+        description="This field identifies the index family to which the index underlying the ETF belongs."
+        + " The index family is represented as categorized by the index provider.",
+    )
+    broader_index_family: Optional[str] = Field(
+        default=None,
+        description="This field identifies the broader index family to which the index underlying the ETF belongs."
+        + " The broader index family is represented as categorized by the index provider.",
+    )
+    index_provider: Optional[str] = Field(
+        default=None,
+        description="This field identifies the Index provider for the index underlying the ETF, if applicable.",
+    )
+    index_provider_code: Optional[str] = Field(
+        default=None,
+        description="This field provides the First Bridge code for each Index provider,"
+        + " corresponding to the index underlying the ETF if applicable.",
+    )
+    replication_structure: Optional[str] = Field(
+        default=None,
+        description="The replication structure of the Exchange Traded Product (ETP).",
+    )
+    growth_value_tilt: Optional[str] = Field(
+        default=None,
+        description="Classifies equity ETFs as either 'Growth' or Value' based on the stated style tilt"
+        + " in the ETF prospectus. Equity ETFs that do not have a stated style tilt are classified as 'Core / Blend'.",
+    )
+    growth_type: Optional[str] = Field(
+        default=None,
+        description="For ETFs that are classified as 'Growth' in 'growth_value_tilt',"
+        + " this field further identifies those where the stocks in the"
+        + " ETF are both selected and weighted based on their growth (style factor) scores.",
+    )
+    value_type: Optional[str] = Field(
+        default=None,
+        description="For ETFs that are classified as 'Value' in 'growth_value_tilt',"
+        + " this field further identifies those where the stocks in the"
+        + " ETF are both selected and weighted based on their value (style factor) scores.",
+    )
+    sector: Optional[str] = Field(
+        default=None,
+        description="For equity ETFs that aim to provide targeted exposure to a sector or industry,"
+        + " this field identifies the Sector that it provides the exposure to.",
+    )
+    industry: Optional[str] = Field(
+        default=None,
+        description="For equity ETFs that aim to provide targeted exposure to an industry,"
+        + " this field identifies the Industry that it provides the exposure to.",
+    )
+    industry_group: Optional[str] = Field(
+        default=None,
+        description="For equity ETFs that aim to provide targeted exposure to a sub-industry,"
+        + " this field identifies the sub-Industry that it provides the exposure to.",
+    )
+    cross_sector_theme: Optional[str] = Field(
+        default=None,
+        description="For equity ETFs that aim to provide targeted exposure to a specific investment theme"
+        + " that cuts across GICS sectors, this field identifies the specific cross-sector theme."
+        + " Examples ('Agri-business', 'Natural Resources', 'Green Investing', etc.)",
+    )
+    natural_resources_type: Optional[str] = Field(
+        default=None,
+        description="For ETFs that are classified as 'Natural Resources' in the 'cross_sector_theme' field,"
+        + " this field provides further detail on the type of Natural Resources exposure.",
+    )
+    us_or_excludes_us: Optional[str] = Field(
+        default=None,
+        description="Takes the value of 'Domestic' for US exposure,"
+        + " 'International' for non-US exposure and 'Global' for exposure that includes all regions including the US.",
+    )
+    developed_emerging: Optional[str] = Field(
+        default=None,
+        description="This field identifies the stage of development of the markets that the ETF provides exposure to.",
+    )
+    specialized_region: Optional[str] = Field(
+        default=None,
+        description="This field is populated if the ETF provides targeted"
+        + " exposure to a specific type of geography-based grouping"
+        + " that does not fall into a specific country or continent grouping."
+        + " Examples ('BRIC', 'Chindia', etc.)",
+    )
+    continent: Optional[str] = Field(
+        default=None,
+        description="This field is populated if the ETF provides targeted exposure"
+        + " to a specific continent or country within that Continent.",
+    )
+    latin_america_sub_group: Optional[str] = Field(
+        default=None,
+        description="For ETFs that are classified as 'Latin America' in the 'continent' field,"
+        + " this field provides further detail on the type of regional exposure.",
+    )
+    europe_sub_group: Optional[str] = Field(
+        default=None,
+        description="For ETFs that are classified as 'Europe' in the 'continent' field,"
+        + " this field provides further detail on the type of regional exposure.",
+    )
+    asia_sub_group: Optional[str] = Field(
+        default=None,
+        description="For ETFs that are classified as 'Asia' in the 'continent' field,"
+        + " this field provides further detail on the type of regional exposure.",
+    )
+    specific_country: Optional[str] = Field(
+        default=None,
+        description="This field is populated if the ETF provides targeted exposure to a specific country.",
+    )
+    china_listing_location: Optional[str] = Field(
+        default=None,
+        description="For ETFs that are classified as 'China' in the 'country' field,"
+        + " this field provides further detail on the type of exposure in the underlying securities.",
+    )
+    us_state: Optional[str] = Field(
+        default=None,
+        description="Takes the value of a US state if the ETF provides"
+        + " targeted exposure to the municipal bonds or equities of companies.",
+    )
+    real_estate: Optional[str] = Field(
+        default=None,
+        description="For ETFs that provide targeted real estate exposure,"
+        + " this field is populated if the ETF provides targeted"
+        + " exposure to a specific segment of the real estate market.",
+    )
+
+    fundamental_weighting_type: Optional[str] = Field(
+        default=None,
+        description="For ETFs that take the value 'Fundamental Weighted' in the 'index_weighting_scheme' field,"
+        + " this field provides detail on the fundamental weighting methodology.",
+    )
+    dividend_weighting_type: Optional[str] = Field(
+        default=None,
+        description="For ETFs that take the value 'Dividend Weighted' in the 'index_weighting_scheme' field,"
+        + " this field provides detail on the dividend weighting methodology.",
+    )
+    bond_type: Optional[str] = Field(
+        default=None,
+        description="For ETFs where 'asset_class_type' is 'Bonds',"
+        + " this field provides detail on the type of bonds held in the ETF.",
+    )
+    government_bond_types: Optional[str] = Field(
+        default=None,
+        description="For bond ETFs that take the value 'Treasury & Government' in 'bond_type',"
+        + " this field provides detail on the exposure.",
+    )
+    municipal_bond_region: Optional[str] = Field(
+        default=None,
+        description="For bond ETFs that take the value 'Municipal' in 'bond_type',"
+        + " this field provides additional detail on the geographic exposure.",
+    )
+    municipal_vrdo: Optional[bool] = Field(
+        default=None,
+        description="For bond ETFs that take the value 'Municipal' in 'bond_type',"
+        + " this field identifies those ETFs that specifically provide exposure to Variable Rate Demand Obligations.",
+    )
+    mortgage_bond_types: Optional[str] = Field(
+        default=None,
+        description="For bond ETFs that take the value 'Mortgage' in 'bond_type',"
+        + " this field provides additional detail on the type of underlying securities.",
+    )
+    bond_tax_status: Optional[str] = Field(
+        default=None,
+        description="For all US bond ETFs, this field provides additional"
+        + " detail on the tax treatment of the underlying securities.",
+    )
+    credit_quality: Optional[str] = Field(
+        default=None,
+        description="For all bond ETFs, this field helps to identify if the ETF"
+        + " provides targeted exposure to securities of a specific credit quality range.",
+    )
+    average_maturity: Optional[str] = Field(
+        default=None,
+        description="For all bond ETFs, this field helps to identify if the ETF"
+        + " provides targeted exposure to securities of a specific maturity range.",
+    )
+    specific_maturity_year: Optional[int] = Field(
+        default=None,
+        description="For all bond ETFs that take the value 'Specific Maturity Year' in the 'average_maturity' field,"
+        + " this field specifies the calendar year.",
+    )
+    commodity_types: Optional[str] = Field(
+        default=None,
+        description="For ETFs where 'asset_class_type' is 'Commodities',"
+        + " this field provides detail on the type of commodities held in the ETF.",
+    )
+    energy_type: Optional[str] = Field(
+        default=None,
+        description="For ETFs where 'commodity_type' is 'Energy',"
+        + " this field provides detail on the type of energy exposure provided by the ETF.",
+    )
+    agricultural_type: Optional[str] = Field(
+        default=None,
+        description="For ETFs where 'commodity_type' is 'Agricultural',"
+        + " this field provides detail on the type of agricultural exposure provided by the ETF.",
+    )
+    livestock_type: Optional[str] = Field(
+        default=None,
+        description="For ETFs where 'commodity_type' is 'Livestock',"
+        + " this field provides detail on the type of livestock exposure provided by the ETF.",
+    )
+    metal_type: Optional[str] = Field(
+        default=None,
+        description="For ETFs where 'commodity_type' is 'Gold & Metals',"
+        + " this field provides detail on the type of exposure provided by the ETF.",
+    )
+    inverse_leveraged: Optional[str] = Field(
+        default=None,
+        description="This field is populated if the ETF provides inverse or leveraged exposure.",
+    )
+    target_date_multi_asset_type: Optional[str] = Field(
+        default=None,
+        description="For ETFs where 'asset_class_type' is 'Target Date / MultiAsset',"
+        + " this field provides detail on the type of commodities held in the ETF.",
+    )
+    currency_pair: Optional[str] = Field(
+        default=None,
+        description="This field is populated if the ETF's strategy involves providing exposure to"
+        + " the movements of a currency or involves hedging currency exposure.",
+    )
+    social_environmental_type: Optional[str] = Field(
+        default=None,
+        description="This field is populated if the ETF's strategy involves providing"
+        + " exposure to a specific social or environmental theme.",
+    )
+    clean_energy_type: Optional[str] = Field(
+        default=None,
+        description="This field is populated if the ETF has a value of 'Clean Energy'"
+        + " in the 'social_environmental_type' field.",
+    )
+    dividend_type: Optional[str] = Field(
+        default=None,
+        description="This field is populated if the ETF has an intended"
+        + " investment objective of holding dividend-oriented stocks as stated in the prospectus.",
+    )
+    regular_dividend_payor_type: Optional[str] = Field(
+        default=None,
+        description="This field is populated if the ETF has a value of"
+        + "'Dividend - Regular Payors' in the 'dividend_type' field.",
+    )
+    quant_strategies_type: Optional[str] = Field(
+        default=None,
+        description="This field is populated if the ETF has either an index-linked"
+        + " or active strategy that is based on a proprietary quantitative strategy.",
+    )
+    other_quant_models: Optional[str] = Field(
+        default=None,
+        description="For ETFs where 'quant_strategies_type' is 'Other Quant Model',"
+        + " this field provides the name of the specific proprietary quant model"
+        + " used as the underlying strategy for the ETF.",
+    )
+    hedge_fund_type: Optional[str] = Field(
+        default=None,
+        description="For ETFs where 'other_asset_types' is 'Hedge Fund Replication',"
+        + " this field provides detail on the type of hedge fund replication strategy.",
+    )
+    excludes_financials: Optional[bool] = Field(
+        default=None,
+        description="For equity ETFs, identifies those ETFs"
+        + " where the underlying fund holdings will not hold financials stocks,"
+        + " based on the funds intended objective.",
+    )
+    excludes_technology: Optional[bool] = Field(
+        default=None,
+        description="For equity ETFs, identifies those ETFs"
+        + " where the underlying fund holdings will not hold technology stocks,"
+        + " based on the funds intended objective.",
+    )
+    holds_only_nyse_stocks: Optional[bool] = Field(
+        default=None,
+        description="If true, the ETF is an equity ETF and holds only stocks listed on NYSE.",
+    )
+    holds_only_nasdaq_stocks: Optional[bool] = Field(
+        default=None,
+        description="If true, the ETF is an equity ETF and holds only stocks listed on Nasdaq.",
+    )
+    holds_mlp: Optional[bool] = Field(
+        default=None,
+        description="If true, the ETF's investment objective explicitly specifies"
+        + " that it holds MLPs as an intended part of its investment strategy.",
+    )
+    holds_preferred_stock: Optional[bool] = Field(
+        default=None,
+        description="If true, the ETF's investment objective explicitly specifies"
+        + " that it holds preferred stock as an intended part of its investment strategy.",
+    )
+    holds_closed_end_funds: Optional[bool] = Field(
+        default=None,
+        description="If true, the ETF's investment objective explicitly specifies"
+        + " that it holds closed end funds as an intended part of its investment strategy.",
+    )
+    holds_adr: Optional[bool] = Field(
+        default=None,
+        description="If true, he ETF's investment objective explicitly specifies that it holds"
+        + " American Depositary Receipts (ADRs) as an intended part of its investment strategy.",
+    )
+    laddered: Optional[bool] = Field(
+        default=None,
+        description="For bond ETFs, this field identifies those ETFs that"
+        + " specifically hold bonds in a laddered structure,"
+        + " where the bonds are scheduled to mature in an annual, sequential structure.",
+    )
+    zero_coupon: Optional[bool] = Field(
+        default=None,
+        description="For bond ETFs, this field identifies those ETFs that specifically hold zero coupon Treasury Bills.",
+    )
+    floating_rate: Optional[bool] = Field(
+        default=None,
+        description="For bond ETFs, this field identifies those ETFs that specifically hold floating rate bonds.",
+    )
+    build_america_bonds: Optional[bool] = Field(
+        default=None,
+        description="For municipal bond ETFs, this field identifies those"
+        + " ETFs that specifically hold Build America Bonds.",
+    )
+    dynamic_futures_roll: Optional[bool] = Field(
+        default=None,
+        description="If the product holds futures contracts, this field identifies those products where the roll strategy"
+        + " is dynamic (rather than entirely rules based), so as to minimize roll costs.",
+    )
+    currency_hedged: Optional[bool] = Field(
+        default=None,
+        description="This field is populated if the ETF's strategy involves hedging currency exposure.",
+    )
+    includes_short_exposure: Optional[bool] = Field(
+        default=None,
+        description="This field is populated if the ETF has short exposure"
+        + " in any of its holdings e.g. in a long/short or inverse ETF.",
+    )
+    ucits: Optional[bool] = Field(
+        default=None,
+        description="If true, the Exchange Traded Product (ETP) is Undertakings for the Collective Investment"
+        + " in Transferable Securities (UCITS) compliant",
+    )
+    registered_countries: Optional[str] = Field(
+        default=None,
+        description="The list of countries where the ETF is legally registered for sale."
+        + " This may differ from where the ETF is domiciled or traded, particularly in Europe.",
+    )
+    issuer_country: Optional[str] = Field(
+        default=None,
+        description="2 letter ISO country code for the country where the issuer is located.",
+    )
+    domicile: Optional[str] = Field(
+        default=None,
+        description="2 letter ISO country code for the country where the ETP is domiciled.",
+    )
+    listing_country: Optional[str] = Field(
+        default=None,
+        description="2 letter ISO country code for the country of the primary listing.",
+        alias="listing_country_code",
+    )
+    listing_region: Optional[str] = Field(
+        default=None,
+        description="Geographic region in the country of the primary listing falls.",
+    )
+    bond_currency_denomination: Optional[str] = Field(
+        default=None,
+        description="For all bond ETFs, this field provides additional"
+        + " detail on the currency denomination of the underlying securities.",
+    )
+    base_currency: Optional[str] = Field(
+        default=None,
+        description="Base currency in which NAV is reported.",
+    )
+    listing_currency: Optional[str] = Field(
+        default=None,
+        description="Listing currency of the Exchange Traded Product (ETP) in which it is traded."
+        + " Reported using the 3-digit ISO currency code.",
+    )
+    number_of_holdings: Optional[int] = Field(
+        default=None,
+        description="The number of holdings in the ETF.",
+    )
+    month_end_assets: Optional[float] = Field(
+        default=None,
+        description="Net assets in millions of dollars as of the most recent month end.",
+    )
+    net_expense_ratio: Optional[float] = Field(
+        default=None,
+        description="Gross expense net of Fee Waivers, as a percentage of net assets"
+        + " as published by the ETF issuer.",
+        json_schema_extra={"x-unit_measurement": "percent", "x-frontend_multiply": 100},
+    )
+    etf_portfolio_turnover: Optional[float] = Field(
+        default=None,
+        description="The percentage of positions turned over in the last 12 months.",
+        json_schema_extra={"x-unit_measurement": "percent", "x-frontend_multiply": 100},
+    )
+
+
+class IntrinioEtfInfoFetcher(
+    Fetcher[IntrinioEtfInfoQueryParams, List[IntrinioEtfInfoData]]
+):
+    """Intrinio ETF Info Fetcher."""
+
+    @staticmethod
+    def transform_query(params: Dict[str, Any]) -> IntrinioEtfInfoQueryParams:
+        """Transform query."""
+        return IntrinioEtfInfoQueryParams(**params)
+
+    @staticmethod
+    async def aextract_data(
+        query: IntrinioEtfInfoQueryParams,
+        credentials: Optional[Dict[str, str]],
+        **kwargs: Any,
+    ) -> List[Dict]:
+        """Return the raw data from the Intrinio endpoint."""
+
+        api_key = credentials.get("intrinio_api_key") if credentials else ""
+        base_url = "https://api-v2.intrinio.com/etfs/"
+        symbols = query.symbol.split(",")
+        symbols = [
+            symbol + ":US" if ":" not in symbol else symbol for symbol in symbols
+        ]
+        urls = [f"{base_url}{symbol}?api_key={api_key}" for symbol in symbols]
+
+        results = []
+
+        async def response_callback(response, _):
+            """Response callback."""
+            result = await response.json()
+            if "error" in result:
+                warn(f"Symbol Error: {result['error']} for {response.url.parts[-1]}")
+                return
+            _ = result.pop("messages", None)
+            results.append(result)
+
+        await amake_requests(urls, response_callback, **kwargs)  # type: ignore
+
+        if not results:
+            raise EmptyDataError("No data was returned.")
+
+        return sorted(
+            results,
+            key=(lambda item: (symbols.index(item.get("figi_ticker", len(symbols))))),
+        )
+
+    @staticmethod
+    def transform_data(
+        query: IntrinioEtfInfoQueryParams,
+        data: List[Dict],
+        **kwargs: Any,
+    ) -> List[IntrinioEtfInfoData]:
+        """Transform data."""
+        return [IntrinioEtfInfoData.model_validate(d) for d in data]

openbb_platform/providers/intrinio/openbb_intrinio/models/etf_price_performance.py

@@ -0,0 +1,227 @@
+"""Intrinio ETF Performance Model."""
+
+# pylint: disable=unused-argument
+
+import asyncio
+from datetime import date as dateType
+from typing import Any, Dict, List, Literal, Optional
+from warnings import warn
+
+from openbb_core.provider.abstract.fetcher import Fetcher
+from openbb_core.provider.standard_models.recent_performance import (
+    RecentPerformanceData,
+    RecentPerformanceQueryParams,
+)
+from openbb_core.provider.utils.descriptions import DATA_DESCRIPTIONS
+from openbb_core.provider.utils.errors import EmptyDataError
+from openbb_core.provider.utils.helpers import amake_request
+from openbb_intrinio.utils.references import ETF_PERFORMANCE_MAP
+from pydantic import Field
+
+
+class IntrinioEtfPricePerformanceQueryParams(RecentPerformanceQueryParams):
+    """
+    Intrinio ETF Performance Query Params.
+
+    Source: https://docs.intrinio.com/documentation/web_api/get_etf_stats_v2
+    Source: https://docs.intrinio.com/documentation/web_api/get_etf_analytics_v2
+    """
+
+    __json_schema_extra__ = {"symbol": {"multiple_items_allowed": True}}
+
+    return_type: Literal["trailing", "calendar"] = Field(
+        default="trailing",
+        description="The type of returns to return, a trailing or calendar window.",
+    )
+    adjustment: Literal["splits_only", "splits_and_dividends"] = Field(
+        default="splits_and_dividends",
+        description="The adjustment factor, 'splits_only' will return pure price performance.",
+    )
+
+
+class IntrinioEtfPricePerformanceData(RecentPerformanceData):
+    """Intrinio ETF Performance Data."""
+
+    __alias_dict__ = {
+        "updated": "date",
+        "year_high": "fifty_two_week_high",
+        "year_low": "fifty_two_week_low",
+        "volume": "volume_traded",
+        "volume_avg_30": "average_daily_volume_one_month",
+        "volume_avg_90": "average_daily_volume_three_month",
+        "volume_avg_180": "average_daily_volume_six_month",
+    }
+
+    max_annualized: Optional[float] = Field(
+        default=None,
+        description="Annualized rate of return from inception.",
+        json_schema_extra={"x-unit_measurement": "percent", "x-frontend_multiply": 100},
+    )
+    volatility_one_year: Optional[float] = Field(
+        default=None,
+        description="Trailing one-year annualized volatility.",
+        json_schema_extra={"x-unit_measurement": "percent", "x-frontend_multiply": 100},
+    )
+    volatility_three_year: Optional[float] = Field(
+        default=None,
+        description="Trailing three-year annualized volatility.",
+        json_schema_extra={"x-unit_measurement": "percent", "x-frontend_multiply": 100},
+    )
+    volatility_five_year: Optional[float] = Field(
+        default=None,
+        description="Trailing five-year annualized volatility.",
+        json_schema_extra={"x-unit_measurement": "percent", "x-frontend_multiply": 100},
+    )
+    volume: Optional[int] = Field(
+        default=None,
+        description=DATA_DESCRIPTIONS.get("volume", ""),
+    )
+    volume_avg_30: Optional[float] = Field(
+        default=None,
+        description="The one-month average daily volume.",
+    )
+    volume_avg_90: Optional[float] = Field(
+        default=None,
+        description="The three-month average daily volume.",
+    )
+    volume_avg_180: Optional[float] = Field(
+        default=None,
+        description="The six-month average daily volume.",
+    )
+    beta: Optional[float] = Field(
+        default=None,
+        description="Beta compared to the S&P 500.",
+    )
+    nav: Optional[float] = Field(
+        default=None,
+        description="Net asset value per share.",
+    )
+    year_high: Optional[float] = Field(
+        default=None,
+        description="The 52-week high price.",
+    )
+    year_low: Optional[float] = Field(
+        default=None,
+        description="The 52-week low price.",
+    )
+
+    market_cap: Optional[float] = Field(
+        default=None,
+        description="The market capitalization.",
+    )
+    shares_outstanding: Optional[int] = Field(
+        default=None,
+        description="The number of shares outstanding.",
+    )
+    updated: Optional[dateType] = Field(
+        default=None,
+        description=DATA_DESCRIPTIONS.get("date", ""),
+    )
+
+
+class IntrinioEtfPricePerformanceFetcher(
+    Fetcher[
+        IntrinioEtfPricePerformanceQueryParams, List[IntrinioEtfPricePerformanceData]
+    ]
+):
+    """Intrinio ETF Performance Fetcher."""
+
+    @staticmethod
+    def transform_query(
+        params: Dict[str, Any]
+    ) -> IntrinioEtfPricePerformanceQueryParams:
+        """Transform query."""
+        return IntrinioEtfPricePerformanceQueryParams(**params)
+
+    @staticmethod
+    async def aextract_data(
+        query: IntrinioEtfPricePerformanceQueryParams,
+        credentials: Optional[Dict[str, str]],
+        **kwargs: Any,
+    ) -> List[Dict]:
+        """Return the raw data from the Intrinio endpoint."""
+
+        api_key = credentials.get("intrinio_api_key") if credentials else ""
+        base_url = "https://api-v2.intrinio.com/etfs/"
+        symbols = query.symbol.split(",")
+        symbols = [
+            symbol + ":US" if ":" not in symbol else symbol for symbol in symbols
+        ]
+
+        adjustment = (
+            "split_only"
+            if query.adjustment == "splits_and_dividends"
+            else "split_and_dividend"
+        )
+
+        return_type = "trailing" if query.return_type == "calendar" else "calendar"
+
+        results = []
+
+        async def get_one(symbol: str, **kwargs):
+            """Get data for one symbol."""
+
+            url = f"{base_url}{symbol}/stats?api_key={api_key}"
+            result = await amake_request(url, **kwargs)
+
+            if "message" in result and result["message"] != []:  # type: ignore
+                warn(f"Symbol Error: {symbol} - {result['message']}")  # type: ignore
+                return
+            _ = result.pop("message", None)  # type: ignore
+            _ = result.pop("messages", None)  # type: ignore
+
+            data = {}
+            etf = result.pop("etf", {})  # type: ignore
+            data["symbol"] = etf.get("ticker")
+            # These items will be kept regardless of the adjustment and return_type.
+            keep = ["volatility", "month", "year_to_date"]
+            for k, v in result.copy().items():  # type: ignore
+                if not any(substring in k for substring in keep):
+                    _ = result.pop(k, None) if adjustment in k else None  # type: ignore
+                    _ = result.pop(k, None) if return_type in k else None  # type: ignore
+                if k in result:
+                    data[ETF_PERFORMANCE_MAP.get(k, k)] = v
+            # Get an additional set of data to combine with the first set.
+            analytics_url = (
+                f"https://api-v2.intrinio.com/etfs/{symbol}/analytics?api_key={api_key}"
+            )
+            if data:
+                analytics = await amake_request(analytics_url, **kwargs)
+                if "messages" in analytics and analytics["messages"] != []:  # type: ignore
+                    warn(
+                        f"Symbol Error: {analytics['messages']}"  # type: ignore
+                        + f"for {etf.get('ticker')}"  # type: ignore
+                    )
+                    return
+                # Remove the duplicate data from the analytics response.
+                _ = analytics.pop("messages", None)  # type: ignore
+                _ = analytics.pop("etf", None)  # type: ignore
+                _ = analytics.pop("date", None)  # type: ignore
+
+                data.update(analytics)  # type: ignore
+
+            results.append(data)
+
+        tasks = [get_one(symbol, **kwargs) for symbol in symbols]
+
+        await asyncio.gather(*tasks)
+
+        if not results:
+            raise EmptyDataError("No data was returned.")
+
+        # Undo any formatting changes made to the symbols before sorting.
+        symbols = query.symbol.replace(":US", "").split(",")
+
+        return sorted(
+            results,
+            key=(lambda item: (symbols.index(item.get("symbol", len(symbols))))),
+        )
+
+    @staticmethod
+    def transform_data(
+        query: IntrinioEtfPricePerformanceQueryParams,
+        data: List[Dict],
+        **kwargs: Any,
+    ) -> List[IntrinioEtfPricePerformanceData]:
+        """Transform data."""
+        return [IntrinioEtfPricePerformanceData.model_validate(d) for d in data]

openbb_platform/providers/intrinio/openbb_intrinio/models/etf_search.py

@@ -0,0 +1,148 @@
+"""Intrinio ETF Search Model."""
+
+# pylint: disable=unused-argument
+
+from typing import Any, Dict, List, Optional, Union
+
+from openbb_core.app.model.abstract.error import OpenBBError
+from openbb_core.provider.abstract.fetcher import Fetcher
+from openbb_core.provider.standard_models.etf_search import (
+    EtfSearchData,
+    EtfSearchQueryParams,
+)
+from openbb_core.provider.utils.errors import EmptyDataError
+from openbb_intrinio.utils.references import ETF_EXCHANGES
+from pydantic import Field
+
+
+class IntrinioEtfSearchQueryParams(EtfSearchQueryParams):
+    """
+    Intrinio ETF Search Query Params.
+
+    Source: https://docs.intrinio.com/documentation/web_api/search_etfs_v2
+    """
+
+    exchange: Union[None, ETF_EXCHANGES] = Field(
+        default=None,
+        description="Target a specific exchange by providing the MIC code.",
+    )
+
+
+class IntrinioEtfSearchData(EtfSearchData):
+    """Intrinio ETF Search Data."""
+
+    __alias_dict__ = {
+        "intrinio_id": "id",
+        "symbol": "ticker",
+        "exchange": "exchange_mic",
+    }
+
+    exchange: Optional[str] = Field(
+        default=None,
+        description="The exchange MIC code.",
+    )
+    figi_ticker: Optional[str] = Field(
+        None,
+        description="The OpenFIGI ticker.",
+    )
+    ric: Optional[str] = Field(
+        None,
+        description="The Reuters Instrument Code.",
+    )
+    isin: Optional[str] = Field(
+        None,
+        description="The International Securities Identification Number.",
+    )
+    sedol: Optional[str] = Field(
+        None,
+        description="The Stock Exchange Daily Official List.",
+    )
+    intrinio_id: Optional[str] = Field(
+        None,
+        description="The unique Intrinio ID for the security.",
+    )
+
+
+class IntrinioEtfSearchFetcher(
+    Fetcher[IntrinioEtfSearchQueryParams, List[IntrinioEtfSearchData]]
+):
+    """Intrinio ETF Search Fetcher."""
+
+    @staticmethod
+    def transform_query(params: Dict[str, Any]) -> IntrinioEtfSearchQueryParams:
+        """Transform query."""
+        return IntrinioEtfSearchQueryParams(**params)
+
+    @staticmethod
+    async def aextract_data(
+        query: IntrinioEtfSearchQueryParams,
+        credentials: Optional[Dict[str, str]],
+        **kwargs: Any,
+    ) -> List[Dict]:
+        """Return the raw data from the Intrinio endpoint."""
+        # pylint: disable=import-outside-toplevel
+        from openbb_core.provider.utils.helpers import (
+            ClientResponse,
+            ClientSession,
+            amake_request,
+        )
+
+        api_key = credentials.get("intrinio_api_key") if credentials else ""
+        BASE = "https://api-v2.intrinio.com/etfs"
+        if query.exchange is not None:
+            url = f"{BASE}?exchange={query.exchange.upper()}&page_size=10000&api_key={api_key}"
+        elif query.query:
+            url = f"{BASE}/search?query={query.query}&page_size=10000&api_key={api_key}"
+        else:
+            url = f"{BASE}?page_size=10000&api_key={api_key}"
+
+        data: List = []
+
+        async def response_callback(response: ClientResponse, session: ClientSession):
+            """Async response callback."""
+            results = await response.json()
+
+            if results.get("messages"):  # type: ignore
+                messages = results.get("messages")  # type: ignore
+                raise OpenBBError(str(messages))
+
+            if results.get("etfs") and len(results.get("etfs")) > 0:  # type: ignore
+                data.extend(results.get("etfs"))  # type: ignore
+                while results.get("next_page"):  # type: ignore
+                    next_page = results["next_page"]  # type: ignore
+                    next_url = f"{url}&next_page={next_page}"
+                    results = await amake_request(next_url, session=session, **kwargs)
+                    if (
+                        "etfs" in results
+                        and len(results.get("etfs")) > 0  # type: ignore
+                    ):
+                        data.extend(results.get("etfs"))  # type: ignore
+            return data
+
+        return await amake_request(url, response_callback=response_callback, **kwargs)  # type: ignore
+
+    @staticmethod
+    def transform_data(
+        query: IntrinioEtfSearchQueryParams,
+        data: List[Dict],
+        **kwargs: Any,
+    ) -> List[IntrinioEtfSearchData]:
+        """Transform data."""
+        # pylint: disable=import-outside-toplevel
+        import re  # noqa
+        from pandas import DataFrame  # noqa
+
+        if not data:
+            raise EmptyDataError("No data found.")
+
+        results = DataFrame(data)
+        if query.query:
+            pattern = f".*{re.escape(query.query)}.*"
+            results = results[
+                results["name"].str.contains(pattern, case=False, regex=True)
+            ]
+
+        return [
+            IntrinioEtfSearchData.model_validate(d)
+            for d in results.to_dict(orient="records")
+        ]

openbb_platform/providers/intrinio/openbb_intrinio/models/financial_attributes.py

@@ -0,0 +1,78 @@
+"""Intrinio Financial Attributes Model."""
+
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+
+from dateutil.relativedelta import relativedelta
+from openbb_core.provider.abstract.fetcher import Fetcher
+from openbb_core.provider.standard_models.financial_attributes import (
+    FinancialAttributesData,
+    FinancialAttributesQueryParams,
+)
+from openbb_core.provider.utils.helpers import get_querystring
+from openbb_intrinio.utils.helpers import get_data_many
+
+
+class IntrinioFinancialAttributesQueryParams(FinancialAttributesQueryParams):
+    """Intrinio Financial Attributes Query."""
+
+    __alias_dict__ = {"sort": "sort_order", "limit": "page_size"}
+
+
+class IntrinioFinancialAttributesData(FinancialAttributesData):
+    """Intrinio Financial Attributes Data."""
+
+
+class IntrinioFinancialAttributesFetcher(
+    Fetcher[
+        IntrinioFinancialAttributesQueryParams,
+        List[IntrinioFinancialAttributesData],
+    ]
+):
+    """Transform the query, extract and transform the data from the Intrinio endpoints."""
+
+    @staticmethod
+    def transform_query(
+        params: Dict[str, Any]
+    ) -> IntrinioFinancialAttributesQueryParams:
+        """Transform the query params."""
+        transformed_params = params
+
+        now = datetime.now().date()
+        if params.get("start_date") is None:
+            transformed_params["start_date"] = now - relativedelta(years=5)
+
+        if params.get("end_date") is None:
+            transformed_params["end_date"] = now
+
+        return IntrinioFinancialAttributesQueryParams(**transformed_params)
+
+    @staticmethod
+    async def aextract_data(
+        query: IntrinioFinancialAttributesQueryParams,  # pylint: disable=unused-argument
+        credentials: Optional[Dict[str, str]],
+        **kwargs: Any,
+    ) -> List[Dict]:
+        """Return the raw data from the Intrinio endpoint."""
+        api_key = credentials.get("intrinio_api_key") if credentials else ""
+        frequency = "yearly" if query.period == "annual" else "quarterly"
+        data: List[Dict] = []
+
+        base_url = "https://api-v2.intrinio.com"
+        query_str = get_querystring(query.model_dump(by_alias=True), ["frequency"])
+        query_str = f"{query_str}&frequency={frequency}"
+
+        url = f"{base_url}/historical_data/{query.symbol}/{query.tag}?{query_str}&api_key={api_key}"
+        # data = get_data_one(url).get("historical_data", [])
+        data = await get_data_many(url, "historical_data")
+
+        return data
+
+    @staticmethod
+    def transform_data(
+        query: IntrinioFinancialAttributesQueryParams,
+        data: List[Dict],
+        **kwargs: Any,
+    ) -> List[IntrinioFinancialAttributesData]:
+        """Return the transformed data."""
+        return [IntrinioFinancialAttributesData.model_validate(item) for item in data]

openbb_platform/providers/intrinio/openbb_intrinio/models/financial_ratios.py

@@ -0,0 +1,320 @@
+"""Intrinio Financial Ratios Model."""
+
+from typing import Any, Dict, List, Literal, Optional
+from warnings import warn
+
+from openbb_core.app.model.abstract.error import OpenBBError
+from openbb_core.provider.abstract.fetcher import Fetcher
+from openbb_core.provider.standard_models.financial_ratios import (
+    FinancialRatiosData,
+    FinancialRatiosQueryParams,
+)
+from openbb_core.provider.utils.descriptions import QUERY_DESCRIPTIONS
+from openbb_core.provider.utils.helpers import ClientResponse, amake_requests
+from openbb_intrinio.utils.helpers import get_data_one
+from pydantic import Field, field_validator
+
+
+class IntrinioFinancialRatiosQueryParams(FinancialRatiosQueryParams):
+    """Intrinio Financial Ratios Query.
+
+    Source: https://docs.intrinio.com/documentation/web_api/get_company_fundamentals_v2
+    Source: https://docs.intrinio.com/documentation/web_api/get_fundamental_standardized_financials_v2
+    """
+
+    __json_schema_extra__ = {
+        "period": {
+            "choices": ["annual", "quarter", "ttm", "ytd"],
+        }
+    }
+    period: Literal["annual", "quarter", "ttm", "ytd"] = Field(
+        default="annual",
+        description=QUERY_DESCRIPTIONS.get("period", ""),
+    )
+    fiscal_year: Optional[int] = Field(
+        default=None,
+        description="The specific fiscal year.  Reports do not go beyond 2008.",
+    )
+
+    @field_validator("symbol", mode="after", check_fields=False)
+    @classmethod
+    def handle_symbol(cls, v) -> str:
+        """Handle symbols with a dash and replace it with a dot for Intrinio."""
+        return v.replace("-", ".")
+
+
+class IntrinioFinancialRatiosData(FinancialRatiosData):
+    """Intrinio Financial Ratios Data."""
+
+    __alias_dict__ = {
+        "net_operating_profit_after_tax_margin": "nopatmargin",
+        "invested_capital_turnover": "investedcapitalturnover",
+        "book_value_per_share": "bookvaluepershare",
+        "tangible_book_value": "tangiblebookvaluepershare",
+        "price_to_book_ratio": "pricetobook",
+        "price_to_tangible_book_ratio": "pricetotangiblebook",
+        "price_to_revenue": "pricetorevenue",
+        "price_to_earnings": "pricetoearnings",
+        "dividend_yield": "dividendyield",
+        "earnings_yield": "earningsyield",
+        "ev_to_invested_capital": "evtoinvestedcapital",
+        "ev_to_sales": "evtorevenue",
+        "ev_to_ebitda": "evtoebitda",
+        "ev_to_ebit": "evtoebit",
+        "ev_to_nopat": "evtonopat",
+        "ev_to_operating_cash_flow": "evtoocf",
+        "ev_to_free_cash_flow": "evtofcff",
+        "gross_margin": "grossmargin",
+        "ebitda_margin": "ebitdamargin",
+        "operating_margin": "operatingmargin",
+        "ebit_margin": "ebitmargin",
+        "net_profit_margin": "profitmargin",
+        "cost_of_rev_to_revenue": "costofrevtorevenue",
+        "sga_expense_to_revenue": "sgaextorevenue",
+        "rd_expense_to_revenue": "rdextorevenue",
+        "op_expense_to_revenue": "opextorevenue",
+        "tax_burden_percent": "taxburdenpct",
+        "interest_burden_percent": "interestburdenpct",
+        "effective_tax_rate": "efftaxrate",
+        "asset_turnover": "assetturnover",
+        "receivables_turnover": "arturnover",
+        "inventory_turnover": "invturnover",
+        "fixed_asset_turnover": "faturnover",
+        "payables_turnover": "apturnover",
+        "days_of_sales_outstanding": "dso",
+        "days_of_inventory_outstanding": "dio",
+        "days_payable_outstanding": "dpo",
+        "cash_conversion_cycle": "ccc",
+        "financial_leverage": "finleverage",
+        "leverage_ratio": "leverageratio",
+        "compound_leverage_factor": "compoundleveragefactor",
+        "long_term_debt_equity_ratio": "ltdebttoequity",
+        "debt_equity_ratio": "debttoequity",
+        "return_on_invested_capital": "roic",
+        "net_non_operating_expense_percent": "nnep",
+        "roic_nnep_spread": "roicnnepspread",
+        "return_on_net_non_operating_assets": "rnnoa",
+        "return_on_equity": "roe",
+        "cash_returned_on_invested_capitals": "croic",
+        "operating_return_on_assets": "oroa",
+        "return_on_assets": "roa",
+        "non_controlling_interest_sharing_ratio": "noncontrollinginterestsharingratio",
+        "return_on_common_equity": "roce",
+        "dividend_payout_ratio": "divpayoutratio",
+        "augmented_payout_ratio": "augmentedpayoutratio",
+        "operating_cash_flow_to_capex": "ocftocapex",
+        "short_term_debt_to_capitalization": "stdebttocap",
+        "long_term_debt_to_capitalization": "ltdebttocap",
+        "debt_to_capitalization": "debttototalcapital",
+        "preferred_equity_to_capitalization": "preferredtocap",
+        "non_controlling_interests_to_capitalization": "noncontrolinttocap",
+        "equity_to_capitalization": "commontocap",
+        "debt_to_ebitda": "debttoebitda",
+        "net_debt_to_ebitda": "netdebttoebitda",
+        "long_term_debt_to_ebita": "ltdebttoebitda",
+        "debt_to_nopat": "debttonopat",
+        "net_debt_to_nopat": "netdebttonopat",
+        "long_term_debt_to_nopat": "ltdebttonopat",
+        "altman_z_score": "altmanzscore",
+        "ebit_to_interest_expense": "ebittointerestex",
+        "nopat_to_intersest_expense": "nopattointerestex",
+        "ebit_less_capex_to_interest_expense": "ebitlesscapextointerestex",
+        "nopat_less_capex_to_interest_expense": "nopatlesscapextointex",
+        "operating_cash_flow_to_interest_expense": "ocftointerestex",
+        "operating_cash_flow_less_capex_to_interest_expense": "ocflesscapextointerestex",
+        "free_cash_flow_to_interest_expense": "fcfftointerestex",
+        "current_ratio": "curratio",
+        "quick_ratio": "quickratio",
+        "debt_free_cash_free_nwc_to_revenue": "dfcfnwctorev",
+        "debt_free_nwc_to_revenue": "dfnwctorev",
+        "net_working_capital_to_revenue": "nwctorev",
+        "normalized_nopat_margin": "normalizednopatmargin",
+        "pre_tax_income_margin": "pretaxincomemargin",
+        "adjusted_basic_eps": "adjbasiceps",
+        "adjusted_diluted_eps": "adjdilutedeps",
+        "adjusted_basic_diluted_eps": "adjbasicdilutedeps",
+        "return_on_equity_simple": "roe_simple",
+    }
+
+
+class IntrinioFinancialRatiosFetcher(
+    Fetcher[
+        IntrinioFinancialRatiosQueryParams,
+        List[IntrinioFinancialRatiosData],
+    ]
+):
+    """Transform the query, extract and transform the data from the Intrinio endpoints."""
+
+    @staticmethod
+    def transform_query(params: Dict[str, Any]) -> IntrinioFinancialRatiosQueryParams:
+        """Transform the query params."""
+        return IntrinioFinancialRatiosQueryParams(**params)
+
+    @staticmethod
+    async def aextract_data(
+        query: IntrinioFinancialRatiosQueryParams,
+        credentials: Optional[Dict[str, str]],
+        **kwargs: Any,
+    ) -> List[Dict]:
+        """Return the raw data from the Intrinio endpoint."""
+        api_key = credentials.get("intrinio_api_key") if credentials else ""
+        statement_code = "calculations"
+        if query.period in ["quarter", "annual"]:
+            period_type = "FY" if query.period == "annual" else "QTR"
+        elif query.period in ["ttm", "ytd"]:
+            period_type = query.period.upper()
+        else:
+            raise OpenBBError(f"Period '{query.period}' not supported.")
+
+        fundamentals_data: Dict = {}
+
+        base_url = "https://api-v2.intrinio.com"
+        fundamentals_url = (
+            f"{base_url}/companies/{query.symbol}/fundamentals?"
+            f"statement_code={statement_code}&type={period_type}"
+        )
+        if query.fiscal_year is not None:
+            if query.fiscal_year < 2008:
+                warn("Financials data is only available from 2008 and later.")
+                query.fiscal_year = 2008
+            fundamentals_url = fundamentals_url + f"&fiscal_year={query.fiscal_year}"
+        fundamentals_url = fundamentals_url + f"&api_key={api_key}"
+        fundamentals_data = (await get_data_one(fundamentals_url, **kwargs)).get(
+            "fundamentals", []
+        )
+        ids = [item["id"] for item in fundamentals_data]
+        ids = ids[: query.limit]
+
+        async def callback(response: ClientResponse, _: Any) -> Dict:
+            """Return the response."""
+            statement_data = await response.json()
+            return {
+                "period_ending": statement_data["fundamental"]["end_date"],  # type: ignore
+                "fiscal_year": statement_data["fundamental"]["fiscal_year"],  # type: ignore
+                "fiscal_period": statement_data["fundamental"]["fiscal_period"],  # type: ignore
+                "calculations": statement_data["standardized_financials"],  # type: ignore
+            }
+
+        urls = [
+            f"https://api-v2.intrinio.com/fundamentals/{id}/standardized_financials?api_key={api_key}"
+            for id in ids
+        ]
+
+        return await amake_requests(urls, callback, **kwargs)  # type: ignore
+
+    @staticmethod
+    def transform_data(
+        query: IntrinioFinancialRatiosQueryParams, data: List[Dict], **kwargs: Any
+    ) -> List[IntrinioFinancialRatiosData]:
+        """Return the transformed data."""
+        transformed_data: List[IntrinioFinancialRatiosData] = []
+
+        tags = [
+            "nopatmargin",
+            "investedcapitalturnover",
+            "bookvaluepershare",
+            "tangiblebookvaluepershare",
+            "pricetobook",
+            "pricetotangiblebook",
+            "pricetorevenue",
+            "pricetoearnings",
+            "dividendyield",
+            "earningsyield",
+            "evtoinvestedcapital",
+            "evtorevenue",
+            "evtoebitda",
+            "evtoebit",
+            "evtonopat",
+            "evtoocf",
+            "evtofcff",
+            "grossmargin",
+            "ebitdamargin",
+            "operatingmargin",
+            "ebitmargin",
+            "profitmargin",
+            "costofrevtorevenue",
+            "sgaextorevenue",
+            "rdextorevenue",
+            "opextorevenue",
+            "taxburdenpct",
+            "interestburdenpct",
+            "efftaxrate",
+            "assetturnover",
+            "arturnover",
+            "invturnover",
+            "faturnover",
+            "apturnover",
+            "dso",
+            "dio",
+            "dpo",
+            "ccc",
+            "finleverage",
+            "leverageratio",
+            "compoundleveragefactor",
+            "ltdebttoequity",
+            "debttoequity",
+            "roic",
+            "nnep",
+            "roicnnepspread",
+            "rnnoa",
+            "roe",
+            "croic",
+            "oroa",
+            "roa",
+            "noncontrollinginterestsharingratio",
+            "roce",
+            "divpayoutratio",
+            "augmentedpayoutratio",
+            "ocftocapex",
+            "stdebttocap",
+            "ltdebttocap",
+            "debttototalcapital",
+            "preferredtocap",
+            "noncontrolinttocap",
+            "commontocap",
+            "debttoebitda",
+            "netdebttoebitda",
+            "ltdebttoebitda",
+            "debttonopat",
+            "netdebttonopat",
+            "ltdebttonopat",
+            "altmanzscore",
+            "ebittointerestex",
+            "nopattointerestex",
+            "ebitlesscapextointerestex",
+            "nopatlesscapextointex",
+            "ocftointerestex",
+            "ocflesscapextointerestex",
+            "fcfftointerestex",
+            "curratio",
+            "quickratio",
+            "dfcfnwctorev",
+            "dfnwctorev",
+            "nwctorev",
+            "normalizednopatmargin",
+            "pretaxincomemargin",
+            "adjbasiceps",
+            "adjdilutedeps",
+            "adjbasicdilutedeps",
+            "roe_simple",
+        ]
+
+        for item in data:
+            sub_dict: Dict[str, Any] = {}
+
+            for sub_item in item["calculations"]:
+                field_name = sub_item["data_tag"]["tag"]
+                if field_name in tags:
+                    sub_dict[field_name] = (
+                        float(sub_item["value"])
+                        if sub_item["value"] and sub_item["value"] != 0
+                        else None
+                    )
+
+            sub_dict["period_ending"] = item["period_ending"]
+            sub_dict["fiscal_year"] = item["fiscal_year"]
+            sub_dict["fiscal_period"] = item["fiscal_period"]
+
+            transformed_data.append(IntrinioFinancialRatiosData(**sub_dict))
+
+        return transformed_data

openbb_platform/providers/intrinio/openbb_intrinio/models/forward_ebitda_estimates.py

@@ -0,0 +1,201 @@
+"""Intrinio Forward EBITDA Estimates Model."""
+
+# pylint: disable=unused-argument
+
+import asyncio
+from typing import Any, Dict, List, Literal, Optional
+from warnings import warn
+
+from openbb_core.app.model.abstract.error import OpenBBError
+from openbb_core.provider.abstract.fetcher import Fetcher
+from openbb_core.provider.standard_models.forward_ebitda_estimates import (
+    ForwardEbitdaEstimatesData,
+    ForwardEbitdaEstimatesQueryParams,
+)
+from openbb_core.provider.utils.errors import EmptyDataError, UnauthorizedError
+from openbb_core.provider.utils.helpers import (
+    amake_request,
+    get_querystring,
+)
+from openbb_intrinio.utils.helpers import response_callback
+from pydantic import Field
+
+
+class IntrinioForwardEbitdaEstimatesQueryParams(ForwardEbitdaEstimatesQueryParams):
+    """Intrinio Forward EBITDA Estimates Query.
+
+    https://docs.intrinio.com/documentation/web_api/get_zacks_sales_estimates_v2
+    """
+
+    __json_schema_extra__ = {"symbol": {"multiple_items_allowed": True}}
+    __alias_dict__ = {"estimate_type": "type"}
+
+    fiscal_period: Optional[Literal["annual", "quarter"]] = Field(
+        default=None, description="Filter for only full-year or quarterly estimates."
+    )
+    estimate_type: Optional[
+        Literal[
+            "ebitda",
+            "ebit",
+            "enterprise_value",
+            "cash_flow_per_share",
+            "pretax_income",
+        ]
+    ] = Field(
+        default=None,
+        description="Limit the EBITDA estimates to this type.",
+    )
+
+
+class IntrinioForwardEbitdaEstimatesData(ForwardEbitdaEstimatesData):
+    """Intrinio Forward EBITDA Estimates Data."""
+
+    __alias_dict__ = {
+        "last_updated": "updated_date",
+        "symbol": "ticker",
+        "calendar_period": "estimate_month",
+        "name": "company_name",
+        "fiscal_year": "estimate_year",
+        "fiscal_period": "period",
+        "low_estimate": "low",
+        "high_estimate": "high",
+        "number_of_analysts": "estimate_count",
+        "standard_deviation": "std_dev",
+    }
+
+    conensus_type: Optional[
+        Literal[
+            "ebitda",
+            "ebitda",
+            "ebit",
+            "enterprise_value",
+            "cash_flow_per_share",
+            "pretax_income",
+        ]
+    ] = Field(
+        default=None,
+        description="The type of estimate.",
+    )
+
+
+class IntrinioForwardEbitdaEstimatesFetcher(
+    Fetcher[
+        IntrinioForwardEbitdaEstimatesQueryParams,
+        List[IntrinioForwardEbitdaEstimatesData],
+    ]
+):
+    """Intrinio Forward EBITDA Estimates Fetcher."""
+
+    @staticmethod
+    def transform_query(
+        params: Dict[str, Any]
+    ) -> IntrinioForwardEbitdaEstimatesQueryParams:
+        """Transform the query params."""
+        return IntrinioForwardEbitdaEstimatesQueryParams(**params)
+
+    @staticmethod
+    async def aextract_data(
+        query: IntrinioForwardEbitdaEstimatesQueryParams,
+        credentials: Optional[Dict[str, str]],
+        **kwargs: Any,
+    ) -> List[Dict]:
+        """Return the raw data from the Intrinio endpoint."""
+        api_key = credentials.get("intrinio_api_key") if credentials else ""
+        BASE_URL = (
+            "https://api-v2.intrinio.com/zacks/ebitda_consensus?"
+            + f"page_size=10000&api_key={api_key}"
+        )
+        symbols = query.symbol.split(",") if query.symbol else None
+        query_str = get_querystring(query.model_dump(by_alias=True), ["symbol"])
+        results: List[Dict] = []
+
+        async def get_one(symbol):
+            """Get the data for one symbol."""
+            url = f"{BASE_URL}&identifier={symbol}"
+            url = url + f"&{query_str}" if query_str else url
+            data = await amake_request(
+                url, response_callback=response_callback, **kwargs
+            )
+            consensus = (
+                data.get("ebitda_consensus")
+                if isinstance(data, dict) and "ebitda_consensus" in data
+                else []
+            )
+            if not data or not consensus:
+                warn(f"Symbol Error: No data found for {symbol}")
+            if consensus:
+                results.extend(consensus)
+
+        if symbols:
+            await asyncio.gather(*[get_one(symbol) for symbol in symbols])
+            if not results:
+                raise EmptyDataError(f"No results were found. -> {query.symbol}")
+            return results
+
+        async def fetch_callback(response, session):
+            """Use callback for pagination."""
+            data = await response.json()
+            error = data.get("error", None)
+            if error:
+                message = data.get("message", "")
+                if "api key" in message.lower():
+                    raise UnauthorizedError(
+                        f"Unauthorized Intrinio request -> {message}"
+                    )
+                raise OpenBBError(f"Error: {error} -> {message}")
+
+            estimates = data.get("ebitda_consensus", [])  # type: ignore
+            if estimates and len(estimates) > 0:
+                results.extend(estimates)
+                while data.get("next_page"):  # type: ignore
+                    next_page = data["next_page"]  # type: ignore
+                    next_url = f"{url}&next_page={next_page}"
+                    data = await amake_request(next_url, session=session, **kwargs)
+                    consensus = (
+                        data.get("ebitda_consensus")
+                        if isinstance(data, dict) and "ebitda_consensus" in data
+                        else []
+                    )
+                    if consensus:
+                        results.extend(consensus)  # type: ignore
+            return results
+
+        url = f"{BASE_URL}&{query_str}" if query_str else BASE_URL
+
+        results = await amake_request(url, response_callback=fetch_callback, **kwargs)  # type: ignore
+
+        if not results:
+            raise EmptyDataError("The request was successful but was returned empty.")
+
+        return results
+
+    @staticmethod
+    def transform_data(
+        query: IntrinioForwardEbitdaEstimatesQueryParams,
+        data: List[Dict],
+        **kwargs: Any,
+    ) -> List[IntrinioForwardEbitdaEstimatesData]:
+        """Transform the raw data into the standard format."""
+        if not data:
+            raise EmptyDataError()
+        results: List[IntrinioForwardEbitdaEstimatesData] = []
+        fiscal_period = None
+        if query.fiscal_period is not None:
+            fiscal_period = "fy" if query.fiscal_period == "annual" else "fq"
+        for item in data:
+            estimate_count = item.get("estimate_count")
+            if (
+                not estimate_count
+                or estimate_count == 0
+                or not item.get("updated_date")
+            ):
+                continue
+            if fiscal_period and item.get("period") != fiscal_period:
+                continue
+            results.append(IntrinioForwardEbitdaEstimatesData.model_validate(item))
+        if not results:
+            raise EmptyDataError()
+
+        return sorted(
+            results, key=lambda x: (x.fiscal_year, x.last_updated), reverse=True
+        )

openbb_platform/providers/intrinio/openbb_intrinio/models/forward_eps_estimates.py

@@ -0,0 +1,236 @@
+"""Intrinio Forward EPS Estimates Model."""
+
+# pylint: disable=unused-argument
+
+import asyncio
+from datetime import datetime
+from typing import Any, Dict, List, Literal, Optional, Union
+from warnings import warn
+
+from openbb_core.app.model.abstract.error import OpenBBError
+from openbb_core.provider.abstract.fetcher import Fetcher
+from openbb_core.provider.standard_models.forward_eps_estimates import (
+    ForwardEpsEstimatesData,
+    ForwardEpsEstimatesQueryParams,
+)
+from openbb_core.provider.utils.errors import EmptyDataError, UnauthorizedError
+from openbb_core.provider.utils.helpers import (
+    amake_request,
+    get_querystring,
+)
+from openbb_intrinio.utils.helpers import response_callback
+from pydantic import Field, field_validator, model_validator
+
+
+class IntrinioForwardEpsEstimatesQueryParams(ForwardEpsEstimatesQueryParams):
+    """Intrinio Forward EPS Estimates Query.
+
+    https://docs.intrinio.com/documentation/web_api/get_zacks_sales_estimates_v2
+    """
+
+    __json_schema_extra__ = {"symbol": {"multiple_items_allowed": True}}
+
+    fiscal_year: Optional[int] = Field(
+        default=None,
+        description="The future fiscal year to retrieve estimates for."
+        + " When no symbol and year is supplied the current calendar year is used.",
+    )
+    fiscal_period: Optional[Literal["fy", "q1", "q2", "q3", "q4"]] = Field(
+        default=None,
+        description="The future fiscal period to retrieve estimates for.",
+    )
+    calendar_year: Optional[int] = Field(
+        default=None,
+        description="The future calendar year to retrieve estimates for."
+        + " When no symbol and year is supplied the current calendar year is used.",
+    )
+    calendar_period: Optional[Literal["q1", "q2", "q3", "q4"]] = Field(
+        default=None,
+        description="The future calendar period to retrieve estimates for.",
+    )
+
+    @model_validator(mode="after")
+    @classmethod
+    def validate_choices(cls, values):
+        """Validate the model and set a safe default state."""
+        if values.symbol is None and (
+            values.calendar_year is None and values.fiscal_year is None
+        ):
+            values.calendar_year = datetime.now().year
+        return values
+
+
+class IntrinioForwardEpsEstimatesData(ForwardEpsEstimatesData):
+    """Intrinio Forward EPS Estimates Data."""
+
+    __alias_dict__ = {
+        "high_estimate": "high",
+        "low_estimate": "low",
+        "number_of_analysts": "count",
+        "mean": "estimated_sales_mean",
+        "revisions_change_percent": "percent_change",
+        "mean_1w": "mean_7_days_ago",
+        "mean_1m": "mean_30_days_ago",
+        "mean_2m": "mean_60_days_ago",
+        "mean_3m": "mean_90_days_ago",
+    }
+
+    revisions_change_percent: Optional[float] = Field(
+        default=None,
+        description="The earnings per share (EPS) percent change in estimate for the period.",
+        json_schema_extra={"x-unit_measurement": "percent", "x-frontend_multiply": 100},
+    )
+    mean_1w: Optional[float] = Field(
+        default=None,
+        description="The mean estimate for the period one week ago.",
+    )
+    mean_1m: Optional[float] = Field(
+        default=None,
+        description="The mean estimate for the period one month ago.",
+    )
+    mean_2m: Optional[float] = Field(
+        default=None,
+        description="The mean estimate for the period two months ago.",
+    )
+    mean_3m: Optional[float] = Field(
+        default=None,
+        description="The mean estimate for the period three months ago.",
+    )
+
+    @field_validator(
+        "revisions_change_percent",
+        mode="before",
+        check_fields=False,
+    )
+    @classmethod
+    def normalize_percent(
+        cls, v: Optional[Union[int, float]]
+    ) -> Optional[Union[int, float]]:
+        """Normalize percent values."""
+        return v / 100 if v else None
+
+
+class IntrinioForwardEpsEstimatesFetcher(
+    Fetcher[
+        IntrinioForwardEpsEstimatesQueryParams, List[IntrinioForwardEpsEstimatesData]
+    ]
+):
+    """Intrinio Forward EPS Estimates Fetcher."""
+
+    @staticmethod
+    def transform_query(
+        params: Dict[str, Any]
+    ) -> IntrinioForwardEpsEstimatesQueryParams:
+        """Transform the query params."""
+        return IntrinioForwardEpsEstimatesQueryParams(**params)
+
+    @staticmethod
+    async def aextract_data(
+        query: IntrinioForwardEpsEstimatesQueryParams,
+        credentials: Optional[Dict[str, str]],
+        **kwargs: Any,
+    ) -> List[Dict]:
+        """Return the raw data from the Intrinio endpoint."""
+        api_key = credentials.get("intrinio_api_key") if credentials else ""
+
+        BASE_URL = "https://api-v2.intrinio.com/zacks/eps_estimates?page_size=10000"
+
+        symbols = query.symbol.split(",") if query.symbol else None
+
+        query_str = get_querystring(
+            query.model_dump(by_alias=True),
+            ["symbol", "calendar_period", "fiscal_period", "limit"],
+        )
+
+        results: List[Dict] = []
+
+        async def get_one(symbol):
+            """Get the data for one symbol."""
+            url = f"{BASE_URL}&identifier={symbol}&{query_str}&api_key={api_key}"
+            new_data: List[Dict] = []
+            data = await amake_request(
+                url, response_callback=response_callback, **kwargs
+            )
+            if not data or not isinstance(data, dict) or not data.get("estimates"):
+                warn(f"Symbol Error: No data found for {symbol}")
+            if isinstance(data, dict) and data.get("estimates"):
+                new_data = data.get("estimates")  # type: ignore
+                if new_data:
+                    results.extend(new_data)
+
+        if symbols:
+            await asyncio.gather(*[get_one(symbol) for symbol in symbols])
+            return results
+
+        async def fetch_callback(response, session):
+            """Use callback for pagination."""
+            data = await response.json()
+            error = data.get("error", None)
+            if error:
+                message = data.get("message", "")
+                if "api key" in message.lower():
+                    raise UnauthorizedError(
+                        f"Unauthorized Intrinio request -> {message}"
+                    )
+                raise OpenBBError(f"Error: {error} -> {message}")
+
+            if data.get("estimates") and len(data.get("estimates")) > 0:  # type: ignore
+                results.extend(data.get("estimates"))  # type: ignore
+                while data.get("next_page"):  # type: ignore
+                    next_page = data["next_page"]  # type: ignore
+                    next_url = f"{url}&next_page={next_page}"
+                    data = await amake_request(next_url, session=session, **kwargs)
+                    if (
+                        "estimates" in data
+                        and len(data.get("estimates")) > 0  # type: ignore
+                    ):
+                        results.extend(data.get("estimates"))  # type: ignore
+            return results
+
+        url = f"{BASE_URL}&{query_str}&api_key={api_key}"
+
+        results = await amake_request(url, response_callback=fetch_callback, **kwargs)  # type: ignore
+
+        if not results:
+            raise EmptyDataError("The request was successful but was returned empty.")
+
+        return results
+
+    @staticmethod
+    def transform_data(
+        query: IntrinioForwardEpsEstimatesQueryParams,
+        data: List[Dict],
+        **kwargs: Any,
+    ) -> List[IntrinioForwardEpsEstimatesData]:
+        """Transform the raw data into the standard format."""
+        symbols = query.symbol.split(",") if query.symbol else []
+        results: List[IntrinioForwardEpsEstimatesData] = []
+        for item in sorted(
+            data,
+            key=lambda item: (  # type: ignore
+                (
+                    symbols.index(item.get("symbol")) if item.get("symbol") in symbols else len(symbols),  # type: ignore
+                    item.get("date"),
+                )
+                if symbols
+                else item.get("date")
+            ),
+        ):
+            temp: Dict[str, Any] = {}
+            company = item.pop("company")
+            if company.get("ticker") is None:
+                continue
+            temp["symbol"] = company.get("ticker")
+            temp["name"] = company.get("name")
+            if query.fiscal_period and query.fiscal_period.upper() != item.get(
+                "fiscal_period"
+            ):
+                continue
+            if query.calendar_period and query.calendar_period.upper() != item.get(
+                "calendar_period"
+            ):
+                continue
+            temp.update(item)
+            results.append(IntrinioForwardEpsEstimatesData.model_validate(temp))
+
+        return results

openbb_platform/providers/intrinio/openbb_intrinio/models/forward_pe_estimates.py

@@ -0,0 +1,165 @@
+"""Intrinio Forward PE Estimates Model."""
+
+# pylint: disable=unused-argument
+
+from datetime import date as dateType
+from typing import Any, Optional
+
+from openbb_core.app.model.abstract.error import OpenBBError
+from openbb_core.provider.abstract.fetcher import Fetcher
+from openbb_core.provider.standard_models.forward_pe_estimates import (
+    ForwardPeEstimatesData,
+    ForwardPeEstimatesQueryParams,
+)
+from pydantic import Field
+
+
+class IntrinioForwardPeEstimatesQueryParams(ForwardPeEstimatesQueryParams):
+    """Intrinio Forward PE Estimates Query.
+
+    https://api-v2.intrinio.com/zacks/forward_pe?
+    """
+
+    __json_schema_extra__ = {"symbol": {"multiple_items_allowed": True}}
+
+
+class IntrinioForwardPeEstimatesData(ForwardPeEstimatesData):
+    """Intrinio Forward PE Estimates Data."""
+
+    __alias_dict__ = {
+        "symbol": "ticker",
+        "name": "company_name",
+        "year1": "forward_pe_year1",
+        "year2": "forward_pe_year2",
+        "year3": "forward_pe_year3",
+        "year4": "forward_pe_year4",
+        "year5": "forward_pe_year5",
+        "peg_ratio_year1": "forward_peg_ratio_year1",
+        "eps_ttm": "latest_ttm_eps",
+        "last_updated": "updated_date",
+    }
+
+    peg_ratio_year1: Optional[float] = Field(
+        default=None,
+        description="Estimated Forward PEG ratio for the next fiscal year.",
+    )
+    eps_ttm: Optional[float] = Field(
+        default=None,
+        description="The latest trailing twelve months earnings per share.",
+    )
+    last_updated: Optional[dateType] = Field(
+        default=None,
+        description="The date the data was last updated.",
+    )
+
+
+class IntrinioForwardPeEstimatesFetcher(
+    Fetcher[IntrinioForwardPeEstimatesQueryParams, list[IntrinioForwardPeEstimatesData]]
+):
+    """Intrinio Forward PE Estimates Fetcher."""
+
+    @staticmethod
+    def transform_query(
+        params: dict[str, Any],
+    ) -> IntrinioForwardPeEstimatesQueryParams:
+        """Transform the query params."""
+        return IntrinioForwardPeEstimatesQueryParams(**params)
+
+    @staticmethod
+    async def aextract_data(
+        query: IntrinioForwardPeEstimatesQueryParams,
+        credentials: Optional[dict[str, str]],
+        **kwargs: Any,
+    ) -> list[dict]:
+        """Return the raw data from the Intrinio endpoint."""
+        # pylint: disable=import-outside-toplevel
+        import asyncio  # noqa
+        from openbb_core.provider.utils.errors import EmptyDataError, UnauthorizedError
+        from openbb_core.provider.utils.helpers import amake_request
+        from openbb_intrinio.utils.helpers import response_callback
+
+        api_key = credentials.get("intrinio_api_key") if credentials else ""
+        BASE_URL = "https://api-v2.intrinio.com/zacks/forward_pe"
+        symbols = query.symbol.split(",") if query.symbol else None
+        results: list[dict] = []
+
+        async def get_one(symbol):
+            """Get the data for one symbol."""
+            url = f"{BASE_URL}/{symbol}?api_key={api_key}"
+            try:
+                data = await amake_request(
+                    url, response_callback=response_callback, **kwargs
+                )
+            except Exception as e:
+                raise OpenBBError(e) from e
+
+            if data:
+                results.append(data)  # type: ignore
+
+        if symbols:
+            try:
+                gather_results = await asyncio.gather(
+                    *[get_one(symbol) for symbol in symbols], return_exceptions=True
+                )
+
+                for result in gather_results:
+                    if isinstance(result, UnauthorizedError):
+                        raise result
+                    if isinstance(result, OpenBBError):
+                        raise result
+
+                if not results:
+                    raise EmptyDataError(
+                        f"There were no results found for any of the given symbols. -> {symbols}"
+                    )
+                return results
+            except Exception as e:
+                raise OpenBBError(
+                    f"Error in Intrinio request -> {e} -> {symbols}"
+                ) from e
+
+        async def fetch_callback(response, session):
+            """Use callback for pagination."""
+            data = await response.json()
+            error = data.get("error", None)
+
+            if error:
+                message = data.get("message", "")
+                if "api key" in message.lower() or "view this data" in error.lower():
+                    raise UnauthorizedError(
+                        f"Unauthorized Intrinio request -> {message} -> {error}"
+                    )
+                raise OpenBBError(f"Error: {error} -> {message}")
+
+            forward_pe = data.get("forward_pe")
+
+            if forward_pe and len(forward_pe) > 0:  # type: ignore
+                results.extend(forward_pe)  # type: ignore
+
+            return results
+
+        url = f"{BASE_URL}?page_size=10000&api_key={api_key}"
+        results = await amake_request(url, response_callback=fetch_callback, **kwargs)  # type: ignore
+
+        if not results:
+            raise EmptyDataError("The request was successful but was returned empty.")
+
+        return results
+
+    @staticmethod
+    def transform_data(
+        query: IntrinioForwardPeEstimatesQueryParams,
+        data: list[dict],
+        **kwargs: Any,
+    ) -> list[IntrinioForwardPeEstimatesData]:
+        """Transform the raw data into the standard format."""
+        symbols = query.symbol.split(",") if query.symbol else []
+        if symbols:
+            data.sort(
+                key=lambda item: (
+                    symbols.index(item.get("ticker"))  # type: ignore
+                    if item.get("ticker") in symbols
+                    else len(symbols)
+                )
+            )
+        return [IntrinioForwardPeEstimatesData.model_validate(d) for d in data]

openbb_platform/providers/intrinio/openbb_intrinio/models/forward_sales_estimates.py

@@ -0,0 +1,254 @@
+"""Intrinio Forward Sales Estimates Model."""
+
+# pylint: disable=unused-argument
+
+import asyncio
+from datetime import datetime
+from typing import Any, Dict, List, Literal, Optional, Union
+from warnings import warn
+
+from openbb_core.app.model.abstract.error import OpenBBError
+from openbb_core.provider.abstract.fetcher import Fetcher
+from openbb_core.provider.standard_models.forward_sales_estimates import (
+    ForwardSalesEstimatesData,
+    ForwardSalesEstimatesQueryParams,
+)
+from openbb_core.provider.utils.errors import EmptyDataError, UnauthorizedError
+from openbb_core.provider.utils.helpers import (
+    amake_request,
+    get_querystring,
+)
+from openbb_intrinio.utils.helpers import response_callback
+from pydantic import Field, field_validator, model_validator
+
+
+class IntrinioForwardSalesEstimatesQueryParams(ForwardSalesEstimatesQueryParams):
+    """Intrinio Forward Sales Estimates Query.
+
+    https://docs.intrinio.com/documentation/web_api/get_zacks_sales_estimates_v2
+    """
+
+    __json_schema_extra__ = {"symbol": {"multiple_items_allowed": True}}
+
+    fiscal_year: Optional[int] = Field(
+        default=None,
+        description="The future fiscal year to retrieve estimates for."
+        + " When no symbol and year is supplied the current calendar year is used.",
+    )
+    fiscal_period: Optional[Literal["fy", "q1", "q2", "q3", "q4"]] = Field(
+        default=None,
+        description="The future fiscal period to retrieve estimates for.",
+    )
+    calendar_year: Optional[int] = Field(
+        default=None,
+        description="The future calendar year to retrieve estimates for."
+        + " When no symbol and year is supplied the current calendar year is used.",
+    )
+    calendar_period: Optional[Literal["q1", "q2", "q3", "q4"]] = Field(
+        default=None,
+        description="The future calendar period to retrieve estimates for.",
+    )
+
+    @model_validator(mode="after")
+    @classmethod
+    def validate_choices(cls, values):
+        """Validate the model and set a safe default state."""
+        if values.symbol is None and (
+            values.calendar_year is None and values.fiscal_year is None
+        ):
+            values.calendar_year = datetime.now().year
+        return values
+
+
+class IntrinioForwardSalesEstimatesData(ForwardSalesEstimatesData):
+    """Intrinio Forward Sales Estimates Data."""
+
+    __alias_dict__ = {
+        "low_estimate": "low",
+        "high_estimate": "high",
+        "number_of_analysts": "count",
+        "mean": "estimated_sales_mean",
+        "revisions_1w_up": "analyst_revisions_up_1w",
+        "revisions_1w_down": "analyst_revisions_down_1w",
+        "revisions_1w_change_percent": "analyst_revisions_percent_change_1w",
+        "revisions_1m_up": "analyst_revisions_up_1m",
+        "revisions_1m_down": "analyst_revisions_down_1m",
+        "revisions_1m_change_percent": "analyst_revisions_percent_change_1m",
+        "revisions_3m_up": "analyst_revisions_up_3m",
+        "revisions_3m_down": "analyst_revisions_down_3m",
+        "revisions_3m_change_percent": "analyst_revisions_percent_change_3m",
+    }
+
+    revisions_1w_up: Optional[int] = Field(
+        default=None, description="Number of revisions up in the last week."
+    )
+    revisions_1w_down: Optional[int] = Field(
+        default=None, description="Number of revisions down in the last week."
+    )
+    revisions_1w_change_percent: Optional[float] = Field(
+        default=None,
+        description="The analyst revisions percent change in estimate for the period of 1 week.",
+        json_schema_extra={"x-unit_measurement": "percent", "x-frontend_multiply": 100},
+    )
+    revisions_1m_up: Optional[int] = Field(
+        default=None, description="Number of revisions up in the last month."
+    )
+    revisions_1m_down: Optional[int] = Field(
+        default=None, description="Number of revisions down in the last month."
+    )
+    revisions_1m_change_percent: Optional[float] = Field(
+        default=None,
+        description="The analyst revisions percent change in estimate for the period of 1 month.",
+        json_schema_extra={"x-unit_measurement": "percent", "x-frontend_multiply": 100},
+    )
+    revisions_3m_up: Optional[int] = Field(
+        default=None, description="Number of revisions up in the last 3 months."
+    )
+    revisions_3m_down: Optional[int] = Field(
+        default=None, description="Number of revisions down in the last 3 months."
+    )
+    revisions_3m_change_percent: Optional[float] = Field(
+        default=None,
+        description="The analyst revisions percent change in estimate for the period of 3 months.",
+        json_schema_extra={"x-unit_measurement": "percent", "x-frontend_multiply": 100},
+    )
+
+    @field_validator(
+        "revisions_1w_change_percent",
+        "revisions_1m_change_percent",
+        "revisions_3m_change_percent",
+        mode="before",
+        check_fields=False,
+    )
+    @classmethod
+    def normalize_percent(
+        cls, v: Optional[Union[int, float]]
+    ) -> Optional[Union[int, float]]:
+        """Normalize percent values."""
+        return v / 100 if v else None
+
+
+class IntrinioForwardSalesEstimatesFetcher(
+    Fetcher[
+        IntrinioForwardSalesEstimatesQueryParams,
+        List[IntrinioForwardSalesEstimatesData],
+    ]
+):
+    """Intrinio Forward Sales Estimates Fetcher."""
+
+    @staticmethod
+    def transform_query(
+        params: Dict[str, Any]
+    ) -> IntrinioForwardSalesEstimatesQueryParams:
+        """Transform the query params."""
+        return IntrinioForwardSalesEstimatesQueryParams(**params)
+
+    @staticmethod
+    async def aextract_data(
+        query: IntrinioForwardSalesEstimatesQueryParams,
+        credentials: Optional[Dict[str, str]],
+        **kwargs: Any,
+    ) -> List[Dict]:
+        """Return the raw data from the Intrinio endpoint."""
+        api_key = credentials.get("intrinio_api_key") if credentials else ""
+
+        BASE_URL = "https://api-v2.intrinio.com/zacks/sales_estimates?page_size=10000"
+
+        symbols = query.symbol.split(",") if query.symbol else None
+
+        query_str = get_querystring(
+            query.model_dump(by_alias=True),
+            ["symbol", "calendar_period", "fiscal_period", "limit"],
+        )
+
+        results: List[Dict] = []
+
+        async def get_one(symbol):
+            """Get the data for one symbol."""
+            url = f"{BASE_URL}&identifier={symbol}&{query_str}&api_key={api_key}"
+            new_data: List[Dict] = []
+            data = await amake_request(
+                url, response_callback=response_callback, **kwargs
+            )
+            if not data or not isinstance(data, dict) or not data.get("estimates"):
+                warn(f"Symbol Error: No data found for {symbol}")
+            if isinstance(data, dict) and data.get("estimates"):
+                new_data = data.get("estimates")  # type: ignore
+                if new_data:
+                    results.extend(new_data)
+
+        if symbols:
+            await asyncio.gather(*[get_one(symbol) for symbol in symbols])
+            return results
+
+        async def fetch_callback(response, session):
+            """Use callback for pagination."""
+            data = await response.json()
+            error = data.get("error", None)
+            if error:
+                message = data.get("message", "")
+                if "api key" in message.lower():
+                    raise UnauthorizedError(
+                        f"Unauthorized Intrinio request -> {message}"
+                    )
+                raise OpenBBError(f"Error: {error} -> {message}")
+            if data.get("estimates") and len(data.get("estimates")) > 0:  # type: ignore
+                results.extend(data.get("estimates"))  # type: ignore
+                while data.get("next_page"):  # type: ignore
+                    next_page = data["next_page"]  # type: ignore
+                    next_url = f"{url}&next_page={next_page}"
+                    data = await amake_request(next_url, session=session, **kwargs)
+                    if (
+                        "estimates" in data
+                        and len(data.get("estimates")) > 0  # type: ignore
+                    ):
+                        results.extend(data.get("estimates"))  # type: ignore
+            return results
+
+        url = f"{BASE_URL}&{query_str}&api_key={api_key}"
+
+        results = await amake_request(url, response_callback=fetch_callback, **kwargs)  # type: ignore
+
+        if not results:
+            raise EmptyDataError("The request was successful but was returned empty.")
+
+        return results
+
+    @staticmethod
+    def transform_data(
+        query: IntrinioForwardSalesEstimatesQueryParams,
+        data: List[Dict],
+        **kwargs: Any,
+    ) -> List[IntrinioForwardSalesEstimatesData]:
+        """Transform the raw data into the standard format."""
+        symbols = query.symbol.split(",") if query.symbol else []
+        results: List[IntrinioForwardSalesEstimatesData] = []
+        for item in sorted(
+            data,
+            key=lambda item: (  # type: ignore
+                (
+                    symbols.index(item.get("symbol")) if item.get("symbol") in symbols else len(symbols),  # type: ignore
+                    item.get("date"),
+                )
+                if symbols
+                else item.get("date")
+            ),
+        ):
+            temp: Dict[str, Any] = {}
+            company = item.pop("company")
+            if company.get("ticker") is None:
+                continue
+            temp["symbol"] = company.get("ticker")
+            temp["name"] = company.get("name")
+            if query.fiscal_period and query.fiscal_period.upper() != item.get(
+                "fiscal_period"
+            ):
+                continue
+            if query.calendar_period and query.calendar_period.upper() != item.get(
+                "calendar_period"
+            ):
+                continue
+            temp.update(item)
+            results.append(IntrinioForwardSalesEstimatesData.model_validate(temp))
+
+        return results

openbb_platform/providers/intrinio/openbb_intrinio/models/fred_series.py

@@ -0,0 +1,114 @@
+"""Intrinio FRED Series Model."""
+
+import asyncio
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+
+from dateutil.relativedelta import relativedelta
+from openbb_core.provider.abstract.fetcher import Fetcher
+from openbb_core.provider.standard_models.fred_series import (
+    SeriesData,
+    SeriesQueryParams,
+)
+from openbb_core.provider.utils.helpers import (
+    ClientResponse,
+    ClientSession,
+    amake_requests,
+    get_querystring,
+)
+from pydantic import Field
+
+
+class IntrinioFredSeriesQueryParams(SeriesQueryParams):
+    """Intrinio FRED Series Query.
+
+    Source: https://docs.intrinio.com/documentation/web_api/get_economic_index_historical_data_v2
+    """
+
+    __alias_dict__ = {"limit": "page_size"}
+
+    all_pages: Optional[bool] = Field(
+        default=False,
+        description="Returns all pages of data from the API call at once.",
+    )
+    sleep: Optional[float] = Field(
+        default=1.0,
+        description="Time to sleep between requests to avoid rate limiting.",
+    )
+
+
+class IntrinioFredSeriesData(SeriesData):
+    """Intrinio FRED Series Data."""
+
+    value: Optional[float] = Field(default=None, description="Value of the index.")
+
+
+class IntrinioFredSeriesFetcher(
+    Fetcher[
+        IntrinioFredSeriesQueryParams,
+        List[IntrinioFredSeriesData],
+    ]
+):
+    """Transform the query, extract and transform the data from the Intrinio endpoints."""
+
+    @staticmethod
+    def transform_query(params: Dict[str, Any]) -> IntrinioFredSeriesQueryParams:
+        """Transform the query params."""
+        transformed_params = params
+
+        now = datetime.now().date()
+        if params.get("start_date") is None:
+            transformed_params["start_date"] = now - relativedelta(years=1)
+
+        if params.get("end_date") is None:
+            transformed_params["end_date"] = now
+
+        return IntrinioFredSeriesQueryParams(**transformed_params)
+
+    @staticmethod
+    async def aextract_data(
+        query: IntrinioFredSeriesQueryParams,
+        credentials: Optional[Dict[str, str]],
+        **kwargs: Any,
+    ) -> List[Dict]:
+        """Return the raw data from the Intrinio endpoint."""
+        api_key = credentials.get("intrinio_api_key") if credentials else ""
+
+        base_url = "https://api-v2.intrinio.com"
+        query_str = get_querystring(
+            query.model_dump(), ["symbol", "all_pages", "sleep"]
+        )
+
+        url = (
+            f"{base_url}/indices/economic/${query.symbol.replace('$', '')}/historical_data/level"
+            f"?{query_str}&api_key={api_key}"
+        )
+
+        async def callback(response: ClientResponse, session: ClientSession) -> dict:
+            """Return the response."""
+            init_response = await response.json()
+
+            all_data: list = init_response.get("historical_data", [])
+
+            if query.all_pages:
+                next_page = init_response.get("next_page", None)
+                while next_page:
+                    if query.limit > 100:
+                        await asyncio.sleep(query.sleep)
+
+                    url = response.url.update_query(next_page=next_page).human_repr()
+                    response_data = await session.get_json(url)
+
+                    all_data.extend(response_data.get("historical_data", []))
+                    next_page = response_data.get("next_page", None)
+
+            return all_data
+
+        return await amake_requests([url], callback, **kwargs)
+
+    @staticmethod
+    def transform_data(
+        query: IntrinioFredSeriesQueryParams, data: List[Dict], **kwargs: Any
+    ) -> List[IntrinioFredSeriesData]:
+        """Return the transformed data."""
+        return [IntrinioFredSeriesData.model_validate(d) for d in data]

openbb_platform/providers/intrinio/openbb_intrinio/models/historical_attributes.py

@@ -0,0 +1,144 @@
+"""Intrinio Historical Attributes Model."""
+
+# pylint: disable = unused-argument
+
+import warnings
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+
+from dateutil.relativedelta import relativedelta
+from openbb_core.app.model.abstract.warning import OpenBBWarning
+from openbb_core.provider.abstract.fetcher import Fetcher
+from openbb_core.provider.standard_models.historical_attributes import (
+    HistoricalAttributesData,
+    HistoricalAttributesQueryParams,
+)
+from openbb_core.provider.utils.helpers import (
+    ClientResponse,
+    ClientSession,
+    amake_requests,
+    get_querystring,
+)
+
+
+class IntrinioHistoricalAttributesQueryParams(HistoricalAttributesQueryParams):
+    """Intrinio Historical Attributes Query.
+
+    Source: https://docs.intrinio.com/documentation/web_api/get_historical_data_v2
+    """
+
+    __alias_dict__ = {"sort": "sort_order", "limit": "page_size", "tag_type": "type"}
+    __json_schema_extra__ = {
+        "tag": {"multiple_items_allowed": True},
+        "symbol": {"multiple_items_allowed": True},
+    }
+
+
+class IntrinioHistoricalAttributesData(HistoricalAttributesData):
+    """Intrinio Historical Attributes Data."""
+
+
+class IntrinioHistoricalAttributesFetcher(
+    Fetcher[
+        IntrinioHistoricalAttributesQueryParams,
+        List[IntrinioHistoricalAttributesData],
+    ]
+):
+    """Transform the query, extract and transform the data from the Intrinio endpoints."""
+
+    @staticmethod
+    def transform_query(
+        params: Dict[str, Any]
+    ) -> IntrinioHistoricalAttributesQueryParams:
+        """Transform the query params."""
+        transformed_params = params
+
+        now = datetime.now().date()
+        if params.get("start_date") is None:
+            transformed_params["start_date"] = now - relativedelta(years=5)
+
+        if params.get("end_date") is None:
+            transformed_params["end_date"] = now
+
+        return IntrinioHistoricalAttributesQueryParams(**transformed_params)
+
+    @staticmethod
+    async def aextract_data(
+        query: IntrinioHistoricalAttributesQueryParams,
+        credentials: Optional[Dict[str, str]],
+        **kwargs: Any,
+    ) -> List[Dict]:
+        """Return the raw data from the Intrinio endpoint."""
+        api_key = credentials.get("intrinio_api_key") if credentials else ""
+
+        base_url = "https://api-v2.intrinio.com"
+        query_str = get_querystring(query.model_dump(by_alias=True), ["symbol", "tag"])
+
+        def generate_url(symbol: str, tag: str) -> str:
+            """Return the url for the given symbol and tag."""
+            url_params = f"{symbol}/{tag}?{query_str}&api_key={api_key}"
+            url = f"{base_url}/historical_data/{url_params}"
+            return url
+
+        async def callback(
+            response: ClientResponse, session: ClientSession
+        ) -> List[Dict]:
+            """Return the response."""
+            init_response = await response.json()
+
+            if message := init_response.get(  # type: ignore
+                "error"
+            ) or init_response.get(  # type: ignore
+                "message"
+            ):
+                warnings.warn(message=str(message), category=OpenBBWarning)
+                return []
+
+            symbol = response.url.parts[-2]  # type: ignore
+            tag = response.url.parts[-1]  # type: ignore
+
+            all_data: List = init_response.get("historical_data", [])  # type: ignore
+            all_data = [{**item, "symbol": symbol, "tag": tag} for item in all_data]
+
+            next_page = init_response.get("next_page", None)  # type: ignore
+            while next_page:
+                url = response.url.update_query(  # type: ignore
+                    next_page=next_page
+                ).human_repr()
+                response_data = await session.get_json(url)
+
+                if message := response_data.get("error") or response_data.get(  # type: ignore
+                    "message"
+                ):
+                    warnings.warn(message=message, category=OpenBBWarning)
+                    return []
+
+                symbol = response.url.parts[-2]  # type: ignore
+                tag = response_data.url.parts[-1]  # type: ignore
+
+                response_data = response_data.get("historical_data", [])  # type: ignore
+                response_data = [
+                    {**item, "symbol": symbol, "tag": tag} for item in response_data
+                ]
+
+                all_data.extend(response_data)
+                next_page = response_data.get("next_page", None)  # type: ignore
+
+            return all_data
+
+        urls = [
+            generate_url(symbol, tag)
+            for symbol in query.symbol.split(",")
+            for tag in query.tag.split(",")
+        ]
+
+        return await amake_requests(urls, callback, **kwargs)
+
+    @staticmethod
+    def transform_data(
+        query: IntrinioHistoricalAttributesQueryParams,
+        data: List[Dict],
+        **kwargs: Any,
+    ) -> List[IntrinioHistoricalAttributesData]:
+        """Return the transformed data."""
+        return [IntrinioHistoricalAttributesData.model_validate(d) for d in data]