Upload 29 files

openbb_platform/providers/tmx/openbb_tmx/__init__.py

@@ -0,0 +1,71 @@
+"""TMX Provider Module."""
+
+from openbb_core.provider.abstract.provider import Provider
+from openbb_tmx.models.available_indices import TmxAvailableIndicesFetcher
+from openbb_tmx.models.bond_prices import TmxBondPricesFetcher
+from openbb_tmx.models.calendar_earnings import TmxCalendarEarningsFetcher
+from openbb_tmx.models.company_filings import TmxCompanyFilingsFetcher
+from openbb_tmx.models.company_news import TmxCompanyNewsFetcher
+from openbb_tmx.models.equity_historical import TmxEquityHistoricalFetcher
+from openbb_tmx.models.equity_profile import TmxEquityProfileFetcher
+from openbb_tmx.models.equity_quote import TmxEquityQuoteFetcher
+from openbb_tmx.models.equity_search import TmxEquitySearchFetcher
+from openbb_tmx.models.etf_countries import TmxEtfCountriesFetcher
+from openbb_tmx.models.etf_holdings import TmxEtfHoldingsFetcher
+from openbb_tmx.models.etf_info import TmxEtfInfoFetcher
+from openbb_tmx.models.etf_search import TmxEtfSearchFetcher
+from openbb_tmx.models.etf_sectors import TmxEtfSectorsFetcher
+from openbb_tmx.models.gainers import TmxGainersFetcher
+from openbb_tmx.models.historical_dividends import TmxHistoricalDividendsFetcher
+from openbb_tmx.models.index_constituents import TmxIndexConstituentsFetcher
+from openbb_tmx.models.index_sectors import TmxIndexSectorsFetcher
+from openbb_tmx.models.index_snapshots import TmxIndexSnapshotsFetcher
+from openbb_tmx.models.insider_trading import TmxInsiderTradingFetcher
+from openbb_tmx.models.options_chains import TmxOptionsChainsFetcher
+from openbb_tmx.models.price_target_consensus import TmxPriceTargetConsensusFetcher
+from openbb_tmx.models.treasury_prices import TmxTreasuryPricesFetcher
+
+tmx_provider = Provider(
+    name="tmx",
+    website="https://www.tmx.com",
+    description="""Unofficial TMX Data Provider Extension
+    TMX Group Companies
+        - Toronto Stock Exchange
+        - TSX Venture Exchange
+        - TSX Trust
+        - Montréal Exchange
+        - TSX Alpha Exchange
+        - Shorcan
+        - CDCC
+        - CDS
+        - TMX Datalinx
+        - Trayport
+    """,
+    fetcher_dict={
+        "AvailableIndices": TmxAvailableIndicesFetcher,
+        "BondPrices": TmxBondPricesFetcher,
+        "CalendarEarnings": TmxCalendarEarningsFetcher,
+        "CompanyFilings": TmxCompanyFilingsFetcher,
+        "CompanyNews": TmxCompanyNewsFetcher,
+        "EquityHistorical": TmxEquityHistoricalFetcher,
+        "EquityInfo": TmxEquityProfileFetcher,
+        "EquityQuote": TmxEquityQuoteFetcher,
+        "EquitySearch": TmxEquitySearchFetcher,
+        "EtfSearch": TmxEtfSearchFetcher,
+        "EtfHoldings": TmxEtfHoldingsFetcher,
+        "EtfSectors": TmxEtfSectorsFetcher,
+        "EtfCountries": TmxEtfCountriesFetcher,
+        "EtfHistorical": TmxEquityHistoricalFetcher,
+        "EtfInfo": TmxEtfInfoFetcher,
+        "EquityGainers": TmxGainersFetcher,
+        "HistoricalDividends": TmxHistoricalDividendsFetcher,
+        "IndexConstituents": TmxIndexConstituentsFetcher,
+        "IndexSectors": TmxIndexSectorsFetcher,
+        "IndexSnapshots": TmxIndexSnapshotsFetcher,
+        "InsiderTrading": TmxInsiderTradingFetcher,
+        "OptionsChains": TmxOptionsChainsFetcher,
+        "PriceTargetConsensus": TmxPriceTargetConsensusFetcher,
+        "TreasuryPrices": TmxTreasuryPricesFetcher,
+    },
+    repr_name="TMX",
+)

openbb_platform/providers/tmx/openbb_tmx/models/__init__.py

@@ -0,0 +1 @@
+"""TMX Provider Models."""

openbb_platform/providers/tmx/openbb_tmx/models/available_indices.py

@@ -0,0 +1,134 @@
+"""Available Indices fetcher for TMX"""
+
+# 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.available_indices import (
+    AvailableIndicesData,
+    AvailableIndicesQueryParams,
+)
+from openbb_core.provider.utils.errors import EmptyDataError
+from pydantic import Field
+
+
+class TmxAvailableIndicesQueryParams(AvailableIndicesQueryParams):
+    """TMX Available Indices Query Params."""
+
+    use_cache: bool = Field(
+        default=True,
+        description="Whether to use a cached request."
+        + " Index data is from a single JSON file, updated each day after close."
+        + " It is cached for one day. To bypass, set to False.",
+    )
+
+
+class TmxAvailableIndicesData(AvailableIndicesData):
+    """TMX Available Indices Data."""
+
+    symbol: str = Field(description="The ticker symbol of the index.")
+
+
+class TmxAvailableIndicesFetcher(
+    Fetcher[
+        TmxAvailableIndicesQueryParams,
+        List[TmxAvailableIndicesData],
+    ]
+):
+    """Transform the query, extract and transform the data from the TMX endpoints."""
+
+    @staticmethod
+    def transform_query(params: Dict[str, Any]) -> TmxAvailableIndicesQueryParams:
+        """Transform the query params."""
+        return TmxAvailableIndicesQueryParams(**params)
+
+    @staticmethod
+    async def aextract_data(
+        query: TmxAvailableIndicesQueryParams,
+        credentials: Optional[Dict[str, str]],
+        **kwargs: Any,
+    ) -> Dict:
+        """Return the raw data from the TMX endpoint."""
+        # pylint: disable=import-outside-toplevel
+        from openbb_tmx.utils.helpers import get_data_from_url, get_indices_backend
+
+        url = "https://tmxinfoservices.com/files/indices/sptsx-indices.json"
+
+        data = await get_data_from_url(
+            url,
+            use_cache=query.use_cache,
+            backend=get_indices_backend(),
+        )
+
+        return data
+
+    @staticmethod
+    def transform_data(
+        query: TmxAvailableIndicesQueryParams,
+        data: Dict,
+        **kwargs: Any,
+    ) -> List[TmxAvailableIndicesData]:
+        """Transform the data to the standard format."""
+        # pylint: disable=import-outside-toplevel
+        import re
+
+        data = data.copy()
+        if data == {}:
+            raise EmptyDataError
+
+        # Extract the category for each index.
+        symbols = {}
+        for category, symbol_list in data["groups"].items():
+            for symbol in symbol_list:
+                if symbol not in symbols:
+                    symbols[symbol] = category
+                else:
+                    symbols[symbol].append(category)
+            category = {"category": symbols}  # noqa: PLW2901
+        # Extract the data for each index and combine with the category.
+        new_data = []
+        for symbol in data["indices"]:
+            overview = data["indices"][symbol].get("overview_en", None)
+            if overview:
+                # Remove HTML tags from the overview
+                overview = re.sub("<.*?>", "", overview)
+                # Remove additional artifacts from the overview
+                overview = re.sub("\r|\n|amp;", "", overview)
+            new_data.append(
+                {
+                    "symbol": symbol,
+                    "name": data["indices"][symbol].get("name_en", None),
+                    "currency": (
+                        "USD"
+                        if "(USD)" in data["indices"][symbol]["name_en"]
+                        else "CAD"
+                    ),
+                    "category": symbols[symbol],
+                    "market_value": (
+                        data["indices"][symbol]["quotedmarketvalue"].get("total", None)
+                        if data["indices"][symbol].get("quotedmarketvalue")
+                        else None
+                    ),
+                    "num_constituents": data["indices"][symbol].get(
+                        "nb_constituents", None
+                    ),
+                    "overview": (
+                        overview
+                        if data["indices"][symbol].get("overview") != ""
+                        else None
+                    ),
+                    "methodology": (
+                        data["indices"][symbol].get("methodology", None)
+                        if data["indices"][symbol].get("methodology") != ""
+                        else None
+                    ),
+                    "factsheet": (
+                        data["indices"][symbol].get("factsheet", None)
+                        if data["indices"][symbol].get("factsheet") != ""
+                        else None
+                    ),
+                }
+            )
+
+        return [TmxAvailableIndicesData.model_validate(d) for d in new_data]

openbb_platform/providers/tmx/openbb_tmx/models/bond_prices.py

@@ -0,0 +1,198 @@
+"""TMX Bond Prices Fetcher"""
+
+# pylint: disable=unused-argument
+from datetime import (
+    date as dateType,
+    datetime,
+)
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
+
+from openbb_core.provider.abstract.fetcher import Fetcher
+from openbb_core.provider.standard_models.bond_reference import (
+    BondReferenceData,
+    BondReferenceQueryParams,
+)
+from pydantic import Field, field_validator
+
+if TYPE_CHECKING:
+    from pandas import DataFrame
+
+
+class TmxBondPricesQueryParams(BondReferenceQueryParams):
+    """
+    TMX Bond Prices Query Params.
+
+    Data will be made available by 5:00 EST on T+1
+
+    Source: https://bondtradedata.iiroc.ca/#/
+    """
+
+    __alias_dict__ = {
+        # "isin": "isins",
+    }
+    issue_date_min: Optional[dateType] = Field(
+        default=None,
+        description="Filter by the minimum original issue date.",
+    )
+    issue_date_max: Optional[dateType] = Field(
+        default=None,
+        description="Filter by the maximum original issue date.",
+    )
+    last_traded_min: Optional[dateType] = Field(
+        default=None,
+        description="Filter by the minimum last trade date.",
+    )
+    use_cache: bool = Field(
+        default=True,
+        description="All bond data is sourced from a single JSON file that is updated daily."
+        + " The file is cached for one day to eliminate downloading more than once."
+        + " Caching will significantly speed up subsequent queries. To bypass, set to False.",
+    )
+
+
+class TmxBondPricesData(BondReferenceData):
+    """TMX Bond Prices Data."""
+
+    __alias_dict__ = {
+        "coupon_rate": "couponRate",
+        "ytm": "lastYield",
+        "price": "lastPrice",
+        "highest_price": "highestPrice",
+        "lowest_price": "lowestPrice",
+        "total_trades": "totalTrades",
+        "last_traded_date": "lastTradedDate",
+        "maturity_date": "maturityDate",
+        "issue_date": "originalIssueDate",
+        "issuer_name": "issuer",
+    }
+
+    ytm: Optional[float] = Field(
+        default=None,
+        description="Yield to maturity (YTM) is the rate of return anticipated on a bond"
+        + " if it is held until the maturity date. It takes into account"
+        + " the current market price, par value, coupon rate and time to maturity. It is assumed that all"
+        + " coupons are reinvested at the same rate."
+        + " Values are returned as a normalized percent.",
+        json_schema_extra={"x-unit_measurement": "percent", "x-frontend_multiply": 100},
+    )
+    price: Optional[float] = Field(
+        default=None,
+        description="The last price for the bond.",
+        json_schema_extra={"x-unit_measurement": "currency"},
+    )
+    highest_price: Optional[float] = Field(
+        default=None,
+        description="The highest price for the bond on the last traded date.",
+        json_schema_extra={"x-unit_measurement": "currency"},
+    )
+    lowest_price: Optional[float] = Field(
+        default=None,
+        description="The lowest price for the bond on the last traded date.",
+        json_schema_extra={"x-unit_measurement": "currency"},
+    )
+    total_trades: Optional[int] = Field(
+        default=None,
+        description="Total number of trades on the last traded date.",
+    )
+    last_traded_date: Optional[dateType] = Field(
+        default=None,
+        description="Last traded date of the bond.",
+    )
+    maturity_date: Optional[dateType] = Field(
+        default=None,
+        description="Maturity date of the bond.",
+    )
+    issue_date: Optional[dateType] = Field(
+        default=None,
+        description="Issue date of the bond. This is the date when the bond first accrues interest.",
+    )
+    issuer_name: Optional[str] = Field(
+        default=None,
+        description="Name of the issuing entity.",
+    )
+
+    @field_validator(
+        "ytm",
+        "coupon_rate",
+        mode="before",
+        check_fields=False,
+    )
+    @classmethod
+    def normalize_percent(cls, v):
+        """Return percents as normalized percentage points."""
+        return float(v) / 100 if v else None
+
+
+class TmxBondPricesFetcher(
+    Fetcher[
+        TmxBondPricesQueryParams,
+        List[TmxBondPricesData],
+    ]
+):
+    """Tmx Bond Reference Fetcher."""
+
+    @staticmethod
+    def transform_query(params: Dict[str, Any]) -> TmxBondPricesQueryParams:
+        """Transform query params."""
+        # pylint: disable=import-outside-toplevel
+        from datetime import timedelta
+
+        transformed_params = params.copy()
+        now = datetime.now()
+        if now.date().weekday() > 4:
+            now = now - timedelta(now.date().weekday() - 4)
+        if transformed_params.get("maturity_date_min") is None:
+            transformed_params["maturity_date_min"] = (
+                now - timedelta(days=1)
+            ).strftime("%Y-%m-%d")
+        return TmxBondPricesQueryParams(**transformed_params)
+
+    @staticmethod
+    async def aextract_data(
+        query: TmxBondPricesQueryParams,
+        credentials: Optional[Dict[str, str]],
+        **kwargs: Any,
+    ) -> "DataFrame":
+        """Get the raw data containing all bond data."""
+        # pylint: disable=import-outside-toplevel
+        from openbb_tmx.utils.helpers import get_all_bonds
+
+        bonds = await get_all_bonds(use_cache=query.use_cache)
+        return bonds
+
+    @staticmethod
+    def transform_data(
+        query: TmxBondPricesQueryParams,
+        data: "DataFrame",
+        **kwargs: Any,
+    ) -> List[TmxBondPricesData]:
+        """Transform data."""
+        bonds = data.copy()
+        results = []
+        data = data[data["bondType"] == "Corp"]
+
+        data = bonds.query(
+            "bondType == 'Corp'"
+            "& maturityDate >= @query.maturity_date_min.strftime('%Y-%m-%d')"
+        ).sort_values(by=["maturityDate"])
+        data.issuer = data.loc[:, "issuer"].str.strip()
+        if query.maturity_date_max:
+            data = data.query(
+                "maturityDate <= @query.maturity_date_max.strftime('%Y-%m-%d')"
+            )
+        if query.last_traded_min:
+            data = data.query(
+                "lastTradedDate >= @query.last_traded_min.strftime('%Y-%m-%d')"
+            )
+        if query.coupon_min:
+            data = data.query("couponRate >= @query.coupon_min")
+        if query.coupon_max:
+            data = data.query("couponRate <= @query.coupon_max")
+        if query.issuer_name:
+            data = data.query("issuer.str.contains(@query.issuer_name, case=False)")
+        if len(data) > 0:
+            data = data.drop(columns=["bondType", "securityId", "secKey"])
+            data = data.fillna("N/A").replace("N/A", None)
+            results = data.to_dict("records")
+
+        return [TmxBondPricesData.model_validate(d) for d in results]

openbb_platform/providers/tmx/openbb_tmx/models/calendar_earnings.py

@@ -0,0 +1,147 @@
+"""TMX Earnings Calendar Model."""
+
+# pylint: disable=unused-argument
+
+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.calendar_earnings import (
+    CalendarEarningsData,
+    CalendarEarningsQueryParams,
+)
+from pydantic import Field, field_validator
+
+
+class TmxCalendarEarningsQueryParams(CalendarEarningsQueryParams):
+    """TMX Calendar Earnings Query."""
+
+
+class TmxCalendarEarningsData(CalendarEarningsData):
+    """TMX Calendar Earnings Data."""
+
+    __alias_dict__ = {
+        "eps_actual": "actualEps",
+        "reporting_time": "announceTime",
+        "eps_consensus": "estimatedEps",
+        "eps_surprise": "epsSurpriseDollar",
+        "surprise_percent": "epsSurprisePercent",
+        "name": "companyName",
+    }
+
+    name: str = Field(description="The company's name.")
+    eps_consensus: Optional[float] = Field(
+        default=None, description="The consensus estimated EPS in dollars."
+    )
+    eps_actual: Optional[float] = Field(
+        default=None, description="The actual EPS in dollars."
+    )
+    eps_surprise: Optional[float] = Field(
+        default=None, description="The EPS surprise in dollars."
+    )
+    surprise_percent: Optional[float] = Field(
+        default=None,
+        description="The EPS surprise as a normalized percent.",
+        json_schema_extra={"x-unit_measurement": "percent", "x-frontend_multiply": 100},
+    )
+    reporting_time: Optional[str] = Field(
+        default=None,
+        description="The time of the report - i.e., before or after market.",
+    )
+
+    @field_validator("surprise_percent", mode="before", check_fields=False)
+    @classmethod
+    def percent_validate(cls, v):  # pylint: disable=E0213
+        """Return the percent as a normalized value."""
+        return float(v) / 100 if v else None
+
+
+class TmxCalendarEarningsFetcher(
+    Fetcher[TmxCalendarEarningsQueryParams, List[TmxCalendarEarningsData]]
+):
+    """Transform the query, extract and transform the data from the TMX endpoints."""
+
+    @staticmethod
+    def transform_query(params: Dict[str, Any]) -> TmxCalendarEarningsQueryParams:
+        """Transform the query."""
+        # pylint: disable=import-outside-toplevel
+        from datetime import timedelta
+
+        transformed_params = params.copy()
+        if transformed_params.get("start_date") is None:
+            transformed_params["start_date"] = (
+                datetime.now().date().strftime("%Y-%m-%d")
+            )
+        if transformed_params.get("end_date") is None:
+            transformed_params["end_date"] = (
+                (datetime.now() + timedelta(days=5)).date().strftime("%Y-%m-%d")
+            )
+        return TmxCalendarEarningsQueryParams(**transformed_params)
+
+    @staticmethod
+    async def aextract_data(
+        query: TmxCalendarEarningsQueryParams,
+        credentials: Optional[Dict[str, str]],
+        **kwargs: Any,
+    ) -> List[Dict]:
+        """Return the raw data from the TMX endpoint."""
+        # pylint: disable=import-outside-toplevel
+        import asyncio  # noqa
+        import json  # noqa
+        from openbb_tmx.utils import gql  # noqa
+        from openbb_tmx.utils.helpers import get_data_from_gql, get_random_agent  # noqa
+        from pandas import date_range  # noqa
+
+        results: List[Dict] = []
+        user_agent = get_random_agent()
+        dates = date_range(query.start_date, end=query.end_date)
+
+        async def create_task(date, results):
+            """Create a task for a single date in the range."""
+            data = []
+            date = date.strftime("%Y-%m-%d")
+            payload = gql.get_earnings_date_payload.copy()
+            payload["variables"]["date"] = date
+            url = "https://app-money.tmx.com/graphql"
+            r = await get_data_from_gql(
+                method="POST",
+                url=url,
+                data=json.dumps(payload),
+                headers={
+                    "Host": "app-money.tmx.com",
+                    "Referer": "https://money.tmx.com/",
+                    "locale": "en",
+                    "Content-Type": "application/json",
+                    "User-Agent": user_agent,
+                    "Accept": "*/*",
+                },
+                timeout=3,
+            )
+            try:
+                if (
+                    "data" in r
+                    and r["data"].get("getEnhancedEarningsForDate") is not None
+                ):
+                    data = r["data"].get("getEnhancedEarningsForDate")
+                    data = [{"report_date": date, **d} for d in data]
+            except Exception as e:
+                raise RuntimeError(e) from e
+            if len(data) > 0:
+                results.extend(data)
+            return results
+
+        tasks = [create_task(date, results) for date in dates if date.weekday() < 5]
+
+        await asyncio.gather(*tasks)
+
+        return sorted(results, key=lambda x: x["report_date"])
+
+    @staticmethod
+    def transform_data(
+        query: TmxCalendarEarningsQueryParams,
+        data: List[Dict],
+        **kwargs: Any,
+    ) -> List[TmxCalendarEarningsData]:
+        """Return the transformed data."""
+        results = [{k: (None if v == "N/A" else v) for k, v in d.items()} for d in data]
+        return [TmxCalendarEarningsData.model_validate(d) for d in results]

openbb_platform/providers/tmx/openbb_tmx/models/company_filings.py

@@ -0,0 +1,184 @@
+"""TMX Company Filings Model."""
+
+# pylint: disable=unused-argument
+
+from datetime import (
+    date as dateType,
+    datetime,
+)
+from typing import Any, Dict, List, Optional
+
+from openbb_core.provider.abstract.fetcher import Fetcher
+from openbb_core.provider.standard_models.company_filings import (
+    CompanyFilingsData,
+    CompanyFilingsQueryParams,
+)
+from pydantic import Field, field_validator
+
+
+class TmxCompanyFilingsQueryParams(CompanyFilingsQueryParams):
+    """TMX Company Filings Query Parameters."""
+
+    start_date: Optional[dateType] = Field(
+        description="The start date to fetch.",
+        default=None,
+    )
+    end_date: Optional[dateType] = Field(
+        description="The end date to fetch.",
+        default=None,
+    )
+
+    @field_validator("symbol", mode="before", check_fields=False)
+    @classmethod
+    def _validate_symbol(cls, v: str):
+        """Validate the symbol."""
+        if not v:
+            raise ValueError("Symbol is required for TMX.")
+        return v
+
+
+class TmxCompanyFilingsData(CompanyFilingsData):
+    """TMX Sedar Filings Data."""
+
+    __alias_dict__ = {
+        "filing_date": "filingDate",
+        "report_type": "name",
+        "report_url": "urlToPdf",
+    }
+
+    description: str = Field(description="The description of the filing.")
+    size: Optional[str] = Field(
+        description="The file size of the PDF document.", default=None
+    )
+
+
+class TmxCompanyFilingsFetcher(
+    Fetcher[TmxCompanyFilingsQueryParams, List[TmxCompanyFilingsData]]
+):
+    """TMX Company Filings Fetcher."""
+
+    @staticmethod
+    def transform_query(params: Dict[str, Any]) -> TmxCompanyFilingsQueryParams:
+        """Transform the query."""
+        # pylint: disable=import-outside-toplevel
+        from datetime import timedelta
+
+        transformed_params = params.copy()
+        if transformed_params.get("start_date") is None:
+            transformed_params["start_date"] = (
+                datetime.now() - timedelta(weeks=16)
+            ).strftime("%Y-%m-%d")
+        if transformed_params.get("end_date") is None:
+            transformed_params["end_date"] = datetime.now().date().strftime("%Y-%m-%d")
+        transformed_params["symbol"] = (
+            params.get("symbol", "")
+            .upper()
+            .replace("-", ".")
+            .replace(".TO", "")
+            .replace(".TSX", "")
+        )
+        return TmxCompanyFilingsQueryParams(**transformed_params)
+
+    @staticmethod
+    async def aextract_data(
+        query: TmxCompanyFilingsQueryParams,
+        credentials: Optional[Dict[str, str]],
+        **kwargs: Any,
+    ) -> List[Dict]:
+        """Return the raw data from the TMX endpoint."""
+        # pylint: disable=import-outside-toplevel
+        import asyncio  # noqa
+        import json  # noqa
+        from dateutil import rrule  # noqa
+        from datetime import timedelta  # noqa
+        from openbb_tmx.utils import gql  # noqa
+        from openbb_tmx.utils.helpers import get_data_from_gql, get_random_agent  # noqa
+
+        user_agent = get_random_agent()
+        results: List[Dict] = []
+
+        # Generate a list of dates from start_date to end_date with a frequency of 1 week
+        dates = list(
+            rrule.rrule(
+                rrule.WEEKLY, interval=1, dtstart=query.start_date, until=query.end_date
+            )
+        )
+
+        # Add end_date to the list if it's not there already
+        if dates[-1] != query.end_date:
+            dates.append(query.end_date)  # type: ignore
+
+        # Create a list of 4-week chunks
+        chunks = [
+            (dates[i], dates[i + 1] - timedelta(days=1)) for i in range(len(dates) - 1)
+        ]
+
+        # Adjust the end date of the last chunk to be the final end date
+        chunks[-1] = (chunks[-1][0], query.end_date)  # type: ignore
+
+        async def create_task(start, end, results):
+            """Create tasks from the chunked start/end dates."""
+            data = []
+            payload = gql.get_company_filings_payload
+            payload["variables"]["symbol"] = query.symbol
+            payload["variables"]["fromDate"] = start.strftime("%Y-%m-%d")
+            payload["variables"]["toDate"] = end.strftime("%Y-%m-%d")
+            payload["variables"]["limit"] = 1000
+            url = "https://app-money.tmx.com/graphql"
+
+            async def try_again():
+                return await get_data_from_gql(
+                    method="POST",
+                    url=url,
+                    data=json.dumps(payload),
+                    headers={
+                        "authority": "app-money.tmx.com",
+                        "referer": f"https://money.tmx.com/en/quote/{query.symbol}",
+                        "locale": "en",
+                        "Content-Type": "application/json",
+                        "User-Agent": user_agent,
+                        "Accept": "*/*",
+                    },
+                    timeout=10,
+                )
+
+            try:
+                data = await get_data_from_gql(
+                    method="POST",
+                    url=url,
+                    data=json.dumps(payload),
+                    headers={
+                        "authority": "app-money.tmx.com",
+                        "referer": f"https://money.tmx.com/en/quote/{query.symbol}",
+                        "locale": "en",
+                        "Content-Type": "application/json",
+                        "User-Agent": user_agent,
+                        "Accept": "*/*",
+                    },
+                    timeout=10,
+                )
+            except Exception:
+                data = await try_again()
+
+            if isinstance(data, str):
+                data = await try_again()
+
+            if data and data.get("data", {}).get("filings"):  # type: ignore
+                results.extend(data["data"]["filings"])  # type: ignore
+
+            return results
+
+        tasks = [create_task(chunk[0], chunk[1], results) for chunk in chunks]
+
+        await asyncio.gather(*tasks)
+
+        return sorted(results, key=lambda x: x["filingDate"], reverse=True)
+
+    @staticmethod
+    def transform_data(
+        query: TmxCompanyFilingsQueryParams,
+        data: List[Dict],
+        **kwargs: Any,
+    ) -> List[TmxCompanyFilingsData]:
+        """Return the transformed data."""
+        return [TmxCompanyFilingsData.model_validate(d) for d in data]

openbb_platform/providers/tmx/openbb_tmx/models/company_news.py

@@ -0,0 +1,136 @@
+"""TMX Stock News model."""
+
+# pylint: disable=unused-argument
+
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+
+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 pydantic import Field, field_validator
+
+
+class TmxCompanyNewsQueryParams(CompanyNewsQueryParams):
+    """TMX Stock News query."""
+
+    __json_schema_extra__ = {"symbol": {"multiple_items_allowed": True}}
+
+    page: Optional[int] = Field(
+        default=1, description="The page number to start from. Use with limit."
+    )
+
+    @field_validator("symbol", mode="before")
+    @classmethod
+    def symbols_validate(cls, v):
+        """Validate the symbols."""
+        if v is None:
+            raise OpenBBError("Symbol is a required field for TMX.")
+        return v
+
+
+class TmxCompanyNewsData(CompanyNewsData):
+    """TMX Stock News Data."""
+
+    __alias_dict__ = {
+        "date": "datetime",
+        "title": "headline",
+    }
+
+    source: Optional[str] = Field(description="Source of the news.", default=None)
+
+    @field_validator("date", mode="before", check_fields=False)
+    @classmethod
+    def date_validate(cls, v):
+        """Validate the datetime format."""
+        # pylint: disable=import-outside-toplevel
+        import pytz
+
+        dt = datetime.strptime(v, "%Y-%m-%dT%H:%M:%S%z")
+        return dt.astimezone(pytz.timezone("America/New_York"))
+
+
+class TmxCompanyNewsFetcher(
+    Fetcher[TmxCompanyNewsQueryParams, List[TmxCompanyNewsData]],
+):
+    """TMX Stock News Fetcher."""
+
+    @staticmethod
+    def transform_query(params: Dict[str, Any]) -> TmxCompanyNewsQueryParams:
+        """Transform the query."""
+        return TmxCompanyNewsQueryParams(**params)
+
+    @staticmethod
+    async def aextract_data(
+        query: TmxCompanyNewsQueryParams,
+        credentials: Optional[Dict[str, str]],
+        **kwargs: Any,
+    ) -> List[Dict]:
+        """Return the raw data from the TMX endpoint."""
+        # pylint: disable=import-outside-toplevel
+        import asyncio  # noqa
+        import json  # noqa
+        from openbb_tmx.utils import gql  # noqa
+        from openbb_tmx.utils.helpers import get_data_from_gql, get_random_agent  # noqa
+
+        user_agent = get_random_agent()
+        symbols = query.symbol.split(",")  # type: ignore
+        results: List[Dict] = []
+
+        async def create_task(symbol, results):
+            """Make a POST request to the TMX GraphQL endpoint for a single symbol."""
+            symbol = (
+                symbol.upper().replace(".TO", "").replace(".TSX", "").replace("-", ".")
+            )
+            payload = gql.get_company_news_events_payload
+            payload["variables"]["symbol"] = symbol
+            payload["variables"]["page"] = query.page
+            payload["variables"]["limit"] = query.limit
+            payload["variables"]["locale"] = "en"
+            url = "https://app-money.tmx.com/graphql"
+            data: Dict = {}
+            response = await get_data_from_gql(
+                method="POST",
+                url=url,
+                data=json.dumps(payload),
+                headers={
+                    "authority": "app-money.tmx.com",
+                    "referer": f"https://money.tmx.com/en/quote/{symbol}",
+                    "locale": "en",
+                    "Content-Type": "application/json",
+                    "User-Agent": user_agent,
+                    "Accept": "*/*",
+                },
+                timeout=3,
+            )
+            data = response["data"] if response.get("data") else data
+            if data.get("news") is not None:
+                news = data["news"]
+                for i in range(len(news)):  # pylint: disable=C0200
+                    url = f"https://money.tmx.com/quote/{symbol.upper()}/news/{news[i]['newsid']}"
+                    news[i]["url"] = url
+                    # The newsid was used to create the URL, so we drop it.
+                    news[i].pop("newsid", None)
+                    # The summary is a duplicated headline, so we drop it.
+                    news[i].pop("summary", None)
+                    # Add the symbol to the data for multi-ticker support.
+                    news[i]["symbols"] = symbol
+                results.extend(news)
+
+            return results
+
+        tasks = [create_task(symbol, results) for symbol in symbols]
+
+        await asyncio.gather(*tasks)
+
+        return sorted(results, key=lambda d: d["datetime"], reverse=True)
+
+    @staticmethod
+    def transform_data(
+        query: TmxCompanyNewsQueryParams, data: List[Dict], **kwargs: Any
+    ) -> List[TmxCompanyNewsData]:
+        """Return the transformed data."""
+        return [TmxCompanyNewsData.model_validate(d) for d in data]

openbb_platform/providers/tmx/openbb_tmx/models/equity_historical.py

@@ -0,0 +1,248 @@
+"""TMX Equity Historical Model."""
+
+# pylint: disable=unused-argument
+
+from datetime import (
+    date as dateType,
+    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.equity_historical import (
+    EquityHistoricalData,
+    EquityHistoricalQueryParams,
+)
+from openbb_core.provider.utils.descriptions import (
+    QUERY_DESCRIPTIONS,
+)
+from openbb_core.provider.utils.errors import EmptyDataError
+from pydantic import Field, field_validator
+
+
+class TmxEquityHistoricalQueryParams(EquityHistoricalQueryParams):
+    """
+    TMX Equity Historical Query Params.
+
+    Ticker symbols are assumed to be Canadian listings when no suffix is provided.
+    ".TO" or ."TSX" are accepted but will automatically be removed.
+
+    US tickers are supported via their composite format: "AAPL:US"
+
+    Canadian Depositary Receipts (CDRs) are: "AAPL:AQL"
+
+    CDRs are the underlying asset for CAD-hedged assets.
+
+    source: https://money.tmx.com
+    """
+
+    __json_schema_extra__ = {"symbol": {"multiple_items_allowed": True}}
+
+    interval: Union[
+        Literal["1m", "2m", "5m", "15m", "30m", "60m", "1h", "1d", "1W", "1M"], str, int
+    ] = Field(  # type: ignore
+        description=QUERY_DESCRIPTIONS.get("interval", "")
+        + " Or, any integer (entered as a string) representing the number of minutes."
+        + " Default is daily data."
+        + " There is no extended hours data, and intraday data is limited to after April 12 2022.",
+        default="day",
+    )
+    adjustment: Literal["splits_only", "splits_and_dividends", "unadjusted"] = Field(
+        description="The adjustment factor to apply. Only valid for daily data.",
+        default="splits_only",
+    )
+
+    @field_validator("interval", mode="after", check_fields=False)
+    @classmethod
+    def validate_interval(cls, v):  # pylint: disable=R0911
+        """Validate the interval to be valid for the TMX request."""
+        if v is None or v == "day":
+            return "day"
+        if v in ("1M", "1mo", "month"):
+            return "month"
+        if "m" in v:
+            return int(v.replace("m", ""))
+        if "h" in v:
+            return int(v.replace("h", "")) * 60
+        if v == "1d":
+            return "day"
+        if v in ("1W", "1w", "week"):
+            return "week"
+        if v.isnumeric():
+            return int(v)
+        raise OpenBBError(f"Invalid interval: {v}")
+
+
+class TmxEquityHistoricalData(EquityHistoricalData):
+    """TMX Equity Historical Data."""
+
+    __alias_dict__ = {
+        "date": "datetime",
+        "open": "openPrice",
+        "close": "closePrice",
+        "transactions_value": "tradeValue",
+        "transactions": "numberOfTrade",
+        "change_percent": "changePercent",
+    }
+
+    vwap: Optional[float] = Field(
+        description="Volume weighted average price for the day.", default=None
+    )
+    change: Optional[float] = Field(description="Change in price.", default=None)
+    change_percent: Optional[float] = Field(
+        description="Change in price, as a normalized percentage.",
+        default=None,
+        json_schema_extra={"x-unit_measurement": "percent", "x-frontend_multiply": 100},
+    )
+    transactions: Optional[int] = Field(
+        description="Total number of transactions recorded.", default=None
+    )
+    transactions_value: Optional[float] = Field(
+        description="Nominal value of recorded transactions.", default=None
+    )
+
+    @field_validator("date", mode="before", check_fields=False)
+    @classmethod
+    def date_validate(cls, v):  # pylint: disable=W0221
+        """Validate the datetime format."""
+        # pylint: disable=import-outside-toplevel
+        import pytz
+
+        if isinstance(v, (datetime, dateType)):
+            return v if v.hour != 0 and v.minute != 0 and v.second != 0 else v.date()  # type: ignore
+        try:
+            dt = datetime.strptime(v, "%Y-%m-%d %H:%M:%S%z")
+            return dt.astimezone(pytz.timezone("America/New_York"))
+        except ValueError:
+            return datetime.strptime(v, "%Y-%m-%d")
+
+
+class TmxEquityHistoricalFetcher(
+    Fetcher[TmxEquityHistoricalQueryParams, List[TmxEquityHistoricalData]]
+):
+    """TMX Equity Historical Fetcher."""
+
+    @staticmethod
+    def transform_query(params: Dict[str, Any]) -> TmxEquityHistoricalQueryParams:
+        """Transform the query."""
+        adjustment = params.get("adjustment")
+        if (
+            adjustment is not None
+            and adjustment != "splits_only"
+            and params.get("interval") not in ["day", "1d"]
+        ):
+            warn("Adjustment parameter is only available for daily data.")
+        return TmxEquityHistoricalQueryParams(**params)
+
+    @staticmethod
+    async def aextract_data(
+        query: TmxEquityHistoricalQueryParams,
+        credentials: Optional[Dict[str, str]],
+        **kwargs: Any,
+    ) -> List[Dict]:
+        """Return the raw data from the TMX endpoint."""
+        # pylint: disable=import-outside-toplevel
+        import asyncio  # noqa
+        from openbb_tmx.utils.helpers import (  # noqa
+            get_daily_price_history,
+            get_intraday_price_history,
+            get_weekly_or_monthly_price_history,
+        )
+
+        results: List[Dict] = []
+        symbols = query.symbol.split(",")
+
+        async def create_task(symbol, results):
+            """Make a POST request to the TMX GraphQL endpoint for a single ticker."""
+            data: List[Dict] = []
+            # A different request is used for each type of interval.
+            if query.interval == "day":
+                data = await get_daily_price_history(
+                    symbol,
+                    start_date=query.start_date,
+                    end_date=query.end_date,
+                    adjustment=query.adjustment,
+                )
+            if query.interval in ("week", "month"):
+                data = await get_weekly_or_monthly_price_history(
+                    symbol,
+                    start_date=query.start_date,
+                    end_date=query.end_date,
+                    interval=query.interval,  # type: ignore
+                )
+            if isinstance(query.interval, int):
+                data = await get_intraday_price_history(
+                    symbol,
+                    interval=query.interval,
+                    start_date=query.start_date,
+                    end_date=query.end_date,
+                )
+
+            if data != []:
+                # Add the symbol to the data for multi-ticker support.
+                data = [{**d, "symbol": symbol} for d in data]
+                results.extend(data)
+
+            if data == []:
+                warn(f"No data found for {symbol}.")
+
+            return results
+
+        tasks = [create_task(symbol, results) for symbol in symbols]
+
+        await asyncio.gather(*tasks)
+
+        return results
+
+    @staticmethod
+    def transform_data(
+        query: TmxEquityHistoricalQueryParams,
+        data: List[Dict],
+        **kwargs: Any,
+    ) -> List[TmxEquityHistoricalData]:
+        """Return the transformed data."""
+        # pylint: disable=import-outside-toplevel
+        from pandas import DataFrame, to_datetime
+
+        results = DataFrame(data)
+        if results.empty or len(results) == 0:
+            raise EmptyDataError()
+
+        # Handle the date formatting differences.
+        results = results.rename(columns={"dateTime": "datetime"})
+        if query.interval != "day":
+            results["datetime"] = to_datetime(results["datetime"], utc=True)
+            if query.interval in ("week", "month"):
+                results["datetime"] = results["datetime"].dt.strftime("%Y-%m-%d")
+            else:
+                results["datetime"] = results["datetime"].dt.strftime(
+                    "%Y-%m-%d %H:%M:%S%z"
+                )
+        if query.interval == "day":
+            results["datetime"] = to_datetime(results["datetime"]).dt.strftime(
+                "%Y-%m-%d"
+            )
+
+        symbols = query.symbol.split(",")
+        # If there are multiple symbols, sort the data by datetime and symbol.
+        if len(symbols) > 1:
+            results = results.set_index(["datetime", "symbol"]).sort_index()
+            results = results.reset_index()
+        # If there is only one symbol, drop the symbol column.
+        if len(symbols) == 1:
+            results = results.drop(columns=["symbol"])
+        # Normalizes the percent change values.
+        if "changePercent" in results.columns:
+            results["changePercent"] = results["changePercent"].astype(float) / 100
+        # For the week beginning 2011-09-12 replace the openPrice NaN with 0 because of 9/11.
+        if query.interval == "week":
+            results["open"] = results["open"].fillna(0)
+        # Convert any NaN values to None.
+        results = results.fillna(value="N/A").replace("N/A", None)
+
+        return [
+            TmxEquityHistoricalData.model_validate(d)
+            for d in results.to_dict("records")
+        ]

openbb_platform/providers/tmx/openbb_tmx/models/equity_profile.py

@@ -0,0 +1,167 @@
+"""TMX Equity Profile fetcher."""
+
+# 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.equity_info import (
+    EquityInfoData,
+    EquityInfoQueryParams,
+)
+from pydantic import Field, model_validator
+
+
+class TmxEquityProfileQueryParams(EquityInfoQueryParams):
+    """TMX Equity Profile query params."""
+
+    __json_schema_extra__ = {"symbol": {"multiple_items_allowed": True}}
+
+
+class TmxEquityProfileData(EquityInfoData):
+    """TMX Equity Profile Data."""
+
+    __alias_dict__ = {
+        "short_description": "shortDescription",
+        "long_description": "longDescription",
+        "company_url": "website",
+        "business_phone_no": "phoneNumber",
+        "business_address": "fullAddress",
+        "stock_exchange": "exchangeCode",
+        "industry_category": "industry",
+        "industry_group": "qmdescription",
+        "issue_type": "issueType",
+        "share_outstanding": "shareOutStanding",
+        "shares_escrow": "sharesESCROW",
+        "total_shares_outstanding": "totalSharesOutStanding",
+    }
+
+    email: Optional[str] = Field(description="The email of the company.", default=None)
+    issue_type: Optional[str] = Field(
+        description="The issuance type of the asset.",
+        default=None,
+    )
+    shares_outstanding: Optional[int] = Field(
+        description="The number of listed shares outstanding.",
+        default=None,
+    )
+    shares_escrow: Optional[int] = Field(
+        description="The number of shares held in escrow.",
+        default=None,
+    )
+    shares_total: Optional[int] = Field(
+        description="The total number of shares outstanding from all classes.",
+        default=None,
+    )
+    dividend_frequency: Optional[str] = Field(
+        description="The dividend frequency.", default=None
+    )
+
+    @model_validator(mode="before")
+    @classmethod
+    def validate_empty_strings(cls, values) -> Dict:
+        """Validate the query parameters."""
+        return {k: None if v == "" else v for k, v in values.items()}
+
+
+class TmxEquityProfileFetcher(
+    Fetcher[
+        TmxEquityProfileQueryParams,
+        List[TmxEquityProfileData],
+    ]
+):
+    """TMX Equity Profile Fetcher."""
+
+    @staticmethod
+    def transform_query(params: Dict[str, Any]) -> TmxEquityProfileQueryParams:
+        """Transform the query."""
+        return TmxEquityProfileQueryParams(**params)
+
+    @staticmethod
+    async def aextract_data(
+        query: TmxEquityProfileQueryParams,
+        credentials: Optional[Dict[str, str]],
+        **kwargs: Any,
+    ) -> List[Dict]:
+        """Return the raw data from the TMX endpoint."""
+        # pylint: disable=import-outside-toplevel
+        import asyncio  # noqa
+        import json  # noqa
+        from openbb_tmx.utils import gql  # noqa
+        from openbb_tmx.utils.helpers import get_data_from_gql, get_random_agent  # noqa
+
+        symbols = query.symbol.split(",")
+
+        # The list where the results will be stored and appended to.
+        results: List[Dict] = []
+        user_agent = get_random_agent()
+
+        url = "https://app-money.tmx.com/graphql"
+
+        async def create_task(symbol: str, results) -> None:
+            """Make a POST request to the TMX GraphQL endpoint for a single symbol."""
+            symbol = (
+                symbol.upper().replace("-", ".").replace(".TO", "").replace(".TSX", "")
+            )
+
+            payload = gql.stock_info_payload.copy()
+            payload["variables"]["symbol"] = symbol
+
+            data = {}
+            r = await get_data_from_gql(
+                method="POST",
+                url=url,
+                data=json.dumps(payload),
+                headers={
+                    "authority": "app-money.tmx.com",
+                    "referer": f"https://money.tmx.com/en/quote/{symbol}",
+                    "locale": "en",
+                    "Content-Type": "application/json",
+                    "User-Agent": user_agent,
+                    "Accept": "*/*",
+                },
+                timeout=3,
+            )
+            if r["data"].get("getQuoteBySymbol"):
+                data = r["data"]["getQuoteBySymbol"]
+                results.append(data)
+
+        tasks = [create_task(symbol, results) for symbol in symbols]
+        await asyncio.gather(*tasks)
+        return results
+
+    @staticmethod
+    def transform_data(
+        query: TmxEquityProfileQueryParams,
+        data: List[Dict],
+        **kwargs: Any,
+    ) -> List[TmxEquityProfileData]:
+        """Return the transformed data."""
+        # Get only the items associated with `equity.profile()`.
+        items_list = [
+            "shortDescription",
+            "longDescription",
+            "website",
+            "phoneNumber",
+            "fullAddress",
+            "sector",
+            "qmdescription",
+            "industry",
+            "exchangeCode",
+            "shareOutStanding",
+            "sharesESCROW",
+            "totalSharesOutStanding",
+            "email",
+            "issueType",
+            "name",
+            "symbol",
+            "dividendFrequency",
+            "employees",
+        ]
+        data = [{k: v for k, v in d.items() if k in items_list} for d in data]
+        # Sort the data by the order of the symbols in the query.
+        symbols = query.symbol.split(",")
+        symbol_to_index = {symbol: index for index, symbol in enumerate(symbols)}
+        data = sorted(data, key=lambda d: symbol_to_index[d["symbol"]])
+
+        return [TmxEquityProfileData.model_validate(d) for d in data]

openbb_platform/providers/tmx/openbb_tmx/models/equity_quote.py

@@ -0,0 +1,382 @@
+"""TMX Equity Profile fetcher."""
+
+# pylint: disable=unused-argument
+
+from datetime import (
+    date as dateType,
+    datetime,
+)
+from typing import Any, Dict, List, Optional, Union
+from warnings import warn
+
+from openbb_core.provider.abstract.fetcher import Fetcher
+from openbb_core.provider.standard_models.equity_quote import (
+    EquityQuoteData,
+    EquityQuoteQueryParams,
+)
+from openbb_core.provider.utils.descriptions import DATA_DESCRIPTIONS
+from pydantic import Field, field_validator
+
+
+class TmxEquityQuoteQueryParams(EquityQuoteQueryParams):
+    """TMX Equity Profile query params."""
+
+    __json_schema_extra__ = {"symbol": {"multiple_items_allowed": True}}
+
+
+class TmxEquityQuoteData(EquityQuoteData):
+    """TMX Equity Profile Data."""
+
+    __alias_dict__ = {
+        "last_price": "price",
+        "open": "openPrice",
+        "high": "dayHigh",
+        "low": "dayLow",
+        "change": "priceChange",
+        "change_percent": "percentChange",
+        "prev_close": "prevClose",
+        "stock_exchange": "exchangeCode",
+        "industry_category": "industry",
+        "industry_group": "qmdescription",
+        "exchange": "exchangeCode",
+        "security_type": "datatype",
+        "year_high": "weeks52high",
+        "year_low": "weeks52low",
+        "ma_21": "day21MovingAvg",
+        "ma_50": "day50MovingAvg",
+        "ma_200": "day200MovingAvg",
+        "volume_avg_10d": "averageVolume10D",
+        "volume_avg_30d": "averageVolume30D",
+        "volume_avg_50d": "averageVolume50D",
+        "market_cap": "marketCap",
+        "market_cap_all_classes": "MarketCapAllClasses",
+        "div_amount": "dividendAmount",
+        "div_currency": "dividendCurrency",
+        "div_yield": "dividendYield",
+        "div_freq": "dividendFrequency",
+        "div_ex_date": "exDividendDate",
+        "div_pay_date": "dividendPayDate",
+        "div_growth_3y": "dividend3Years",
+        "div_growth_5y": "dividend5Years",
+        "pe": "peRatio",
+        "debt_to_equity": "totalDebtToEquity",
+        "price_to_book": "priceToBook",
+        "price_to_cf": "priceToCashFlow",
+        "return_on_equity": "returnOnEquity",
+        "return_on_assets": "returnOnAssets",
+        "shares_outstanding": "shareOutStanding",
+        "shares_escrow": "sharesESCROW",
+        "shares_total": "totalSharesOutStanding",
+    }
+
+    name: Optional[str] = Field(default=None, description="The name of the asset.")
+    security_type: Optional[str] = Field(
+        description="The issuance type of the asset.", default=None
+    )
+    exchange: Optional[str] = Field(
+        default=None,
+        description="The listing exchange code.",
+    )
+    sector: Optional[str] = Field(default=None, description="The sector of the asset.")
+    industry_category: Optional[str] = Field(
+        default=None,
+        description="The industry category of the asset.",
+    )
+    industry_group: Optional[str] = Field(
+        default=None,
+        description="The industry group of the asset.",
+    )
+    last_price: Optional[float] = Field(
+        default=None, description="The last price of the asset."
+    )
+    open: Optional[float] = Field(
+        default=None,
+        description=DATA_DESCRIPTIONS.get("open", ""),
+    )
+    high: Optional[float] = Field(
+        default=None,
+        description=DATA_DESCRIPTIONS.get("high", ""),
+    )
+    low: Optional[float] = Field(
+        default=None,
+        description=DATA_DESCRIPTIONS.get("low", ""),
+    )
+    close: Optional[float] = Field(
+        default=None,
+    )
+    vwap: Optional[float] = Field(
+        default=None, description=DATA_DESCRIPTIONS.get("vwap", "")
+    )
+    volume: Optional[int] = Field(
+        default=None, description=DATA_DESCRIPTIONS.get("vwap", "")
+    )
+    prev_close: Optional[float] = Field(
+        default=None, description=DATA_DESCRIPTIONS.get("prev_close", "")
+    )
+    change: Optional[float] = Field(
+        default=None,
+        description="The change in price.",
+    )
+    change_percent: Optional[float] = Field(
+        default=None,
+        description="The change in price as a normalized percent.",
+        json_schema_extra={"x-unit_measurement": "percent", "x-frontend_multiply": 100},
+    )
+    year_high: Optional[float] = Field(
+        description="Fifty-two week high.",
+        default=None,
+    )
+    year_low: Optional[float] = Field(
+        description="Fifty-two week low.",
+        default=None,
+    )
+    ma_21: Optional[float] = Field(
+        description="Twenty-one day moving average.",
+        default=None,
+    )
+    ma_50: Optional[float] = Field(
+        description="Fifty day moving average.",
+        default=None,
+    )
+    ma_200: Optional[float] = Field(
+        description="Two-hundred day moving average.",
+        default=None,
+    )
+    volume_avg_10d: Optional[int] = Field(
+        description="Ten day average volume.",
+        default=None,
+    )
+    volume_avg_30d: Optional[int] = Field(
+        description="Thirty day average volume.",
+        default=None,
+    )
+    volume_avg_50d: Optional[int] = Field(
+        description="Fifty day average volume.",
+        default=None,
+    )
+    market_cap: Optional[int] = Field(
+        description="Market capitalization.",
+        default=None,
+    )
+    market_cap_all_classes: Optional[int] = Field(
+        description="Market capitalization of all share classes.",
+        default=None,
+    )
+    div_amount: Optional[float] = Field(
+        description="The most recent dividend amount.",
+        default=None,
+    )
+    div_currency: Optional[str] = Field(
+        description="The currency the dividend is paid in.",
+        default=None,
+    )
+    div_yield: Optional[float] = Field(
+        description="The dividend yield as a normalized percentage.",
+        default=None,
+        json_schema_extra={"x-unit_measurement": "percent", "x-frontend_multiply": 100},
+    )
+    div_freq: Optional[str] = Field(
+        description="The frequency of dividend payments.",
+        default=None,
+    )
+    div_ex_date: Optional[dateType] = Field(
+        description="The ex-dividend date.",
+        default=None,
+    )
+    div_pay_date: Optional[dateType] = Field(
+        description="The next dividend ayment date.",
+        default=None,
+    )
+    div_growth_3y: Optional[Union[float, str]] = Field(
+        description="The three year dividend growth as a normalized percentage.",
+        default=None,
+        json_schema_extra={"x-unit_measurement": "percent", "x-frontend_multiply": 100},
+    )
+    div_growth_5y: Optional[Union[float, str]] = Field(
+        description="The five year dividend growth as a normalized percentage.",
+        default=None,
+        json_schema_extra={"x-unit_measurement": "percent", "x-frontend_multiply": 100},
+    )
+    pe: Optional[Union[float, str]] = Field(
+        description="The price to earnings ratio.",
+        default=None,
+    )
+    eps: Optional[Union[float, str]] = Field(
+        description="The earnings per share.", default=None
+    )
+    debt_to_equity: Optional[Union[float, str]] = Field(
+        description="The debt to equity ratio.",
+        default=None,
+    )
+    price_to_book: Optional[Union[float, str]] = Field(
+        description="The price to book ratio.",
+        default=None,
+    )
+    price_to_cf: Optional[Union[float, str]] = Field(
+        description="The price to cash flow ratio.",
+        default=None,
+    )
+    return_on_equity: Optional[Union[float, str]] = Field(
+        description="The return on equity, as a normalized percentage.",
+        default=None,
+        json_schema_extra={"x-unit_measurement": "percent", "x-frontend_multiply": 100},
+    )
+    return_on_assets: Optional[Union[float, str]] = Field(
+        description="The return on assets, as a normalized percentage.",
+        default=None,
+        json_schema_extra={"x-unit_measurement": "percent", "x-frontend_multiply": 100},
+    )
+    beta: Optional[Union[float, str]] = Field(
+        description="The beta relative to the TSX Composite.", default=None
+    )
+    alpha: Optional[Union[float, str]] = Field(
+        description="The alpha relative to the TSX Composite.", default=None
+    )
+    shares_outstanding: Optional[int] = Field(
+        description="The number of listed shares outstanding.",
+        default=None,
+    )
+    shares_escrow: Optional[int] = Field(
+        description="The number of shares held in escrow.",
+        default=None,
+    )
+    shares_total: Optional[int] = Field(
+        description="The total number of shares outstanding from all classes.",
+        default=None,
+    )
+
+    @field_validator(
+        "div_ex_date",
+        "div_pay_date",
+        mode="before",
+        check_fields=False,
+    )
+    @classmethod
+    def date_validate(cls, v):  # pylint: disable=E0213
+        """Return the datetime object from the date string."""
+        if v:
+            try:
+                return datetime.strptime(v, "%Y-%m-%d").date()
+            except ValueError:
+                return datetime.strptime(v, "%Y-%m-%d %H:%M:%S.%f").date()
+        return None
+
+    @field_validator(
+        "return_on_equity",
+        "return_on_assets",
+        "div_yield",
+        "div_growth_3y",
+        "div_growth_5y",
+        "change_percent",
+        mode="before",
+        check_fields=False,
+    )
+    @classmethod
+    def normalize_percent(cls, v):
+        """Return percents as normalized percentage points."""
+        return round(float(v) / 100, 6) if v else None
+
+
+class TmxEquityQuoteFetcher(
+    Fetcher[
+        TmxEquityQuoteQueryParams,
+        List[TmxEquityQuoteData],
+    ]
+):
+    """TMX Equity Quote Fetcher."""
+
+    @staticmethod
+    def transform_query(params: Dict[str, Any]) -> TmxEquityQuoteQueryParams:
+        """Transform the query."""
+        return TmxEquityQuoteQueryParams(**params)
+
+    @staticmethod
+    async def aextract_data(
+        query: TmxEquityQuoteQueryParams,
+        credentials: Optional[Dict[str, str]],
+        **kwargs: Any,
+    ) -> List[Dict]:
+        """Return the raw data from the TMX endpoint."""
+        # pylint: disable=import-outside-toplevel
+        import asyncio  # noqa
+        import json  # noqa
+        from openbb_tmx.utils import gql  # noqa
+        from openbb_tmx.utils.helpers import get_data_from_gql, get_random_agent  # noqa
+
+        symbols = query.symbol.split(",")
+
+        # The list where the results will be stored and appended to.
+        results: List[Dict] = []
+        user_agent = get_random_agent()
+
+        url = "https://app-money.tmx.com/graphql"
+
+        async def create_task(symbol: str, results) -> None:
+            """Make a POST request to the TMX GraphQL endpoint for a single symbol."""
+            symbol = (
+                symbol.upper().replace("-", ".").replace(".TO", "").replace(".TSX", "")
+            )
+
+            payload = gql.stock_info_payload.copy()
+            payload["variables"]["symbol"] = symbol
+
+            data = {}
+            r = await get_data_from_gql(
+                method="POST",
+                url=url,
+                data=json.dumps(payload),
+                headers={
+                    "authority": "app-money.tmx.com",
+                    "referer": f"https://money.tmx.com/en/quote/{symbol}",
+                    "locale": "en",
+                    "Content-Type": "application/json",
+                    "User-Agent": user_agent,
+                    "Accept": "*/*",
+                },
+                timeout=3,
+            )
+            if r["data"].get("getQuoteBySymbol"):
+                data = r["data"]["getQuoteBySymbol"]
+                results.append(data)
+            else:
+                warn(f"Could not get data for {symbol}.")
+
+        tasks = [create_task(symbol, results) for symbol in symbols]
+        await asyncio.gather(*tasks)
+        return results
+
+    @staticmethod
+    def transform_data(
+        query: TmxEquityQuoteQueryParams,
+        data: List[Dict],
+        **kwargs: Any,
+    ) -> List[TmxEquityQuoteData]:
+        """Return the transformed data."""
+        # pylint: disable=import-outside-toplevel
+        from numpy import nan
+
+        # Remove the items associated with `equity.profile()`.
+        items_list = [
+            "shortDescription",
+            "longDescription",
+            "website",
+            "phoneNumber",
+            "fullAddress",
+            "email",
+            "issueType",
+            "exchangeName",
+            "employees",
+            "exShortName",
+        ]
+        data = [{k: v for k, v in d.items() if k not in items_list} for d in data]
+        # Replace all NaN values with None.
+        for d in data:
+            for k, v in d.items():
+                if v in (nan, 0, ""):
+                    d[k] = None
+        # Sort the data by the order of the symbols in the query.
+        symbols = query.symbol.split(",")
+        symbol_to_index = {symbol: index for index, symbol in enumerate(symbols)}
+        data = sorted(data, key=lambda d: symbol_to_index[d["symbol"]])
+
+        return [TmxEquityQuoteData.model_validate(d) for d in data]

openbb_platform/providers/tmx/openbb_tmx/models/equity_search.py

@@ -0,0 +1,72 @@
+"""TMX Equity Search fetcher."""
+
+# 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.equity_search import (
+    EquitySearchData,
+    EquitySearchQueryParams,
+)
+from pydantic import Field
+
+
+class TmxEquitySearchQueryParams(EquitySearchQueryParams):
+    """TMX Equity Search query.
+
+    Source: https://www.tmx.com/
+    """
+
+    use_cache: bool = Field(
+        default=True,
+        description="Whether to use a cached request. The list of companies is cached for two days.",
+    )
+
+
+class TmxEquitySearchData(EquitySearchData):
+    """TMX Equity Search Data."""
+
+
+class TmxEquitySearchFetcher(
+    Fetcher[
+        TmxEquitySearchQueryParams,
+        List[TmxEquitySearchData],
+    ]
+):
+    """TMX Equity Search Fetcher."""
+
+    @staticmethod
+    def transform_query(params: Dict[str, Any]) -> TmxEquitySearchQueryParams:
+        """Transform the query."""
+        return TmxEquitySearchQueryParams(**params)
+
+    @staticmethod
+    async def aextract_data(
+        query: TmxEquitySearchQueryParams,
+        credentials: Optional[Dict[str, str]],
+        **kwargs: Any,
+    ) -> List[Dict]:
+        """Return the raw data from the TMX endpoint."""
+        # pylint: disable=import-outside-toplevel
+        from openbb_tmx.utils.helpers import get_all_tmx_companies
+        from pandas import DataFrame
+
+        companies = await get_all_tmx_companies(use_cache=query.use_cache)
+        results = DataFrame(index=companies, data=companies.values(), columns=["name"])
+        results = results.reset_index().rename(columns={"index": "symbol"})
+
+        if query:
+            results = results[
+                results["name"].str.contains(query.query, case=False)
+                | results["symbol"].str.contains(query.query, case=False)
+            ]
+
+        return results.reset_index(drop=True).astype(str).to_dict("records")
+
+    @staticmethod
+    def transform_data(
+        query: TmxEquitySearchQueryParams, data: List[Dict], **kwargs: Any
+    ) -> List[TmxEquitySearchData]:
+        """Transform the data to the standard format."""
+        return [TmxEquitySearchData.model_validate(d) for d in data]

openbb_platform/providers/tmx/openbb_tmx/models/etf_countries.py

@@ -0,0 +1,114 @@
+"""TMX ETF Countries fetcher."""
+
+# pylint: disable=unused-argument
+
+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_countries import (
+    EtfCountriesData,
+    EtfCountriesQueryParams,
+)
+from pydantic import Field
+
+
+class TmxEtfCountriesQueryParams(EtfCountriesQueryParams):
+    """TMX ETF Countries Query Params"""
+
+    __json_schema_extra__ = {"symbol": {"multiple_items_allowed": True}}
+
+    use_cache: bool = Field(
+        default=True,
+        description="Whether to use a cached request. All ETF data comes from a single JSON file that is updated daily."
+        + " To bypass, set to False. If True, the data will be cached for 4 hours.",
+    )
+
+
+class TmxEtfCountriesData(EtfCountriesData):
+    """TMX ETF Countries Data."""
+
+
+class TmxEtfCountriesFetcher(
+    Fetcher[
+        TmxEtfCountriesQueryParams,
+        List[TmxEtfCountriesData],
+    ]
+):
+    """TMX ETF Countries Fetcher."""
+
+    @staticmethod
+    def transform_query(params: Dict[str, Any]) -> TmxEtfCountriesQueryParams:
+        """Transform the query."""
+        return TmxEtfCountriesQueryParams(**params)
+
+    @staticmethod
+    async def aextract_data(
+        query: TmxEtfCountriesQueryParams,
+        credentials: Optional[Dict[str, str]],
+        **kwargs: Any,
+    ) -> List[Dict]:
+        """Return the raw data from the TMX endpoint."""
+        # pylint: disable=import-outside-toplevel
+        from openbb_core.provider.utils.errors import EmptyDataError  # noqa
+        from openbb_tmx.utils.helpers import get_all_etfs
+        from pandas import DataFrame
+
+        symbols = (
+            query.symbol.split(",") if "," in query.symbol else [query.symbol.upper()]
+        )
+
+        _data = DataFrame(await get_all_etfs(use_cache=query.use_cache))
+        results = {}
+        for symbol in symbols:
+            data = {}
+            if ".TO" in symbol:
+                symbol = symbol.replace(".TO", "")  # noqa
+            _target = _data[_data["symbol"] == symbol]["regions"]
+            target = DataFrame()
+            if len(_target) > 0:
+                target = DataFrame.from_records(_target.iloc[0]).rename(
+                    columns={"name": "country", "percent": "weight"}
+                )
+                if not target.empty:
+                    target = target.set_index("country")
+                for i in target.index:
+                    data.update({i: target.loc[i]["weight"]})
+                if data:
+                    results.update({symbol: data})
+            else:
+                warn(f"No data found for {symbol}")
+
+        if not results:
+            raise EmptyDataError("No countries info found for the given symbol(s).")
+
+        output = (
+            DataFrame(results)
+            .transpose()
+            .reset_index()
+            .rename(columns={"index": "symbol"})
+        ).transpose()
+        output.columns = output.loc["symbol"].to_list()
+        output.drop("symbol", axis=0, inplace=True)
+        return (
+            output.reset_index().rename(columns={"index": "country"}).to_dict("records")
+        )
+
+    @staticmethod
+    def transform_data(
+        query: TmxEtfCountriesQueryParams, data: List[Dict], **kwargs: Any
+    ) -> List[TmxEtfCountriesData]:
+        """Return the transformed data."""
+        # pylint: disable=import-outside-toplevel
+        from numpy import nan
+        from pandas import DataFrame
+
+        output = DataFrame(data)
+        for col in output.columns.to_list():
+            if col != "country":
+                output[col] = output[col].astype(float) / 100
+        output = output.replace({nan: None})
+
+        return [
+            TmxEtfCountriesData.model_validate(d) for d in output.to_dict("records")
+        ]

openbb_platform/providers/tmx/openbb_tmx/models/etf_holdings.py

@@ -0,0 +1,150 @@
+"""TMX ETF Holdings fetcher."""
+
+# pylint: disable=unused-argument
+
+from typing import Any, Dict, List, Optional, Union
+
+from openbb_core.provider.abstract.fetcher import Fetcher
+from openbb_core.provider.standard_models.etf_holdings import (
+    EtfHoldingsData,
+    EtfHoldingsQueryParams,
+)
+from pydantic import Field, field_validator
+
+
+class TmxEtfHoldingsQueryParams(EtfHoldingsQueryParams):
+    """TMX ETF Holdings query.
+
+    Source: https://www.tmx.com/
+    """
+
+    use_cache: bool = Field(
+        default=True,
+        description="Whether to use a cached request. All ETF data comes from a single JSON file that is updated daily."
+        + " To bypass, set to False. If True, the data will be cached for 4 hours.",
+    )
+
+
+class TmxEtfHoldingsData(EtfHoldingsData):
+    """TMX ETF Holdings Data."""
+
+    __alias_dict__ = {
+        "shares": "number_of_shares",
+    }
+
+    symbol: Optional[str] = Field(
+        description="The ticker symbol of the asset.", default=None
+    )
+    name: Optional[str] = Field(description="The name of the asset.", default=None)
+    weight: Optional[float] = Field(
+        description="The weight of the asset in the portfolio, as a normalized percentage.",
+        default=None,
+        json_schema_extra={"x-unit_measurement": "percent", "x-frontend_multiply": 100},
+    )
+    shares: Optional[Union[int, str]] = Field(
+        description="The value of the assets under management.",
+        default=None,
+    )
+    market_value: Optional[Union[float, str]] = Field(
+        description="The market value of the holding.", default=None
+    )
+    currency: Optional[str] = Field(
+        default=None, description="The currency of the holding."
+    )
+    share_percentage: Optional[float] = Field(
+        description="The share percentage of the holding, as a normalized percentage.",
+        default=None,
+        json_schema_extra={"x-unit_measurement": "percent", "x-frontend_multiply": 100},
+    )
+    share_change: Optional[Union[float, str]] = Field(
+        description="The change in shares of the holding.", default=None
+    )
+    country: Optional[str] = Field(
+        description="The country of the holding.", default=None
+    )
+    exchange: Optional[str] = Field(
+        description="The exchange code of the holding.", default=None
+    )
+    type_id: Optional[str] = Field(
+        description="The holding type ID of the asset.", default=None
+    )
+    fund_id: Optional[str] = Field(
+        description="The fund ID of the asset.", default=None
+    )
+
+    @field_validator("share_percentage", "weight", mode="before", check_fields=False)
+    @classmethod
+    def normalize_percent(cls, v):
+        """Return percents as normalized percentage points."""
+        return float(v) / 100 if v else None
+
+
+class TmxEtfHoldingsFetcher(
+    Fetcher[
+        TmxEtfHoldingsQueryParams,
+        List[TmxEtfHoldingsData],
+    ]
+):
+    """TMX ETF Holdings Fetcher."""
+
+    @staticmethod
+    def transform_query(params: Dict[str, Any]) -> TmxEtfHoldingsQueryParams:
+        """Transform the query."""
+        params["symbol"] = (
+            params["symbol"].replace(".TO", "").replace(".TSX", "").replace("-", ".")
+        )
+        return TmxEtfHoldingsQueryParams(**params)
+
+    @staticmethod
+    async def aextract_data(
+        query: TmxEtfHoldingsQueryParams,
+        credentials: Optional[Dict[str, str]],
+        **kwargs: Any,
+    ) -> List[Dict]:
+        """Return the raw data from the TMX endpoint."""
+        # pylint: disable=import-outside-toplevel
+        from openbb_tmx.utils.helpers import get_all_etfs
+        from pandas import DataFrame
+
+        query.symbol = query.symbol.upper()
+        results = []
+        etf = DataFrame()
+        etfs = DataFrame(await get_all_etfs(use_cache=query.use_cache))
+        etf = etfs[etfs["symbol"] == query.symbol]
+
+        if len(etf) == 1:
+            top_holdings = DataFrame(etf["holdings_top10"].iloc[0])
+            top_holdings = top_holdings.dropna(axis=1, how="all")
+            _columns = {
+                "numberofshares": "number_of_shares",
+                "symbol": "symbol",
+                "country": "country",
+                "fundid": "fund_id",
+                "excode": "exchange",
+                "securityname": "name",
+                "currency": "currency",
+                "marketvalue": "market_value",
+                "detailholdingtypeid": "type_id",
+                "weighting": "weight",
+                "sharepercentage": "share_percentage",
+                "sharechange": "share_change",
+                "shareChange": "share_change",
+            }
+            top_holdings.rename(columns=_columns, inplace=True)
+            results = (
+                top_holdings.fillna("N/A")
+                .replace("NA", None)
+                .replace("N/A", None)
+                .to_dict("records")
+            )
+
+        return results
+
+    @staticmethod
+    def transform_data(
+        query: TmxEtfHoldingsQueryParams,
+        data: List[Dict],
+        **kwargs: Any,
+    ) -> List[TmxEtfHoldingsData]:
+        """Transform the data to the standard format."""
+        return [TmxEtfHoldingsData.model_validate(d) for d in data]

openbb_platform/providers/tmx/openbb_tmx/models/etf_info.py

@@ -0,0 +1,239 @@
+"""TMX ETF Info fetcher."""
+
+# 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.etf_info import (
+    EtfInfoData,
+    EtfInfoQueryParams,
+)
+from pydantic import Field, field_validator
+
+
+class TmxEtfInfoQueryParams(EtfInfoQueryParams):
+    """TMX ETF Info Query Params"""
+
+    __json_schema_extra__ = {"symbol": {"multiple_items_allowed": True}}
+
+    use_cache: bool = Field(
+        default=True,
+        description="Whether to use a cached request. All ETF data comes from a single JSON file that is updated daily."
+        + " To bypass, set to False. If True, the data will be cached for 4 hours.",
+    )
+
+
+class TmxEtfInfoData(EtfInfoData):
+    """TMX ETF Info Data."""
+
+    __alias_dict__ = {
+        "avg_volume": "volume_avg_daily",
+        "issuer": "fund_family",
+        "avg_volume_30d": "volume_avg_30d",
+        "description": "investment_objectives",
+    }
+
+    issuer: Optional[str] = Field(description="The issuer of the ETF.", default=None)
+    investment_style: Optional[str] = Field(
+        description="The investment style of the ETF.", default=None
+    )
+    esg: Optional[bool] = Field(
+        description="Whether the ETF qualifies as an ESG fund.", default=None
+    )
+    currency: Optional[str] = Field(description="The currency of the ETF.")
+    unit_price: Optional[float] = Field(
+        description="The unit price of the ETF.", default=None
+    )
+    close: Optional[float] = Field(description="The closing price of the ETF.")
+    prev_close: Optional[float] = Field(
+        description="The previous closing price of the ETF.", default=None
+    )
+    return_1m: Optional[float] = Field(
+        description="The one-month return of the ETF, as a normalized percent",
+        default=None,
+        json_schema_extra={"x-unit_measurement": "percent", "x-frontend_multiply": 100},
+    )
+    return_3m: Optional[float] = Field(
+        description="The three-month return of the ETF, as a normalized percent.",
+        default=None,
+        json_schema_extra={"x-unit_measurement": "percent", "x-frontend_multiply": 100},
+    )
+    return_6m: Optional[float] = Field(
+        description="The six-month return of the ETF, as a normalized percent.",
+        default=None,
+        json_schema_extra={"x-unit_measurement": "percent", "x-frontend_multiply": 100},
+    )
+    return_ytd: Optional[float] = Field(
+        description="The year-to-date return of the ETF, as a normalized percent.",
+        default=None,
+        json_schema_extra={"x-unit_measurement": "percent", "x-frontend_multiply": 100},
+    )
+    return_1y: Optional[float] = Field(
+        description="The one-year return of the ETF, as a normalized percent.",
+        default=None,
+        json_schema_extra={"x-unit_measurement": "percent", "x-frontend_multiply": 100},
+    )
+    return_3y: Optional[float] = Field(
+        description="The three-year return of the ETF, as a normalized percent.",
+        default=None,
+        json_schema_extra={"x-unit_measurement": "percent", "x-frontend_multiply": 100},
+    )
+    return_5y: Optional[float] = Field(
+        description="The five-year return of the ETF, as a normalized percent.",
+        default=None,
+        json_schema_extra={"x-unit_measurement": "percent", "x-frontend_multiply": 100},
+    )
+    return_10y: Optional[float] = Field(
+        description="The ten-year return of the ETF, as a normalized percent.",
+        default=None,
+        json_schema_extra={"x-unit_measurement": "percent", "x-frontend_multiply": 100},
+    )
+    return_from_inception: Optional[float] = Field(
+        description="The return from inception of the ETF, as a normalized percent.",
+        default=None,
+        json_schema_extra={"x-unit_measurement": "percent", "x-frontend_multiply": 100},
+    )
+    avg_volume: Optional[int] = Field(
+        description="The average daily volume of the ETF.",
+        default=None,
+    )
+    avg_volume_30d: Optional[int] = Field(
+        description="The 30-day average volume of the ETF.",
+        default=None,
+    )
+    aum: Optional[float] = Field(description="The AUM of the ETF.", default=None)
+    pe_ratio: Optional[float] = Field(
+        description="The price-to-earnings ratio of the ETF.", default=None
+    )
+    pb_ratio: Optional[float] = Field(
+        description="The price-to-book ratio of the ETF.", default=None
+    )
+    management_fee: Optional[float] = Field(
+        description="The management fee of the ETF, as a normalized percent.",
+        default=None,
+        json_schema_extra={"x-unit_measurement": "percent", "x-frontend_multiply": 100},
+    )
+    mer: Optional[float] = Field(
+        description="The management expense ratio of the ETF, as a normalized percent.",
+        default=None,
+        json_schema_extra={"x-unit_measurement": "percent", "x-frontend_multiply": 100},
+    )
+    distribution_yield: Optional[float] = Field(
+        description="The distribution yield of the ETF, as a normalized percent.",
+        default=None,
+        json_schema_extra={"x-unit_measurement": "percent", "x-frontend_multiply": 100},
+    )
+    dividend_frequency: Optional[str] = Field(
+        description="The dividend payment frequency of the ETF.", default=None
+    )
+    website: Optional[str] = Field(description="The website of the ETF.", default=None)
+    description: Optional[str] = Field(
+        description="The description of the ETF.",
+        default=None,
+    )
+
+    @field_validator(
+        "distribution_yield",
+        "return_1m",
+        "return_3m",
+        "return_6m",
+        "return_ytd",
+        "return_1y",
+        "return_3y",
+        "return_5y",
+        "return_10y",
+        "return_from_inception",
+        "mer",
+        "management_fee",
+        mode="before",
+        check_fields=False,
+    )
+    @classmethod
+    def normalize_percent(cls, v):
+        """Return percents as normalized percentage points."""
+        return float(v) / 100 if v else None
+
+
+class TmxEtfInfoFetcher(
+    Fetcher[
+        TmxEtfInfoQueryParams,
+        List[TmxEtfInfoData],
+    ]
+):
+    """TMX ETF Info Fetcher."""
+
+    @staticmethod
+    def transform_query(params: Dict[str, Any]) -> TmxEtfInfoQueryParams:
+        """Transform the query."""
+        return TmxEtfInfoQueryParams(**params)
+
+    @staticmethod
+    async def aextract_data(
+        query: TmxEtfInfoQueryParams,
+        credentials: Optional[Dict[str, str]],
+        **kwargs: Any,
+    ) -> List[Dict]:
+        """Return the raw data from the TMX endpoint."""
+        # pylint: disable=import-outside-toplevel
+        from openbb_tmx.utils.helpers import get_all_etfs
+        from pandas import DataFrame
+
+        results = []
+        symbols = (
+            query.symbol.split(",") if "," in query.symbol else [query.symbol.upper()]
+        )
+        _data = DataFrame(await get_all_etfs(use_cache=query.use_cache))
+        COLUMNS = [
+            "symbol",
+            "inception_date",
+            "name",
+            "fund_family",
+            "investment_style",
+            "esg",
+            "currency",
+            "unit_price",
+            "close",
+            "prev_close",
+            "return_1m",
+            "return_3m",
+            "return_6m",
+            "return_ytd",
+            "return_1y",
+            "return_3y",
+            "return_5y",
+            "return_from_inception",
+            "volume_avg_daily",
+            "volume_avg_30d",
+            "aum",
+            "pe_ratio",
+            "pb_ratio",
+            "management_fee",
+            "mer",
+            "distribution_yield",
+            "dividend_frequency",
+            "website",
+            "investment_objectives",
+        ]
+
+        for symbol in symbols:
+            result = {}
+            target = DataFrame()
+            symbol = (  # noqa: PLW2901
+                symbol.replace(".TO", "").replace(".TSX", "").replace("-", ".")
+            )
+            target = _data[_data["symbol"] == symbol][COLUMNS]
+            target = target.fillna("N/A").replace("N/A", None)
+            if len(target) > 0:
+                result = target.reset_index(drop=True).transpose().to_dict()[0]
+                results.append(result)
+        return results
+
+    @staticmethod
+    def transform_data(
+        query: TmxEtfInfoQueryParams,
+        data: List[Dict],
+        **kwargs: Any,
+    ) -> List[TmxEtfInfoData]:
+        """Return the transformed data."""
+        return [TmxEtfInfoData.model_validate(d) for d in data]

openbb_platform/providers/tmx/openbb_tmx/models/etf_search.py

@@ -0,0 +1,270 @@
+"""TMX ETF Search fetcher."""
+
+# 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.etf_search import (
+    EtfSearchData,
+    EtfSearchQueryParams,
+)
+from pydantic import Field, field_validator
+
+
+class TmxEtfSearchQueryParams(EtfSearchQueryParams):
+    """TMX ETF Search query.
+
+    Source: https://www.tmx.com/
+    """
+
+    div_freq: Optional[Literal["monthly", "annually", "quarterly"]] = Field(
+        description="The dividend payment frequency.", default=None
+    )
+
+    sort_by: Optional[
+        Literal[
+            "aum",
+            "return_1m",
+            "return_3m",
+            "return_6m",
+            "return_1y",
+            "return_3y",
+            "return_ytd",
+            "beta_1y",
+            "volume_avg_daily",
+            "management_fee",
+            "distribution_yield",
+            "pb_ratio",
+            "pe_ratio",
+        ]
+    ] = Field(description="The column to sort by.", default=None)
+
+    use_cache: bool = Field(
+        default=True,
+        description="Whether to use a cached request. All ETF data comes from a single JSON file that is updated daily."
+        + " To bypass, set to False. If True, the data will be cached for 4 hours.",
+    )
+
+
+class TmxEtfSearchData(EtfSearchData):
+    """TMX ETF Search Data."""
+
+    __alias_dict__ = {
+        "issuer": "fund_family",
+        "avg_volume": "volume_avg_daily",
+        "avg_volume_30d": "volume_avg_30d",
+    }
+
+    short_name: Optional[str] = Field(
+        description="The short name of the ETF.", default=None
+    )
+    inception_date: Optional[str] = Field(
+        description="The inception date of the ETF.", default=None
+    )
+    issuer: Optional[str] = Field(description="The issuer of the ETF.", default=None)
+    investment_style: Optional[str] = Field(
+        description="The investment style of the ETF.", default=None
+    )
+    esg: Optional[bool] = Field(
+        description="Whether the ETF qualifies as an ESG fund.", default=None
+    )
+    currency: Optional[str] = Field(description="The currency of the ETF.")
+    unit_price: Optional[float] = Field(
+        description="The unit price of the ETF.", default=None
+    )
+    close: Optional[float] = Field(description="The closing price of the ETF.")
+    prev_close: Optional[float] = Field(
+        description="The previous closing price of the ETF.", default=None
+    )
+    return_1m: Optional[float] = Field(
+        description="The one-month return of the ETF, as a normalized percent.",
+        default=None,
+        json_schema_extra={"x-unit_measurement": "percent", "x-frontend_multiply": 100},
+    )
+    return_3m: Optional[float] = Field(
+        description="The three-month return of the ETF, as a normalized percent.",
+        default=None,
+        json_schema_extra={"x-unit_measurement": "percent", "x-frontend_multiply": 100},
+    )
+    return_6m: Optional[float] = Field(
+        description="The six-month return of the ETF, as a normalized percent.",
+        default=None,
+        json_schema_extra={"x-unit_measurement": "percent", "x-frontend_multiply": 100},
+    )
+    return_ytd: Optional[float] = Field(
+        description="The year-to-date return of the ETF, as a normalized percent.",
+        default=None,
+        json_schema_extra={"x-unit_measurement": "percent", "x-frontend_multiply": 100},
+    )
+    return_1y: Optional[float] = Field(
+        description="The one-year return of the ETF, as a normalized percent.",
+        default=None,
+        json_schema_extra={"x-unit_measurement": "percent", "x-frontend_multiply": 100},
+    )
+    beta_1y: Optional[float] = Field(
+        description="The one-year beta of the ETF, as a normalized percent.",
+        default=None,
+        json_schema_extra={"x-unit_measurement": "percent", "x-frontend_multiply": 100},
+    )
+    return_3y: Optional[float] = Field(
+        description="The three-year return of the ETF, as a normalized percent.",
+        default=None,
+        json_schema_extra={"x-unit_measurement": "percent", "x-frontend_multiply": 100},
+    )
+    beta_3y: Optional[float] = Field(
+        description="The three-year beta of the ETF, as a normalized percent.",
+        default=None,
+        json_schema_extra={"x-unit_measurement": "percent", "x-frontend_multiply": 100},
+    )
+    return_5y: Optional[float] = Field(
+        description="The five-year return of the ETF, as a normalized percent.",
+        default=None,
+        json_schema_extra={"x-unit_measurement": "percent", "x-frontend_multiply": 100},
+    )
+    beta_5y: Optional[float] = Field(
+        description="The five-year beta of the ETF, as a normalized percent.",
+        default=None,
+        json_schema_extra={"x-unit_measurement": "percent", "x-frontend_multiply": 100},
+    )
+    return_10y: Optional[float] = Field(
+        description="The ten-year return of the ETF, as a normalized percent.",
+        default=None,
+        json_schema_extra={"x-unit_measurement": "percent", "x-frontend_multiply": 100},
+    )
+    beta_10y: Optional[float] = Field(
+        description="The ten-year beta of the ETF.", default=None
+    )
+    beta_15y: Optional[float] = Field(
+        description="The fifteen-year beta of the ETF.", default=None
+    )
+    return_from_inception: Optional[float] = Field(
+        description="The return from inception of the ETF, as a normalized percent.",
+        default=None,
+        json_schema_extra={"x-unit_measurement": "percent", "x-frontend_multiply": 100},
+    )
+    avg_volume: Optional[int] = Field(
+        description="The average daily volume of the ETF.",
+        default=None,
+    )
+    avg_volume_30d: Optional[int] = Field(
+        description="The 30-day average volume of the ETF.",
+        default=None,
+    )
+    aum: Optional[float] = Field(description="The AUM of the ETF.", default=None)
+    pe_ratio: Optional[float] = Field(
+        description="The price-to-earnings ratio of the ETF.", default=None
+    )
+    pb_ratio: Optional[float] = Field(
+        description="The price-to-book ratio of the ETF.", default=None
+    )
+    management_fee: Optional[float] = Field(
+        description="The management fee of the ETF, as a normalized percent.",
+        default=None,
+        json_schema_extra={"x-unit_measurement": "percent", "x-frontend_multiply": 100},
+    )
+    mer: Optional[float] = Field(
+        description="The management expense ratio of the ETF, as a normalized percent.",
+        default=None,
+        json_schema_extra={"x-unit_measurement": "percent", "x-frontend_multiply": 100},
+    )
+    distribution_yield: Optional[float] = Field(
+        description="The distribution yield of the ETF, as a normalized percent.",
+        default=None,
+        json_schema_extra={"x-unit_measurement": "percent", "x-frontend_multiply": 100},
+    )
+    dividend_frequency: Optional[str] = Field(
+        description="The dividend payment frequency of the ETF.", default=None
+    )
+
+    @field_validator(
+        "distribution_yield",
+        "return_1m",
+        "return_3m",
+        "return_6m",
+        "return_ytd",
+        "return_1y",
+        "return_3y",
+        "return_5y",
+        "return_10y",
+        "return_from_inception",
+        "mer",
+        "management_fee",
+        mode="before",
+        check_fields=False,
+    )
+    @classmethod
+    def normalize_percent(cls, v):
+        """Return percents as normalized percentage points."""
+        if v:
+            return float(v) / 100
+        return None
+
+
+class TmxEtfSearchFetcher(
+    Fetcher[
+        TmxEtfSearchQueryParams,
+        List[TmxEtfSearchData],
+    ]
+):
+    """Transform the query, extract and transform the data from the TMX endpoints."""
+
+    @staticmethod
+    def transform_query(params: Dict[str, Any]) -> TmxEtfSearchQueryParams:
+        """Transform the query."""
+        return TmxEtfSearchQueryParams(**params)
+
+    @staticmethod
+    async def aextract_data(
+        query: TmxEtfSearchQueryParams,
+        credentials: Optional[Dict[str, str]],
+        **kwargs: Any,
+    ) -> List[Dict]:
+        """Return the raw data from the TMX endpoint."""
+        # pylint: disable=import-outside-toplevel
+        from openbb_tmx.utils.helpers import get_all_etfs
+        from pandas import DataFrame
+
+        etfs = DataFrame(await get_all_etfs(use_cache=query.use_cache))
+
+        if query.query:
+            etfs = etfs[
+                etfs["name"].str.contains(query.query, case=False)
+                | etfs["short_name"].str.contains(query.query, case=False)
+                | etfs["investment_style"].str.contains(query.query, case=False)
+                | etfs["investment_objectives"].str.contains(query.query, case=False)
+                | etfs["symbol"].str.contains(query.query, case=False)
+            ]
+
+        data = etfs.copy()
+
+        if query.div_freq:
+            data = data[data["dividend_frequency"] == query.div_freq.capitalize()]
+
+        if query.sort_by:
+            data = data.sort_values(by=query.sort_by, ascending=False)
+
+        data.drop(
+            columns=[
+                "sectors",
+                "regions",
+                "holdings_top10_summary",
+                "holdings_top10",
+                "additional_data",
+                "website",
+                "asset_class_id",
+                "investment_objectives",
+            ],
+            inplace=True,
+        )
+        data = data.dropna(how="all")
+        return data.fillna("N/A").replace("N/A", None).to_dict("records")
+
+    @staticmethod
+    def transform_data(
+        query: TmxEtfSearchQueryParams,
+        data: List[Dict],
+        **kwargs: Any,
+    ) -> List[TmxEtfSearchData]:
+        """Transform the data to the standard format."""
+        return [TmxEtfSearchData.model_validate(d) for d in data]

openbb_platform/providers/tmx/openbb_tmx/models/etf_sectors.py

@@ -0,0 +1,95 @@
+"""TMX ETF Sectors fetcher."""
+
+# 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.etf_sectors import (
+    EtfSectorsData,
+    EtfSectorsQueryParams,
+)
+from pydantic import Field
+
+
+class TmxEtfSectorsQueryParams(EtfSectorsQueryParams):
+    """TMX ETF Sectors Query Params"""
+
+    use_cache: bool = Field(
+        default=True,
+        description="Whether to use a cached request. All ETF data comes from a single JSON file that is updated daily."
+        + " To bypass, set to False. If True, the data will be cached for 4 hours.",
+    )
+
+
+class TmxEtfSectorsData(EtfSectorsData):
+    """TMX ETF Sectors Data."""
+
+
+class TmxEtfSectorsFetcher(
+    Fetcher[
+        TmxEtfSectorsQueryParams,
+        List[TmxEtfSectorsData],
+    ]
+):
+    """TMX ETF Sectors Fetcher."""
+
+    @staticmethod
+    def transform_query(params: Dict[str, Any]) -> TmxEtfSectorsQueryParams:
+        """Transform the query."""
+        return TmxEtfSectorsQueryParams(**params)
+
+    @staticmethod
+    async def aextract_data(
+        query: TmxEtfSectorsQueryParams,
+        credentials: Optional[Dict[str, str]],
+        **kwargs: Any,
+    ) -> List[Dict]:
+        """Return the raw data from the TMX endpoint."""
+        # pylint: disable=import-outside-toplevel
+        from openbb_core.provider.utils.errors import EmptyDataError  # noqa
+        from openbb_tmx.utils.helpers import get_all_etfs
+        from pandas import DataFrame
+
+        target = DataFrame()
+        _data = DataFrame(await get_all_etfs(use_cache=query.use_cache))
+        symbol = (
+            query.symbol.upper()
+            .replace("-", ".")
+            .replace(".TO", "")
+            .replace(".TSX", "")
+        )
+        _target = _data[_data["symbol"] == symbol]["sectors"]
+
+        if len(_target) > 0:
+            target = DataFrame.from_records(_target.iloc[0]).rename(
+                columns={"name": "sector", "percent": "weight"}
+            )
+            return target.to_dict(orient="records")
+        raise EmptyDataError(f"No sectors info found for ETF symbol: {query.symbol}.")
+
+    @staticmethod
+    def transform_data(
+        query: TmxEtfSectorsQueryParams,
+        data: List[Dict],
+        **kwargs: Any,
+    ) -> List[TmxEtfSectorsData]:
+        """Return the transformed data."""
+        # pylint: disable=import-outside-toplevel
+        from openbb_core.provider.utils.errors import EmptyDataError  # noqa
+        from numpy import nan
+        from pandas import DataFrame
+
+        target = DataFrame(data)
+        try:
+            target["weight"] = target["weight"] / 100
+        except KeyError:
+            raise EmptyDataError(  # pylint: disable=raise-missing-from
+                f"No sectors info found for ETF symbol: {query.symbol}."
+            )
+
+        target = target.replace({nan: None})
+        return [
+            TmxEtfSectorsData.model_validate(d)
+            for d in target.to_dict(orient="records")
+        ]

openbb_platform/providers/tmx/openbb_tmx/models/gainers.py

@@ -0,0 +1,174 @@
+"""TMX Equity Gainers 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.equity_performance import (
+    EquityPerformanceData,
+    EquityPerformanceQueryParams,
+)
+from openbb_core.provider.utils.errors import EmptyDataError
+from pydantic import Field, field_validator, model_validator
+
+STOCK_LISTS_DICT = {
+    "dividend": "TOP_DIVIDEND",
+    "energy": "TOP_ENERGY",
+    "healthcare": "TOP_HEALTHCARE",
+    "industrials": "TOP_INDUSTRIALS",
+    "price_performer": "TOP_PRICE_PERFORMER",
+    "rising_stars": "RISING_STARS",
+    "real_estate": "TOP_REAL_ESTATE",
+    "tech": "TOP_TECH",
+    "utilities": "TOP_UTILITIES",
+    "52w_high": "TOP_WEEK_52_HIGH",
+    "volume": "TOP_VOLUME",
+}
+
+STOCK_LISTS = Literal[
+    "dividend",
+    "energy",
+    "healthcare",
+    "industrials",
+    "price_performer",
+    "rising_stars",
+    "real_estate",
+    "tech",
+    "utilities",
+    "52w_high",
+    "volume",
+]
+
+
+class TmxGainersQueryParams(EquityPerformanceQueryParams):
+    """TMX Gainers Query Params."""
+
+    __json_schema_extra__ = {
+        "category": {
+            "multiple_items_allowed": False,
+            "choices": list(STOCK_LISTS_DICT),
+        },
+    }
+
+    category: STOCK_LISTS = Field(
+        default="price_performer",
+        description="The category of list to retrieve. Defaults to `price_performer`.",
+    )
+
+
+class TmxGainersData(EquityPerformanceData):
+    """TMX Gainers Data."""
+
+    __alias_dict__ = {
+        "name": "longName",
+        "change": "priceChange",
+        "percent_change": "percentChange",
+        "thirty_day_price_change": "30 Day Price Change",
+        "dividend_yield": "Dividend Yield",
+        "year_high": "52 Week High",
+        "avg_volume_10d": "10 Day Avg. Volume",
+        "ninety_day_price_change": "90 Day Price Change",
+    }
+    thirty_day_price_change: Optional[float] = Field(
+        default=None,
+        description="30 Day Price Change.",
+        json_schema_extra={"x-unit_measurement": "currency"},
+    )
+    ninety_day_price_change: Optional[float] = Field(
+        default=None,
+        description="90 Day Price Change.",
+        json_schema_extra={"x-unit_measurement": "currency"},
+    )
+    dividend_yield: Optional[float] = Field(
+        default=None,
+        description="Dividend Yield.",
+        json_schema_extra={"x-unit_measurement": "percent", "x-frontend_multiply": 100},
+    )
+    avg_volume_10d: Optional[float] = Field(
+        default=None,
+        description="10 Day Avg. Volume.",
+    )
+    rank: int = Field(description="The rank of the stock in the list.")
+
+    @field_validator("percent_change", mode="after", check_fields=False)
+    @classmethod
+    def normalize_percent(cls, v):
+        """Return percents as normalized percentage points."""
+        return float(v) / 100 if v else 0
+
+    @model_validator(mode="before")
+    @classmethod
+    def check_metric(cls, values):
+        """Check for missing metrics."""
+        for k, v in values.items():
+            if v is None or v == "-":
+                values[k] = 0
+            if k in ["Dividend Yield"]:
+                values[k] = float(v) / 100 if v else None
+        return values
+
+
+class TmxGainersFetcher(
+    Fetcher[
+        TmxGainersQueryParams,
+        List[TmxGainersData],
+    ]
+):
+    """TMX Gainers Fetcher."""
+
+    @staticmethod
+    def transform_query(params: Dict[str, Any]) -> TmxGainersQueryParams:
+        """Transform the query."""
+        return TmxGainersQueryParams(**params)
+
+    @staticmethod
+    async def aextract_data(
+        query: TmxGainersQueryParams,
+        credentials: Optional[Dict[str, str]],
+        **kwargs: Any,
+    ) -> List[TmxGainersData]:
+        """Return the raw data from the TMX endpoint."""
+        # pylint: disable=import-outside-toplevel
+        import json  # noqa
+        from openbb_tmx.utils import gql  # noqa
+        from openbb_tmx.utils.helpers import get_data_from_gql, get_random_agent  # noqa
+
+        user_agent = get_random_agent()
+        payload = gql.get_stock_list_payload.copy()
+        payload["variables"]["stockListId"] = STOCK_LISTS_DICT[query.category]
+
+        url = "https://app-money.tmx.com/graphql"
+        response = await get_data_from_gql(
+            method="POST",
+            url=url,
+            data=json.dumps(payload),
+            headers={
+                "authority": "app-money.tmx.com",
+                "referer": "https://money.tmx.com",
+                "locale": "en",
+                "Content-Type": "application/json",
+                "User-Agent": user_agent,
+                "Accept": "*/*",
+            },
+            timeout=5,
+        )
+        if "errors" in response:
+            raise EmptyDataError()
+        results = response["data"]["stockList"].get("listItems")
+        metric = response["data"]["stockList"].get("metricTitle")
+        for i in range(len(results)):  # pylint: disable=C0200
+            if "metric" in results[i]:
+                results[i][metric] = results[i]["metric"]
+                del results[i]["metric"]
+
+        return results
+
+    @staticmethod
+    def transform_data(
+        query: TmxGainersQueryParams,
+        data: List[Dict],
+        **kwargs: Any,
+    ) -> List[TmxGainersData]:
+        """Transform the data to the model."""
+        return [TmxGainersData.model_validate(d) for d in data]

openbb_platform/providers/tmx/openbb_tmx/models/historical_dividends.py

@@ -0,0 +1,111 @@
+"""TMX Stock Dividends Model"""
+
+# pylint: disable=unused-argument
+
+from datetime import date as dateType
+from typing import Any, Dict, List, Optional
+
+from openbb_core.provider.abstract.fetcher import Fetcher
+from openbb_core.provider.standard_models.historical_dividends import (
+    HistoricalDividendsData,
+    HistoricalDividendsQueryParams,
+)
+from pydantic import Field
+
+
+class TmxHistoricalDividendsQueryParams(HistoricalDividendsQueryParams):
+    """TMX Historical Dividends Query Params"""
+
+
+class TmxHistoricalDividendsData(HistoricalDividendsData):
+    """TMX Historical Dividends Data"""
+
+    __alias_dict__ = {
+        "ex_dividend_date": "exDate",
+        "record_date": "recordDate",
+        "payment_date": "payableDate",
+        "declaration_date": "declarationDate",
+    }
+    currency: Optional[str] = Field(
+        default=None, description="The currency the dividend is paid in."
+    )
+    decalaration_date: Optional[dateType] = Field(
+        default=None, description="The date of the announcement."
+    )
+    record_date: Optional[dateType] = Field(
+        default=None,
+        description="The record date of ownership for rights to the dividend.",
+    )
+    payment_date: Optional[dateType] = Field(
+        default=None, description="The date the dividend is paid."
+    )
+
+
+class TmxHistoricalDividendsFetcher(
+    Fetcher[TmxHistoricalDividendsQueryParams, List[TmxHistoricalDividendsData]]
+):
+    """TMX Historical Dividends Fetcher"""
+
+    @staticmethod
+    def transform_query(params: Dict[str, Any]) -> TmxHistoricalDividendsQueryParams:
+        """Transform the query."""
+        return TmxHistoricalDividendsQueryParams(**params)
+
+    @staticmethod
+    async def aextract_data(
+        query: TmxHistoricalDividendsQueryParams,
+        credentials: Optional[Dict[str, str]],
+        **kwargs: Any,
+    ) -> List[Dict]:
+        """Return the raw data from the TMX endpoint."""
+        # pylint: disable=import-outside-toplevel
+        import json  # noqa
+        from openbb_tmx.utils import gql  # noqa
+        from openbb_tmx.utils.helpers import get_data_from_gql, get_random_agent  # noqa
+
+        user_agent = get_random_agent()
+        symbol = (
+            query.symbol.upper()
+            .replace("-", ".")
+            .replace(".TO", "")
+            .replace(".TSX", "")
+        )
+        data = []
+        payload = gql.historical_dividends_payload.copy()
+        payload["variables"]["symbol"] = symbol
+        payload["variables"]["batch"] = 500
+        payload["variables"]["page"] = 1
+
+        url = "https://app-money.tmx.com/graphql"
+        response = await get_data_from_gql(
+            method="POST",
+            url=url,
+            data=json.dumps(payload),
+            headers={
+                "authority": "app-money.tmx.com",
+                "referer": f"https://money.tmx.com/en/quote/{symbol}",
+                "locale": "en",
+                "Content-Type": "application/json",
+                "User-Agent": user_agent,
+                "Accept": "*/*",
+            },
+            timeout=5,
+        )
+        try:
+            if response.get("data", {}).get("dividends"):  # type: ignore
+                data = response["data"]["dividends"]  # type: ignore
+                data = sorted(data["dividends"], key=lambda d: d["exDate"])  # type: ignore
+
+        except Exception as e:
+            raise RuntimeError(e) from e
+
+        return data
+
+    @staticmethod
+    def transform_data(
+        query: TmxHistoricalDividendsQueryParams,
+        data: List[Dict],
+        **kwargs: Any,
+    ) -> List[TmxHistoricalDividendsData]:
+        """Return the transformed data."""
+        return [TmxHistoricalDividendsData.model_validate(d) for d in data]

openbb_platform/providers/tmx/openbb_tmx/models/index_constituents.py

@@ -0,0 +1,98 @@
+"""TMX Index Constituents Model."""
+
+# pylint: disable=unused-argument
+
+from typing import Any, Dict, List, Optional
+
+from openbb_core.app.model.abstract.error import OpenBBError
+from openbb_core.provider.abstract.fetcher import Fetcher
+from openbb_core.provider.standard_models.index_constituents import (
+    IndexConstituentsData,
+    IndexConstituentsQueryParams,
+)
+from openbb_core.provider.utils.errors import EmptyDataError
+from pydantic import Field, field_validator
+
+
+class TmxIndexConstituentsQueryParams(IndexConstituentsQueryParams):
+    """TMX Index Constituents Query Params."""
+
+    use_cache: bool = Field(
+        default=True,
+        description="Whether to use a cached request."
+        + " Index data is from a single JSON file, updated each day after close."
+        + " It is cached for one day. To bypass, set to False.",
+    )
+
+
+class TmxIndexConstituentsData(IndexConstituentsData):
+    """TMX Index Constituents Data."""
+
+    __alias_dict__ = {
+        "market_value": "quotedmarketvalue",
+    }
+
+    market_value: Optional[float] = Field(
+        default=None,
+        description="The quoted market value of the asset.",
+    )
+
+    @field_validator("weight", mode="before", check_fields=False)
+    @classmethod
+    def normalize_percent(cls, v):
+        """Return percents as normalized percentage points."""
+        return float(v) / 100 if v else None
+
+
+class TmxIndexConstituentsFetcher(
+    Fetcher[
+        TmxIndexConstituentsQueryParams,
+        List[TmxIndexConstituentsData],
+    ]
+):
+    """TMX Index Constituents Fetcher."""
+
+    @staticmethod
+    def transform_query(params: Dict[str, Any]) -> TmxIndexConstituentsQueryParams:
+        """Transform the query."""
+        return TmxIndexConstituentsQueryParams(**params)
+
+    @staticmethod
+    async def aextract_data(
+        query: TmxIndexConstituentsQueryParams,
+        credentials: Optional[Dict[str, str]],
+        **kwargs: Any,
+    ) -> Dict:
+        """Return the raw data from the TMX endpoint."""
+        # pylint: disable=import-outside-toplevel
+        from openbb_tmx.utils.helpers import get_data_from_url, get_indices_backend
+
+        url = "https://tmxinfoservices.com/files/indices/sptsx-indices.json"
+
+        data = await get_data_from_url(
+            url,
+            use_cache=query.use_cache,
+            backend=get_indices_backend(),
+        )
+
+        return data
+
+    @staticmethod
+    def transform_data(
+        query: TmxIndexConstituentsQueryParams, data: Dict, **kwargs
+    ) -> List[TmxIndexConstituentsData]:
+        """Return the transformed data."""
+        results = []
+        data = data.copy()
+        if data == {}:
+            raise EmptyDataError
+        if query.symbol not in data.get("indices"):  # type: ignore
+            raise OpenBBError(f"Index {query.symbol} was not found. Check the symbol.")
+        index_data = data["indices"][query.symbol]
+        if (
+            index_data.get("nb_constituents") == 0
+            or index_data.get("constituents") is None
+        ):
+            raise OpenBBError(f"No constituents found for index, {query.symbol}")
+        results = index_data["constituents"]
+        return [TmxIndexConstituentsData.model_validate(d) for d in results]

openbb_platform/providers/tmx/openbb_tmx/models/index_sectors.py

@@ -0,0 +1,92 @@
+"""TMX Index Sectors fetcher."""
+
+# 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.index_sectors import (
+    IndexSectorsData,
+    IndexSectorsQueryParams,
+)
+from openbb_core.provider.utils.errors import EmptyDataError
+from pydantic import Field, field_validator
+
+
+class TmxIndexSectorsQueryParams(IndexSectorsQueryParams):
+    """TMX Index Sectors Query Params"""
+
+    use_cache: bool = Field(
+        default=True,
+        description="Whether to use a cached request. All Index data comes from a single JSON file that is updated daily."
+        + " To bypass, set to False. If True, the data will be cached for 1 day.",
+    )
+
+
+class TmxIndexSectorsData(IndexSectorsData):
+    """TMX Index Sectors Data."""
+
+    @field_validator("weight", mode="after", check_fields=False)
+    @classmethod
+    def normalize_percent(cls, v):
+        """Return percents as normalized percentage points."""
+        return float(v) / 100 if v else None
+
+
+class TmxIndexSectorsFetcher(
+    Fetcher[
+        TmxIndexSectorsQueryParams,
+        List[TmxIndexSectorsData],
+    ]
+):
+    """Transform the query, extract and transform the data from the TMX endpoints."""
+
+    @staticmethod
+    def transform_query(params: Dict[str, Any]) -> TmxIndexSectorsQueryParams:
+        """Transform the query."""
+        return TmxIndexSectorsQueryParams(**params)
+
+    @staticmethod
+    async def aextract_data(
+        query: TmxIndexSectorsQueryParams,
+        credentials: Optional[Dict[str, str]],
+        **kwargs: Any,
+    ) -> Dict:
+        """Return the raw data from the TMX endpoint."""
+        # pylint: disable=import-outside-toplevel
+        from openbb_tmx.utils.helpers import get_data_from_url, get_indices_backend
+
+        url = "https://tmxinfoservices.com/files/indices/sptsx-indices.json"
+
+        data = await get_data_from_url(
+            url,
+            use_cache=query.use_cache,
+            backend=get_indices_backend(),
+        )
+
+        return data
+
+    @staticmethod
+    def transform_data(
+        query: TmxIndexSectorsQueryParams, data: Dict, **kwargs: Any
+    ) -> List[TmxIndexSectorsData]:
+        """Return the transformed data."""
+        results = []
+        data = data.copy()
+        if data == {}:
+            raise EmptyDataError
+        if (
+            query.symbol in data["indices"]
+            and "sectors" in data["indices"][query.symbol]
+        ):
+            temp = data["indices"][query.symbol].get("sectors")
+            results = [
+                {
+                    "sector": d.get("name"),
+                    "weight": d.get("weight"),
+                }
+                for d in temp
+                if temp is not None
+            ]
+
+        return [TmxIndexSectorsData.model_validate(d) for d in results]

openbb_platform/providers/tmx/openbb_tmx/models/index_snapshots.py

@@ -0,0 +1,288 @@
+"""TMX Index Snapshots 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.index_snapshots import (
+    IndexSnapshotsData,
+    IndexSnapshotsQueryParams,
+)
+from openbb_core.provider.utils.errors import EmptyDataError
+from pydantic import Field, field_validator
+
+
+class TmxIndexSnapshotsQueryParams(IndexSnapshotsQueryParams):
+    """TMX Index Snapshots Query Params."""
+
+    region: Optional[Literal["ca", "us"]] = Field(default="ca")  # type: ignore
+    use_cache: bool = Field(
+        default=True,
+        description="Whether to use a cached request."
+        + " Index data is from a single JSON file, updated each day after close."
+        + " It is cached for one day. To bypass, set to False.",
+    )
+
+
+class TmxIndexSnapshotsData(IndexSnapshotsData):
+    """TMX Index Snapshots Data."""
+
+    __alias_dict__ = {
+        "name": "longname",
+        "prev_close": "prevClose",
+        "change": "priceChange",
+        "change_percent": "previousday",
+        "year_high": "weeks52high",
+        "year_low": "weeks52low",
+        "return_mtd": "monthtodate",
+        "return_qtd": "quartertodate",
+        "return_ytd": "yeartodate",
+        "total_market_value": "total",
+        "constituent_average_market_value": "average",
+        "constituent_median_market_value": "median",
+        "constituent_top10_market_value": "sumtop10",
+        "constituent_largest_market_value": "largest",
+        "constituent_largest_weight": "largestweight",
+        "constituent_smallest_market_value": "smallest",
+        "constituent_smallest_weight": "smallestweight",
+    }
+    year_high: Optional[float] = Field(
+        default=None, description="The 52-week high of the index."
+    )
+    year_low: Optional[float] = Field(
+        default=None, description="The 52-week low of the index."
+    )
+    return_mtd: Optional[float] = Field(
+        default=None,
+        description="The month-to-date return of the index, as a normalized percent.",
+        json_schema_extra={"x-unit_measurement": "percent", "x-frontend_multiply": 100},
+    )
+    return_qtd: Optional[float] = Field(
+        default=None,
+        description="The quarter-to-date return of the index, as a normalized percent.",
+        json_schema_extra={"x-unit_measurement": "percent", "x-frontend_multiply": 100},
+    )
+    return_ytd: Optional[float] = Field(
+        default=None,
+        description="The year-to-date return of the index, as a normalized percent.",
+        json_schema_extra={"x-unit_measurement": "percent", "x-frontend_multiply": 100},
+    )
+    total_market_value: Optional[float] = Field(
+        default=None,
+        description="The total quoted market value of the index.",
+    )
+    number_of_constituents: Optional[int] = Field(
+        default=None,
+        description="The number of constituents in the index.",
+    )
+    constituent_average_market_value: Optional[float] = Field(
+        default=None,
+        description="The average quoted market value of the index constituents.",
+    )
+    constituent_median_market_value: Optional[float] = Field(
+        default=None,
+        description="The median quoted market value of the index constituents.",
+    )
+    constituent_top10_market_value: Optional[float] = Field(
+        default=None,
+        description="The sum of the top 10 quoted market values of the index constituents.",
+    )
+    constituent_largest_market_value: Optional[float] = Field(
+        default=None,
+        description="The largest quoted market value of the index constituents.",
+    )
+    constituent_largest_weight: Optional[float] = Field(
+        default=None,
+        description="The largest weight of the index constituents, as a normalized percent.",
+        json_schema_extra={"x-unit_measurement": "percent", "x-frontend_multiply": 100},
+    )
+    constituent_smallest_market_value: Optional[float] = Field(
+        default=None,
+        description="The smallest quoted market value of the index constituents.",
+    )
+    constituent_smallest_weight: Optional[float] = Field(
+        default=None,
+        description="The smallest weight of the index constituents, as a normalized percent.",
+        json_schema_extra={"x-unit_measurement": "percent", "x-frontend_multiply": 100},
+    )
+
+    @field_validator(
+        "return_mtd",
+        "return_qtd",
+        "return_ytd",
+        "change_percent",
+        "constituent_largest_weight",
+        "constituent_smallest_weight",
+        mode="before",
+        check_fields=False,
+    )
+    @classmethod
+    def normalize_percent(cls, v):
+        """Return percents as normalized percentage points."""
+        return round(float(v) / 100, 6) if v else None
+
+    @field_validator(
+        "year_high",
+        "year_low",
+        "price",
+        "prev_close",
+        "change",
+        mode="before",
+        check_fields=False,
+    )
+    @classmethod
+    def round_floating(cls, v):
+        """Round floating values to two decimals."""
+        return round(float(v), 2) if v else None
+
+
+class TmxIndexSnapshotsFetcher(
+    Fetcher[
+        TmxIndexSnapshotsQueryParams,
+        List[TmxIndexSnapshotsData],
+    ]
+):
+    """TMX Index Snapshots Fetcher."""
+
+    @staticmethod
+    def transform_query(params: Dict[str, Any]) -> TmxIndexSnapshotsQueryParams:
+        """Transform the query."""
+        return TmxIndexSnapshotsQueryParams(**params)
+
+    @staticmethod
+    async def aextract_data(
+        query: TmxIndexSnapshotsQueryParams,
+        credentials: Optional[Dict[str, str]],
+        **kwargs: Any,
+    ) -> List[Dict]:
+        """Return the raw data from the TMX endpoint."""
+        # pylint: disable=import-outside-toplevel
+        import json  # noqa
+        from openbb_tmx.utils import gql  # noqa
+        from openbb_tmx.utils.helpers import (  # noqa
+            NASDAQ_GIDS,
+            get_data_from_gql,
+            get_data_from_url,
+            get_random_agent,
+            get_indices_backend,
+        )
+
+        url = "https://tmxinfoservices.com/files/indices/sptsx-indices.json"
+        user_agent = get_random_agent()
+        results = []
+        if query.region == "ca":
+            data = await get_data_from_url(
+                url,
+                use_cache=query.use_cache,
+                backend=get_indices_backend(),
+            )
+            if not data:
+                raise EmptyDataError
+            symbols = []
+
+            for symbol in data["indices"]:
+                symbols.append(symbol)
+                new_data = {}
+                performance = data["indices"][symbol].get("performance", {})
+                market_value = data["indices"][symbol].get("quotedmarketvalue", {})
+                new_data.update(
+                    {
+                        "symbol": symbol,
+                        "name": data["indices"][symbol].get("name_en", None),
+                        "currency": (
+                            "USD"
+                            if "(USD)" in data["indices"][symbol]["name_en"]
+                            else "CAD"
+                        ),
+                        **performance,
+                        **market_value,
+                    }
+                )
+                results.append(new_data)
+
+            # Get current levels for each index.
+
+            payload = gql.get_quote_for_symbols_payload.copy()
+            payload["variables"]["symbols"] = symbols
+
+            url = "https://app-money.tmx.com/graphql"
+            response = await get_data_from_gql(
+                method="POST",
+                url=url,
+                data=json.dumps(payload),
+                headers={
+                    "authority": "app-money.tmx.com",
+                    "referer": "https://money.tmx.com/en/quote/^TSX",
+                    "locale": "en",
+                    "Content-Type": "application/json",
+                    "User-Agent": user_agent,
+                    "Accept": "*/*",
+                },
+                timeout=5,
+            )
+            if response.get("data") and response["data"].get("getQuoteForSymbols"):
+                quote_data = response["data"]["getQuoteForSymbols"]
+                for d in data:
+                    if "longname" in d:
+                        d.pop("longname")
+                    if "percentChange" in d:
+                        d.pop("percentChange")
+                merged_list = [
+                    {
+                        **d1,
+                        **next(
+                            (d2 for d2 in quote_data if d2["symbol"] == d1["symbol"]),
+                            {},
+                        ),
+                    }
+                    for d1 in results
+                ]
+                results = merged_list
+
+        if query.region == "us":
+            symbols = [f"{symbol}:US" for symbol in NASDAQ_GIDS]
+            payload = gql.get_quote_for_symbols_payload.copy()
+            payload["variables"]["symbols"] = symbols
+
+            url = "https://app-money.tmx.com/graphql"
+            response = await get_data_from_gql(
+                method="POST",
+                url=url,
+                data=json.dumps(payload),
+                headers={
+                    "authority": "app-money.tmx.com",
+                    "referer": "https://money.tmx.com/en/quote/^TSX",
+                    "locale": "en",
+                    "Content-Type": "application/json",
+                    "User-Agent": user_agent,
+                    "Accept": "*/*",
+                },
+                timeout=5,
+            )
+            if response.get("data") and response["data"].get("getQuoteForSymbols"):
+                results = response["data"]["getQuoteForSymbols"]
+            for item in results:
+                item["change_percent"] = item.pop("percentChange")
+
+        return results
+
+    @staticmethod
+    def transform_data(
+        query: TmxIndexSnapshotsQueryParams,
+        data: List[Dict],
+        **kwargs: Any,
+    ) -> List[TmxIndexSnapshotsData]:
+        """Return the transformed data."""
+        return [
+            TmxIndexSnapshotsData.model_validate(
+                {
+                    "change_percent" if k == "percentChange" else k: (
+                        None if v in ["", 0] else v
+                    )
+                    for k, v in d.items()
+                }
+            )
+            for d in data
+            if "price" in d and d["price"] is not None
+        ]

openbb_platform/providers/tmx/openbb_tmx/models/insider_trading.py

@@ -0,0 +1,173 @@
+"""TMX Insider Trading 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.insider_trading import (
+    InsiderTradingData,
+    InsiderTradingQueryParams,
+)
+from openbb_core.provider.utils.errors import EmptyDataError
+from pydantic import Field, field_validator
+
+
+class TmxInsiderTradingQueryParams(InsiderTradingQueryParams):
+    """TMX Insider Trading Query Params."""
+
+    summary: bool = Field(
+        default=False,
+        description="Return a summary of the insider activity instead of the individuals.",
+    )
+
+
+class TmxInsiderTradingData(InsiderTradingData):
+    """TMX Insider Trading Data."""
+
+    period: str = Field(
+        description="The period of the activity. Bucketed by three, six, and twelve months."
+    )
+    owner_name: Optional[str] = Field(
+        default=None, description="The name of the insider."
+    )
+    acquisition_or_deposition: Optional[str] = Field(
+        default=None, description="Whether the insider bought or sold the shares."
+    )
+    number_of_trades: Optional[int] = Field(
+        default=None, description="The number of shares traded over the period."
+    )
+    securities_owned: Optional[int] = Field(
+        default=None, description="The number of shares held by the insider."
+    )
+    trade_value: Optional[float] = Field(
+        default=None, description="The value of the shares traded by the insider."
+    )
+    securities_transacted: Optional[int] = Field(
+        default=None,
+        description="The total number of shares traded by the insider over the period.",
+    )
+    securities_bought: Optional[int] = Field(
+        default=None,
+        description="The total number of shares bought by all insiders over the period.",
+    )
+    securities_sold: Optional[int] = Field(
+        default=None,
+        description="The total number of shares sold by all insiders over the period.",
+    )
+    net_activity: Optional[int] = Field(
+        default=None,
+        description="The total net activity by all insiders over the period.",
+    )
+
+    @field_validator("period", mode="before", check_fields=False)
+    @classmethod
+    def period_to_snake_case(cls, v):
+        """Convert the period to snake case."""
+        # pylint: disable=import-outside-toplevel
+        from openbb_core.provider.utils.helpers import to_snake_case
+
+        return to_snake_case(v) if v else None
+
+
+class TmxInsiderTradingFetcher(
+    Fetcher[
+        TmxInsiderTradingQueryParams,
+        List[TmxInsiderTradingData],
+    ]
+):
+    """TMX Insider Trading Fetcher."""
+
+    @staticmethod
+    def transform_query(params: Dict[str, Any]) -> TmxInsiderTradingQueryParams:
+        """Transform the query."""
+        return TmxInsiderTradingQueryParams(**params)
+
+    @staticmethod
+    async def aextract_data(
+        query: TmxInsiderTradingQueryParams,
+        credentials: Optional[Dict[str, str]],
+        **kwargs: Any,
+    ) -> List[Dict]:
+        """Return the raw data from the TMX endpoint."""
+        # pylint: disable=import-outside-toplevel
+        import json  # noqa
+        from openbb_tmx.utils import gql  # noqa
+        from openbb_tmx.utils.helpers import get_data_from_gql, get_random_agent  # noqa
+
+        results: List = []
+        user_agent = get_random_agent()
+        symbol = (
+            query.symbol.upper()
+            .replace("-", ".")
+            .replace(".TO", "")
+            .replace(".TSX", "")
+        )
+        payload = gql.get_company_insiders_payload.copy()
+        payload["variables"]["symbol"] = symbol
+
+        url = "https://app-money.tmx.com/graphql"
+        response = await get_data_from_gql(
+            method="POST",
+            url=url,
+            data=json.dumps(payload),
+            headers={
+                "authority": "app-money.tmx.com",
+                "referer": f"https://money.tmx.com/en/quote/{symbol}",
+                "locale": "en",
+                "Content-Type": "application/json",
+                "User-Agent": user_agent,
+                "Accept": "*/*",
+            },
+            timeout=5,
+        )
+
+        if response.get("data") and response["data"].get(  # type: ignore
+            "getCompanyInsidersActivities"
+        ):
+            results = response["data"]["getCompanyInsidersActivities"]  # type: ignore
+
+        if not results:
+            raise EmptyDataError()
+
+        return results
+
+    @staticmethod
+    def transform_data(
+        query: TmxInsiderTradingQueryParams,
+        data: List[Dict],
+        **kwargs: Any,
+    ) -> List[TmxInsiderTradingData]:
+        """Transform the data."""
+        data = data.copy()
+        results = []
+        flattened_insiders = []
+        for activity in data["insiderActivities"]:  # type: ignore
+            for transaction_type in ["buy", "sell"]:
+                for transaction in activity[transaction_type]:
+                    new_transaction = {
+                        "period": activity["periodkey"],
+                        "acquisition_or_disposition": transaction_type,
+                        "owner_name": transaction["name"],
+                        "number_of_trades": transaction["trades"],
+                        "securities_transacted": transaction["shares"],
+                        "securities_owned": transaction["sharesHeld"],
+                        "trade_value": transaction["tradeValue"],
+                    }
+                    flattened_insiders.append(new_transaction)
+        flattened_summary = []
+        for activity in data["activitySummary"]:  # type: ignore
+            new_activity = {
+                "period": activity["periodkey"],
+                "securities_bought": activity["buyShares"],
+                "securities_sold": activity["soldShares"],
+                "net_activity": activity["netActivity"],
+                "securities_transacted": activity["totalShares"],
+            }
+            flattened_summary.append(new_activity)
+        if query.summary is False and len(flattened_insiders) > 0:
+            results = flattened_insiders
+        elif query.summary is True and len(flattened_summary) > 0:
+            results = flattened_summary
+
+        return [TmxInsiderTradingData.model_validate(d) for d in results]

openbb_platform/providers/tmx/openbb_tmx/models/options_chains.py

@@ -0,0 +1,115 @@
+"""TMX Options Chains Model."""
+
+# pylint: disable=unused-argument
+from datetime import (
+    date as dateType,
+    datetime,
+)
+from typing import Any, Dict, List, Optional, Union
+
+from openbb_core.provider.abstract.fetcher import Fetcher
+from openbb_core.provider.standard_models.options_chains import (
+    OptionsChainsData,
+    OptionsChainsQueryParams,
+)
+from openbb_core.provider.utils.descriptions import (
+    QUERY_DESCRIPTIONS,
+)
+from pydantic import Field, field_validator
+
+
+class TmxOptionsChainsQueryParams(OptionsChainsQueryParams):
+    """TMX Options Chains Query.
+
+    Source: https://www.Tmx.com/
+    """
+
+    date: Optional[dateType] = Field(
+        description=QUERY_DESCRIPTIONS.get("date", ""),
+        default=None,
+    )
+    use_cache: bool = Field(
+        default=True,
+        description="Caching is used to validate the supplied ticker symbol, or if a historical EOD chain is requested."
+        + " To bypass, set to False.",
+    )
+
+
+class TmxOptionsChainsData(OptionsChainsData):
+    """TMX Options Chains Data."""
+
+    __doc__ = OptionsChainsData.__doc__
+
+    transactions: List[Union[int, None]] = Field(
+        default_factory=list, description="Number of transactions for the contract."
+    )
+    total_value: List[Union[float, None]] = Field(
+        default_factory=list,
+        description="Total value of the transactions.",
+    )
+    settlement_price: List[Union[float, None]] = Field(
+        default_factory=list,
+        description="Settlement price on that date.",
+    )
+
+    @field_validator("expiration", mode="before", check_fields=False)
+    @classmethod
+    def date_validate(cls, v):
+        """Return the datetime object from the date string"""
+        return [datetime.strptime(d, "%Y-%m-%d") for d in v]
+
+
+class TmxOptionsChainsFetcher(
+    Fetcher[
+        TmxOptionsChainsQueryParams,
+        TmxOptionsChainsData,
+    ]
+):
+    """TMX Options Chains Fetcher."""
+
+    @staticmethod
+    def transform_query(params: Dict[str, Any]) -> TmxOptionsChainsQueryParams:
+        """Transform the query."""
+        return TmxOptionsChainsQueryParams(**params)
+
+    @staticmethod
+    async def aextract_data(
+        query: TmxOptionsChainsQueryParams,
+        credentials: Optional[Dict[str, str]],
+        **kwargs: Any,
+    ) -> Dict:
+        """Return the data."""
+        # pylint: disable=import-outside-toplevel
+        from openbb_tmx.models.equity_quote import TmxEquityQuoteFetcher
+        from openbb_tmx.utils.helpers import download_eod_chains, get_current_options
+        from pandas import DataFrame
+
+        results: Dict = {}
+        chains = DataFrame()
+        if query.date is not None:
+            chains = await download_eod_chains(
+                symbol=query.symbol, date=query.date, use_cache=query.use_cache
+            )
+        else:
+            chains = await get_current_options(query.symbol, use_cache=query.use_cache)
+            underlying_quote = await TmxEquityQuoteFetcher.fetch_data(
+                {"symbol": query.symbol}, credentials
+            )
+            underlying_price = underlying_quote[0].last_price  # type: ignore
+            if underlying_price and not chains.empty:
+                chains["underlying_price"] = underlying_price
+                chains["underlying_symbol"] = query.symbol + ":CA"
+
+        if not chains.empty:
+            results = chains.to_dict(orient="list")
+
+        return results
+
+    @staticmethod
+    def transform_data(
+        query: TmxOptionsChainsQueryParams,
+        data: Dict,
+        **kwargs: Any,
+    ) -> TmxOptionsChainsData:
+        """Transform the data and validate the model."""
+        return TmxOptionsChainsData.model_validate(data)

openbb_platform/providers/tmx/openbb_tmx/models/price_target_consensus.py

@@ -0,0 +1,172 @@
+"""TMX Stock Analysts Model."""
+
+# pylint: disable=unused-argument
+
+from typing import Any, Dict, List, Optional
+
+from openbb_core.app.model.abstract.error import OpenBBError
+from openbb_core.provider.abstract.fetcher import Fetcher
+from openbb_core.provider.standard_models.price_target_consensus import (
+    PriceTargetConsensusData,
+    PriceTargetConsensusQueryParams,
+)
+from pydantic import Field, field_validator
+
+
+class TmxPriceTargetConsensusQueryParams(PriceTargetConsensusQueryParams):
+    """TMX Price Target Consensus Query."""
+
+    __json_schema_extra__ = {"symbol": {"multiple_items_allowed": True}}
+
+    @field_validator("symbol", mode="before", check_fields=False)
+    @classmethod
+    def check_symbol(cls, value):
+        """Check the symbol."""
+        if not value:
+            raise OpenBBError("Symbol is a required field for TMX.")
+        return value
+
+
+class TmxPriceTargetConsensusData(PriceTargetConsensusData):
+    """TMX Price Target Consensus Data."""
+
+    __alias_dict__ = {
+        "target_consensus": "price_target",
+        "target_high": "price_target_high",
+        "target_low": "price_target_low",
+        "target_upside": "price_target_upside",
+    }
+
+    target_upside: Optional[float] = Field(
+        default=None,
+        description="Percent of upside, as a normalized percent.",
+        json_schema_extra={"x-unit_measurement": "percent", "x-frontend_multiply": 100},
+    )
+    total_analysts: Optional[int] = Field(
+        default=None, description="Total number of analyst."
+    )
+    buy_ratings: Optional[int] = Field(
+        default=None, description="Number of buy ratings."
+    )
+    sell_ratings: Optional[int] = Field(
+        default=None, description="Number of sell ratings."
+    )
+    hold_ratings: Optional[int] = Field(
+        default=None, description="Number of hold ratings."
+    )
+    consensus_action: Optional[str] = Field(
+        default=None, description="Consensus action."
+    )
+
+    @field_validator("target_upside", mode="before", check_fields=False)
+    @classmethod
+    def normalize_percent(cls, v):
+        """Return percents as normalized percentage points."""
+        return float(v) / 100 if v else None
+
+    @field_validator(
+        "target_consensus",
+        "target_high",
+        "target_low",
+        mode="before",
+        check_fields=False,
+    )
+    @classmethod
+    def round_targets(cls, v):
+        """Return rounded prices to two decimals."""
+        return round(float(v), 2) if v else None
+
+
+class TmxPriceTargetConsensusFetcher(
+    Fetcher[TmxPriceTargetConsensusQueryParams, List[TmxPriceTargetConsensusData]]
+):
+    """Transform the query, extract and transform the data from the TMX endpoints."""
+
+    @staticmethod
+    def transform_query(params: Dict[str, Any]) -> TmxPriceTargetConsensusQueryParams:
+        """Transform the query."""
+        return TmxPriceTargetConsensusQueryParams(**params)
+
+    @staticmethod
+    async def aextract_data(
+        query: TmxPriceTargetConsensusQueryParams,
+        credentials: Optional[Dict[str, str]],
+        **kwargs: Any,
+    ) -> List[Dict]:
+        """Return the raw data from the TMX endpoint."""
+        # pylint: disable=import-outside-toplevel
+        import asyncio  # noqa
+        import json  # noqa
+        from openbb_tmx.utils import gql  # noqa
+        from openbb_tmx.utils.helpers import get_data_from_gql, get_random_agent  # noqa
+
+        symbols = query.symbol.split(",")  # type: ignore
+        results: List[Dict] = []
+
+        async def create_task(symbol, results):
+            """Create a task for each symbol provided."""
+            symbol = (
+                symbol.upper()
+                .replace("-", ".")
+                .replace(".TO", "")
+                .replace(".TSXV", "")
+                .replace(".TSX", "")
+            )
+
+            payload = gql.get_company_analysts_payload.copy()
+            payload["variables"]["symbol"] = symbol
+            payload["variables"]["datatype"] = "equity"
+
+            data = {}
+            url = "https://app-money.tmx.com/graphql"
+            response = await get_data_from_gql(
+                method="POST",
+                url=url,
+                data=json.dumps(payload),
+                headers={
+                    "authority": "app-money.tmx.com",
+                    "referer": f"https://money.tmx.com/en/quote/{symbol}",
+                    "locale": "en",
+                    "Content-Type": "application/json",
+                    "User-Agent": get_random_agent(),
+                    "Accept": "*/*",
+                },
+                timeout=10,
+            )
+            r_data = (
+                response["data"].get("analysts", None) if response.get("data") else None
+            )
+            if r_data:
+                data.update(
+                    {
+                        "symbol": symbol,
+                        "total_analysts": r_data["totalAnalysts"],
+                        "consensus_action": r_data["consensusAnalysts"]["consensus"],
+                        "buy_ratings": r_data["consensusAnalysts"]["buy"],
+                        "sell_ratings": r_data["consensusAnalysts"]["sell"],
+                        "hold_ratings": r_data["consensusAnalysts"]["hold"],
+                        "price_target": r_data["priceTarget"]["priceTarget"],
+                        "price_target_high": r_data["priceTarget"]["highPriceTarget"],
+                        "price_target_low": r_data["priceTarget"]["lowPriceTarget"],
+                        "price_target_upside": r_data["priceTarget"][
+                            "priceTargetUpside"
+                        ],
+                    }
+                )
+                results.append(data)
+            return results
+
+        tasks = [create_task(symbol, results) for symbol in symbols]
+
+        await asyncio.gather(*tasks)
+
+        return results
+
+    @staticmethod
+    def transform_data(
+        query: TmxPriceTargetConsensusQueryParams,
+        data: List[Dict],
+        **kwargs: Any,
+    ) -> List[TmxPriceTargetConsensusData]:
+        """Return the transformed data."""
+        return [TmxPriceTargetConsensusData.model_validate(d) for d in data]

openbb_platform/providers/tmx/openbb_tmx/models/treasury_prices.py

@@ -0,0 +1,161 @@
+"""TMX Treasury Prices Fetcher."""
+
+# pylint: disable=unused-argument
+
+from datetime import date as dateType
+from typing import TYPE_CHECKING, Any, Dict, List, Literal, Optional
+
+from openbb_core.provider.abstract.fetcher import Fetcher
+from openbb_core.provider.standard_models.treasury_prices import (
+    TreasuryPricesData,
+    TreasuryPricesQueryParams,
+)
+from pydantic import Field, field_validator
+
+if TYPE_CHECKING:
+    from pandas import DataFrame
+
+
+class TmxTreasuryPricesQueryParams(TreasuryPricesQueryParams):
+    """TMX Treasury Prices Query Params.
+
+    Data will be made available by 5:00 EST on T+1
+
+    Source: https://bondtradedata.iiroc.ca/#/
+    """
+
+    govt_type: Literal["federal", "provincial", "municipal"] = Field(
+        default="federal",
+        description="The level of government issuer.",
+    )
+    issue_date_min: Optional[dateType] = Field(
+        default=None,
+        description="Filter by the minimum original issue date.",
+    )
+    issue_date_max: Optional[dateType] = Field(
+        default=None,
+        description="Filter by the maximum original issue date.",
+    )
+    last_traded_min: Optional[dateType] = Field(
+        default=None,
+        description="Filter by the minimum last trade date.",
+    )
+    maturity_date_min: Optional[dateType] = Field(
+        default=None,
+        description="Filter by the minimum maturity date.",
+    )
+    maturity_date_max: Optional[dateType] = Field(
+        default=None,
+        description="Filter by the maximum maturity date.",
+    )
+    use_cache: bool = Field(
+        default=True,
+        description="All bond data is sourced from a single JSON file that is updated daily."
+        + " The file is cached for one day to eliminate downloading more than once."
+        + " Caching will significantly speed up subsequent queries. To bypass, set to False.",
+    )
+
+
+class TmxTreasuryPricesData(TreasuryPricesData):
+    """TMX Treasury Prices Data."""
+
+    __alias_dict__ = {
+        "rate": "couponRate",
+        "ytm": "lastYield",
+        "last_price": "lastPrice",
+        "highest_price": "highestPrice",
+        "lowest_price": "lowestPrice",
+        "total_trades": "totalTrades",
+        "last_traded_date": "lastTradedDate",
+        "maturity_date": "maturityDate",
+        "issue_date": "originalIssueDate",
+        "issuer_name": "issuer",
+    }
+
+    @field_validator(
+        "ytm",
+        "rate",
+        mode="before",
+        check_fields=False,
+    )
+    @classmethod
+    def normalize_percent(cls, v):
+        """Return percents as normalized percentage points."""
+        return float(v) / 100 if v else None
+
+
+class TmxTreasuryPricesFetcher(
+    Fetcher[
+        TmxTreasuryPricesQueryParams,
+        List[TmxTreasuryPricesData],
+    ]
+):
+    """Tmx Bond Reference Fetcher."""
+
+    @staticmethod
+    def transform_query(params: Dict[str, Any]) -> TmxTreasuryPricesQueryParams:
+        """Transform query params."""
+        # pylint: disable=import-outside-toplevel
+        from datetime import timedelta
+
+        transformed_params = params.copy()
+        yesterday = dateType.today() - timedelta(days=1)
+        last_bd = (
+            yesterday - timedelta(yesterday.weekday() - 4)
+            if yesterday.weekday() > 4
+            else yesterday
+        )
+        if "maturity_date_min" not in transformed_params:
+            transformed_params["maturity_date_min"] = last_bd
+        return TmxTreasuryPricesQueryParams(**transformed_params)
+
+    @staticmethod
+    async def aextract_data(
+        query: TmxTreasuryPricesQueryParams,
+        credentials: Optional[Dict[str, str]],
+        **kwargs: Any,
+    ) -> "DataFrame":
+        """Get the raw data containing all bond data."""
+        # pylint: disable=import-outside-toplevel
+        from openbb_tmx.utils.helpers import get_all_bonds
+
+        bonds = await get_all_bonds(use_cache=query.use_cache)
+
+        return bonds
+
+    @staticmethod
+    def transform_data(
+        query: TmxTreasuryPricesQueryParams,
+        data: "DataFrame",
+        **kwargs: Any,
+    ) -> List[TmxTreasuryPricesData]:
+        """Transform data."""
+        bonds = data.copy()
+        results = []
+        govt_type_dict = {
+            "provincial": "prov",
+            "federal": "government of canada",
+            "municipal": "municipal",
+        }
+        govt_type = govt_type_dict[query.govt_type]  # noqa  # pylint: disable=W0612
+        data = bonds.query(
+            "maturityDate >= @query.maturity_date_min.strftime('%Y-%m-%d')"
+            + " & bondType == 'Govt'"
+            + " & issuer.str.contains(@govt_type, case=False)"
+        ).sort_values(by=["maturityDate"])
+        data.issuer = data.loc[:, "issuer"].str.strip()
+        if query.maturity_date_max:
+            data = data.query(
+                "maturityDate <= @query.maturity_date_max.strftime('%Y-%m-%d')"
+            )
+        if query.last_traded_min:
+            data = data.query(
+                "lastTradedDate >= @query.last_traded_min.strftime('%Y-%m-%d')"
+            )
+
+        if len(data) > 0:
+            data = data.drop(columns=["bondType", "securityId", "secKey"])
+            data = data.fillna("N/A").replace("N/A", None)
+            results = data.to_dict("records")
+
+        return [TmxTreasuryPricesData.model_validate(d) for d in results]

openbb_platform/providers/tmx/openbb_tmx/utils/__init__.py

@@ -0,0 +1 @@
+"""TMX Provider Utils."""

openbb_platform/providers/tmx/openbb_tmx/utils/gql.py

@@ -0,0 +1,513 @@
+"""GraphQL query definitions."""
+
+# pylint: disable=line-too-long
+# ruff: noqa: E501
+
+stock_info_query = """ query getQuoteBySymbol(
+  $symbol: String,
+  $locale: String
+) {
+  getQuoteBySymbol(symbol: $symbol, locale: $locale) {
+    symbol
+    name
+    price
+    priceChange
+    percentChange
+    exchangeName
+    exShortName
+    exchangeCode
+    sector
+    industry
+    volume
+    openPrice
+    dayHigh
+    dayLow
+    MarketCap
+    MarketCapAllClasses
+    peRatio
+    prevClose
+    dividendFrequency
+    dividendYield
+    dividendAmount
+    dividendCurrency
+    beta
+    eps
+    exDividendDate
+    shortDescription
+    longDescription
+    website
+    email
+    phoneNumber
+    fullAddress
+    employees
+    shareOutStanding
+    totalDebtToEquity
+    totalSharesOutStanding
+    sharesESCROW
+    vwap
+    dividendPayDate
+    weeks52high
+    weeks52low
+    alpha
+    averageVolume10D
+    averageVolume30D
+    averageVolume50D
+    priceToBook
+    priceToCashFlow
+    returnOnEquity
+    returnOnAssets
+    day21MovingAvg
+    day50MovingAvg
+    day200MovingAvg
+    dividend3Years
+    dividend5Years
+    datatype
+    issueType
+    qmdescription
+  }
+}
+"""
+
+stock_info_payload = {
+    "operationName": "getQuoteBySymbol",
+    "variables": {"locale": "en"},
+    "query": stock_info_query,
+}
+
+get_timeseries_query = """query getTimeSeriesData($symbol: String!, $freq: String, $interval: Int, $start: String, $end: String, $startDateTime: Int, $endDateTime: Int) {
+ getTimeSeriesData(
+ symbol: $symbol
+ freq: $freq
+ interval: $interval
+ start: $start
+ end: $end
+ startDateTime: $startDateTime
+ endDateTime: $endDateTime
+ ) {
+ dateTime
+ open
+ high
+ low
+ close
+ volume
+}
+}"""
+
+get_timeseries_payload = {
+    "operationName": "getTimeSeriesData",
+    "variables": {
+        "symbol": "BNS",
+        "freq": "day",
+        "interval": "",
+        "start": "2013-09-30",
+        "end": "2013-10-31",
+        "startDateTime": "",
+        "endDateTime": "",
+    },
+    "query": get_timeseries_query,
+}
+
+get_company_price_history_query = """query getCompanyPriceHistory($symbol: String!, $start: String, $end: String, $adjusted: Boolean, $adjustmentType: String, $unadjusted: Boolean, $limit: Int) {
+ getCompanyPriceHistory(
+ symbol: $symbol
+ start: $start
+ end: $end
+ adjusted: $adjusted
+ adjustmentType: $adjustmentType
+ unadjusted: $unadjusted
+ limit: $limit
+ ) {
+ datetime
+ openPrice
+ closePrice
+ high
+ low
+ volume
+ tradeValue
+ numberOfTrade
+ change
+ changePercent
+ vwap
+}
+}"""
+
+get_company_price_history_payload = {
+    "operationName": "getCompanyPriceHistory",
+    "variables": {
+        "adjusted": True,
+        "adjustmentType": "SO",
+        "end": "2023-10-28",
+        "start": "2023-10-01",
+        "symbol": "BNS",
+        "unadjusted": False,
+    },
+    "query": get_company_price_history_query,
+}
+
+get_company_most_recent_trades_query = """query getCompanyMostRecentTrades(
+  $symbol: String!
+  $limit: Int
+) {
+trades: getCompanyMostRecentTrades(
+  symbol: $symbol,
+  limit: $limit
+) {
+  price
+  volume
+  datetime
+  sellerId
+  sellerName
+  buyerId
+  buyerName
+  exchangeCode
+  }
+}
+"""
+
+get_company_most_recent_trades_payload = {
+    "operationName": "getCompanyMostRecentTrades",
+    "variables": {
+        "symbol": "BNS",
+        "limit": 51,
+    },
+    "query": get_company_most_recent_trades_query,
+}
+
+get_company_news_events_query = """query getNewsAndEvents(
+  $symbol: String!,
+  $page: Int!,
+  $limit: Int!,
+  $locale: String!
+) {
+  news: getNewsForSymbol(
+    symbol: $symbol,
+    page: $page,
+    limit: $limit,
+    locale: $locale
+  ) {
+    headline
+    datetime
+    source
+    newsid
+    summary
+  }
+  events: getUpComingEventsForSymbol(symbol: $symbol, locale: $locale) {
+    title
+    date
+    status
+    type
+    }
+  }
+"""
+
+get_company_news_events_payload = {
+    "operationName": "getNewsAndEvents",
+    "variables": {"symbol": "ART", "page": 1, "limit": 100, "locale": "en"},
+    "query": get_company_news_events_query,
+}
+
+get_company_filings_query = """query getCompanyFilings($symbol: String!, $fromDate: String, $toDate: String, $limit: Int) {
+  filings: getCompanyFilings(
+  symbol: $symbol
+  fromDate: $fromDate
+  toDate: $toDate
+  limit: $limit
+  ) {
+size
+filingDate
+description
+name
+urlToPdf
+}
+}"""
+
+get_company_filings_payload = {
+    "operationName": "getCompanyFilings",
+    "variables": {
+        "symbol": "AC",
+        "fromDate": "2020-09-01",
+        "toDate": "2023-09-20",
+        "limit": 100,
+    },
+    "query": get_company_filings_query,
+}
+
+historical_dividends_query = """query getDividendsForSymbol(
+  $symbol: String!
+  $page: Int,
+  $batch: Int
+) {
+  dividends: getDividendsForSymbol(
+    symbol: $symbol
+    page: $page
+    batch: $batch
+  ) {
+    pageNumber
+    hasNextPage
+    dividends
+      {
+        exDate
+        amount
+        currency
+        payableDate
+        declarationDate
+        recordDate
+    }
+  }
+}"""
+
+historical_dividends_payload = {
+    "operationName": "getDividendsForSymbol",
+    "variables": {
+        "batch": 10,
+        "page": 1,
+        "symbol": "BNS",
+    },
+    "query": historical_dividends_query,
+}
+
+get_company_analysts_query = """query getCompanyAnalysts(
+  $symbol: String!
+  $dataType: String,
+) {
+  analysts: getCompanyAnalysts(
+    datatype: $dataType,
+    symbol: $symbol
+  ) {
+    totalAnalysts
+    priceTarget
+      {
+        highPriceTarget
+        lowPriceTarget
+        priceTarget
+        priceTargetUpside
+    }
+    consensusAnalysts
+      {
+      consensus
+      buy
+      sell
+      hold
+    }
+  }
+}"""
+
+get_company_analysts_payload = {
+    "operationName": "getCompanyAnalysts",
+    "variables": {
+        "symbol": "BNS",
+        "datatype": "equity",
+    },
+    "query": get_company_analysts_query,
+}
+
+get_earnings_date_query = """query getEnhancedEarningsForDate(
+  $date: String!
+  ) {
+  getEnhancedEarningsForDate(
+    date: $date
+) {
+      symbol
+      companyName
+      announceTime
+      estimatedEps
+      actualEps
+      epsSurprisePercent
+      epsSurpriseDollar
+  }
+}"""
+
+get_earnings_date_payload = {
+    "operationName": "getEnhancedEarningsForDate",
+    "variables": {
+        "date": "2023-10-04",
+    },
+    "query": get_earnings_date_query,
+}
+
+get_index_overview_query = """query getIndexBySymbol(
+  $symbol: String!,
+  $locale: String
+  ) {
+  getIndexBySymbol(
+    symbol: $symbol,
+    locale: $locale
+) {
+      name
+      intro
+      overview
+  }
+}"""
+
+get_index_overview_payload = {
+    "operationName": "getIndexBySymbol",
+    "variables": {
+        "symbol": "^TSX",
+    },
+    "query": get_index_overview_query,
+}
+
+get_index_constituents_query = """query getIndexConstituents(
+  $symbol: String!
+) {
+    constituents: getIndexConstituents(
+      symbol: $symbol
+  ) {
+      symbol
+      quotedMarketValue
+      longName
+      shortName
+      weight
+      exShortName
+      exchange
+      exLongName
+  }
+    keyData: getIndexKeyData(
+      symbol: $symbol
+  ) {
+      adjMarketCap
+      avgConstituentMarketCap
+      numConstituents
+      top10HoldingsAdjMarketCap
+      ytdPriceReturn
+      prevDayPriceReturn
+      prevMonthPriceReturn
+      prevQuarterPriceReturn
+      percentWeightLargestConstituent
+      peRatio
+      pbRatio
+      priceToSales
+      divYield
+      pcfRatio
+    }
+  }"""
+
+get_index_constituents_payload = {
+    "operationName": "getIndexConstituents",
+    "variables": {
+        "symbol": "^TSX",
+    },
+    "query": get_index_constituents_query,
+}
+
+get_stock_list_query = """query getStockListSymbolsWithQuote(
+  $stockListId: String!
+  $locale: String,
+) {
+  stockList: getStockListSymbolsWithQuote(
+    stockListId: $stockListId,
+    locale: $locale
+  ) {
+    stockListId
+    name
+    description
+    longDescription
+    metricTitle
+    listItems
+      {
+        symbol
+        longName
+        rank
+        metric
+        price
+        priceChange
+        percentChange
+        volume
+    }
+    totalPriceChange
+    totalPercentChange
+    createdAt
+    updatedAt
+  }
+}"""
+
+get_stock_list_payload = {
+    "operationName": "getStockListSymbolsWithQuote",
+    "variables": {"locale": "en", "stockListId": "TOP_VOLUME"},
+    "query": get_stock_list_query,
+}
+
+get_company_insiders_query = """query getCompanyInsidersActivities(
+    $symbol: String
+) {
+    getCompanyInsidersActivities(
+      symbol: $symbol
+  ) {
+    insiderActivities {
+      periodkey
+      buy {
+        name
+        trades
+        shares
+        sharesHeld
+        tradeValue
+    }
+      sell {
+        name
+        trades
+        shares
+        sharesHeld
+        tradeValue
+    }
+  }
+    activitySummary {
+      periodkey
+      buyShares
+      soldShares
+      netActivity
+      totalShares
+    }
+  }
+}"""
+
+get_company_insiders_payload = {
+    "operationName": "getCompanyInsidersActivities",
+    "variables": {
+        "symbol": "CNQ",
+    },
+    "query": get_company_insiders_query,
+}
+
+
+get_quote_for_symbols_query = """query getQuoteForSymbols($symbols: [String]) {
+ getQuoteForSymbols(symbols: $symbols) {
+ symbol
+ longname
+ price
+ prevClose
+ priceChange
+ percentChange
+ weeks52high
+ weeks52low
+ }
+}"""
+
+get_quote_for_symbols_payload = {
+    "operationName": "getQuoteForSymbols",
+    "variables": {
+        "symbols": [
+            "SRE:US",
+            "BWVTF:US",
+            "C.P.K:US",
+            "BAC.PY:US",
+            "BALTF:US",
+            "BACRP:US",
+        ],
+    },
+    "query": get_quote_for_symbols_query,
+}
+
+get_index_price_history_query = """query getIndexPriceHistory($symbol: String!, $start: String, $end: String, $adjusted: Boolean, $adjustmentType: String, $unadjusted: Boolean, $limit: Int) {\n  getIndexPriceHistory(\n    symbol: $symbol\n    start: $start\n    end: $end\n    adjusted: $adjusted\n    adjustmentType: $adjustmentType\n    unadjusted: $unadjusted\n    limit: $limit\n  ) {\n    datetime\n    openPrice\n    closePrice\n    high\n    low\n    volume\n    change\n    changePercent\n    triv\n      }\n}"}"""
+
+get_index_price_history_payload = {
+    "operationName": "getIndexPriceHistory",
+    "variables": {
+        "symbol": "^TSX",
+        "start": "2023-12-01",
+        "end": "2023-12-31",
+        "adjusted": True,
+        "adjustmentType": "SO",
+        "unadjusted": False,
+    },
+    "query": get_index_price_history_query,
+}

openbb_platform/providers/tmx/openbb_tmx/utils/helpers.py

@@ -0,0 +1,1147 @@
+"""TMX Helpers Module."""
+
+# pylint: disable=too-many-lines,unused-argument,simplifiable-if-expression
+
+from datetime import (
+    date as dateType,
+    datetime,
+    time,
+    timedelta,
+)
+from typing import TYPE_CHECKING, Any, Dict, List, Literal, Optional, Union
+
+from openbb_core.app.model.abstract.error import OpenBBError
+from openbb_tmx.utils import gql
+
+if TYPE_CHECKING:
+    from aiohttp_client_cache import SQLiteBackend
+    from pandas import DataFrame
+
+# Column map for ETFs.
+COLUMNS_DICT = {
+    "symbol": "symbol",
+    "shortname": "short_name",
+    "longname": "name",
+    "fundfamily": "fund_family",
+    "regions": "regions",
+    "sectors": "sectors",
+    "currency": "currency",
+    "inceptiondate": "inception_date",
+    "unitprice": "unit_price",
+    "prevClose": "prev_close",
+    "close": "close",
+    "esg": "esg",
+    "investmentstyle": "investment_style",
+    "avgdailyvolume": "volume_avg_daily",
+    "totalreturn1month": "return_1m",
+    "totalreturn3month": "return_3m",
+    "totalreturn1year": "return_1y",
+    "totalreturn3year": "return_3y",
+    "totalreturn5year": "return_5y",
+    "totalreturnytd": "return_ytd",
+    "totalreturnsinceinception": "return_from_inception",
+    "distributionyeld": "distribution_yield",
+    "dividendfrequency": "dividend_frequency",
+    "pricetoearnings": "pe_ratio",
+    "pricetobook": "pb_ratio",
+    "assetclass": "asset_class_id",
+    "prospectobjective": "investment_objectives",
+    "beta1y": "beta_1y",
+    "beta2y": "beta_2y",
+    "beta3y": "beta_3y",
+    "beta4y": "beta_4y",
+    "beta5y": "beta_5y",
+    "beta6y": "beta_6y",
+    "beta7y": "beta_7y",
+    "beta8y": "beta_8y",
+    "beta9y": "beta_9y",
+    "beta10y": "beta_10y",
+    "beta11y": "beta_11y",
+    "beta12y": "beta_12y",
+    "beta13y": "beta_13y",
+    "beta14y": "beta_14y",
+    "beta15y": "beta_15y",
+    "beta16y": "beta_16y",
+    "beta17y": "beta_17y",
+    "beta18y": "beta_18y",
+    "beta19y": "beta_19y",
+    "beta20y": "beta_20y",
+    "avgvol30days": "volume_avg_30d",
+    "aum": "aum",
+    "top10holdings": "holdings_top10",
+    "top10holdingsummary": "holdings_top10_summary",
+    "totalreturn6month": "return_6m",
+    "totalreturn10year": "return_10y",
+    "managementfee": "management_fee",
+    "altData": "additional_data",
+}
+
+# Additional Indices Supported By TMX for Snapshots Data.
+
+NASDAQ_GIDS = {
+    "^ADRAI": "BLDRS Asia 50 ADR Index Fund",
+    "^ADRDI": "BLDRS Developed Markets 100 ADR Index Fund",
+    "^ADREI": "BLDRS Emerging Markets 50 ADR Index Fund",
+    "^ASRN": "AlphaSector Rotation Index",
+    "^ASRX": "AlphaSector Rotation Total Return Index",
+    "^AVSPY": "NASDAQ OMX Alpha AAPL vs. SPY Index",
+    "^BIXR": "BetterInvesting 100 Total Return Index",
+    "^BIXX": "BetterInvesting 100 Index",
+    "^BKX": "KBW Bank Index",
+    "^BSCBK": "NASDAQ BulletShares USD Corporate Bond 2020 Index",
+    "^BSCBL": "NASDAQ BulletShares USD Corporate Bond 2021 Index",
+    "^BSCBM": "NASDAQ BulletShares USD Corporate Bond 2022 Index",
+    "^BSCBN": "NASDAQ BulletShares USD Corporate Bond 2023 Index",
+    "^BSCBO": "NASDAQ BulletShares USD Corporate Bond 2024 Index",
+    "^BSCBP": "NASDAQ BulletShares USD Corporate Bond 2025 Index",
+    "^BSJKK": "NASDAQ BulletShares USD High Yield Corporate Bond",
+    "^BSJKL": "NASDAQ BulletShares USD High Yield Corporate Bond",
+    "^BSJKM": "NASDAQ BulletShares USD High Yield Corporate Bond",
+    "^BSJKN": "NASDAQ BulletShares USD High Yield Corporate Bond",
+    "^BXN": "CBOE NASDAQ-100 BuyWrite Index",
+    "^CELS": "NASDAQ Clean Edge Green Energy Index",
+    "^CEXX": "NASDAQ Clean Edge Green Energy Total Return Index",
+    "^CHXN": "NASDAQ China Index",
+    "^CIX100": "Cryptoindex.com",
+    "^CND": "NASDAQ Canada",
+    "^COMPX": "NASDAQ Composite",
+    "^CVXLF": "NASDAQ OMX Alpha C vs. XLF Index",
+    "^DFX": "PHLX Defense Sector",
+    "^DIVQ": "NASDAQ Dividend Achievers Index",
+    "^DOT": "TheStreet.com Internet Sector",
+    "^DTEC": "NASDAQ Dallas Regional Chamber Index",
+    "^DVQT": "NASDAQ Dividend Achievers Total Return Index",
+    "^DWAFIR": "Dorsey Wright Fixed Income Allocation Index",
+    "^DWANQFF": "Dorsey Wright Focus Five Index",
+    "^EMCLOUD": "BVP Nasdaq Emerging Cloud Index",
+    "^EPX": "SIG Oil Exploration & Production Index",
+    "^ABAQ": "ABA Community Bank NASDAQ Index",
+    "^EVSPY": "NASDAQ OMX Alpha EEM vs. SPY Index",
+    "^GESPY": "NASDAQ OMX Alpha GE vs. SPY Index",
+    "^GOOSY": "NASDAQ OMX Alpha GOOG vs. SPY Index",
+    "^GVSPY": "NASDAQ OMX Alpha GLD vs. SPY Index",
+    "^HAUL": "Wilder NASDAQ OMX Global Energy Efficient Transport Index",
+    "^HGX": "PHLX Housing Sector",
+    "^IBMSY": "NASDAQ OMX Alpha IBM vs. SPY Index",
+    "^ILTI": "NASDAQ OMX AeA Illinois Tech Index",
+    "^INTSY": "NASDAQ OMX Alpha INTC vs. SPY Index",
+    "^ISRQ": "NASDAQ Israel Index",
+    "^ISRX": "NASDAQ Israel Total Return",
+    "^IVSPY": "NASDAQ OMX Alpha IBM vs. SPY Index",
+    "^IXBK": "NASDAQ Bank",
+    "^IXCO": "NASDAQ Computer",
+    "^IXF": "NASDAQ Financial",
+    "^IXFN": "NASDAQ Other Finance",
+    "^IXHC": "NASDAQ Health Care Index",
+    "^IXID": "NASDAQ Industrial",
+    "^IXIS": "NASDAQ Insurance",
+    "^IXTC": "NASDAQ Telecommunications",
+    "^IXTR": "NASDAQ Transportation",
+    "^JVSPY": "NASDAQ OMX Alpha INTC vs. SPY Index",
+    "^KRX": "KBW Regional Banking Index",
+    "^LVSPY": "NASDAQ OMX Alpha GE vs. SPY Index",
+    "^MFX": "KBW Mortgage Finance Index",
+    "^MRKSY": "NASDAQ OMX Alpha MRK vs. SPY Index",
+    "^MSH": "Morgan Stanley Technology index",
+    "^MXZ": "PHLX Medical Device Sector",
+    "^NBI": "NASDAQ Biotechnology",
+    "^NBIE": "NASDAQ Biotechnology Equal Weighted Index",
+    "^NBIJR": "Nasdaq Junior Biotechnology Index",
+    "^NCI": "Nasdaq Crypto Index",
+    "^NDX": "NASDAQ 100 Index",
+    "^NDXE": "The NASDAQ-100 Equal Weighted Index",
+    "^NDXT": "NASDAQ-100 Technology Sector Index",
+    "^NDXX": "NASDAQ-100 Ex-Tech Sector Index",
+    "^NEUX": "NASDAQ OMX Europe Index",
+    "^NGX": "Nasdaq Next Generation 100 Index",
+    "^NQ7HANDLTL": "Nasdaq 7HANDL Index",
+    "^NQCICLER": "NASDAQ Commodity Crude Oil Index ER",
+    "^NQCIGCER": "NASDAQ Commodity Gold Index ER",
+    "^NQCIHGER": "NASDAQ Commodity HG Copper Index ER",
+    "^NQCINGER": "NASDAQ Commodity Natural Gas Index ER",
+    "^NQCISIER": "NASDAQ Commodity Silver Index ER",
+    "^NQCYBRT": "Nasdaq CTA Cybersecurity Index",
+    "^NQGM": "NASDAQ Global Market Composite",
+    "^NQGS": "NASDAQ Global Select Market Composite",
+    "^NQH2O": "Nasdaq Veles California Water Index",
+    "^NQMGUSL": "Nasdaq US Mega Cap Select Leaders Index",
+    "^NQVWLCCT": "Nasdaq Victory US 500 Large Vol Wt L/C TR",
+    "^NQVWLCT": "Nasdaq Victory US 500 Large Vol Wt TR",
+    "^NQVWLDCT": "Nasdaq Victory US 100 Large High Div Vol Wt L/C TR",
+    "^NQX": "NASDAQ-100 Reduced Value Index",
+    "^NVSPY": "NASDAQ OMX Alpha MRK vs. SPY Index",
+    "^NXTQ": "NASDAQ Q-50",
+    "^OMXB10": "OMX Baltic 10",
+    "^OMXC20": "OMX Copenhagen 20",
+    "^OMXH25": "OMX Helsinki 25",
+    "^OMXN40": "OMX Nordic 40",
+    "^OMXS30": "OMX Stockholm 30 Index",
+    "^ONEQI": "Fidelity Nasdaq Composite Index Tracking Stock",
+    "^OSX": "PHLX Oil Service Sector",
+    "^PRFEI": "PowerShares FTSE RAFI Energy Sector Portfolio",
+    "^PRFFI": "PowerShares FTSE RAFI Financials Sector Portfolio",
+    "^PRFGI": "PowerShares FTSE RAFI Consumer Goods Sector Portfolio",
+    "^PRFHI": "PowerShares FTSE RAFI Health Care Sector Portfolio",
+    "^PRFMI": "PowerShares FTSE RAFI Basic Materials Sector Portfolio",
+    "^PRFNI": "PowerShares FTSE RAFI Industrials Sector Portfolio",
+    "^PRFQI": "PowerShares FTSE RAFI Telecom & Tech Sector Portfolio",
+    "^PRFSI": "PowerShares FTSE RAFI Consumer Goods Sector Portfolio",
+    "^PRFUI": "PowerShares FTSE RAFI Utilities Sector Portfolio",
+    "^PRFZI": "PowerShares FTSE RAFI US 1500 Small-Mid Portfolio",
+    "^QAGR": "NASDAQ OMX Global Agriculture Index",
+    "^QCLNI": "First Trust NASDAQ Clean Edge U.S. Liquid Series",
+    "^QCOL": "NASDAQ OMX Global Coal Index",
+    "^QGLD": "NASDAQ OMX Global Gold & Precious Metals Index",
+    "^QGRI": "NASDAQ OMX Government Relief Index",
+    "^QIRL": "NASDAQ OMX Ireland Index",
+    "^QIV": "NASDAQ 100 After Hours Indicator",
+    "^QMEA": "NASDAQ OMX Middle East North Africa Index",
+    "^QMI": "NASDAQ 100 Pre Market Indicator",
+    "^QNET": "NASDAQ Internet Index",
+    "^QOMX": "NASDAQ OMX 100 Index",
+    "^QQEWI": "First Trust NASDAQ 100 Equal Weighted Index Fund",
+    "^NOCO": "NASDAQ OMX Carbon Excess Return Index",
+    "^QQXTI": "First Trust NASDAQ 100 Ex-Technology Sector",
+    "^QSTL": "NASDAQ OMX Global Steel Index",
+    "^QTECI": "First Trust NASDAQ 100 Technology Sector",
+    "^QWND": "NASDAQ OMX Clean Edge Global Wind Energy Index",
+    "^RCMP": "NASDAQ Capital Market Composite Index",
+    "^RXS": "PHLX Drug Sector",
+    "^SHX": "PHLX Marine Shipping Sector",
+    "^SOX": "PHLX Semiconductor Sector",
+    "^SRVRSCPR": "Kelly Data Center and Tech Infrastructure Index",
+    "^SVO": "SIG Energy MLP Index",
+    "^TRAN": "Dow Transportation",
+    "^TVSPY": "NASDAQ OMX Alpha TLT vs. SPY Index",
+    "^UTY": "PHLX Utility Sector",
+    "^UVSPY": "NASDAQ OMX Alpha GOOG vs. SPY Index",
+    "^VOLNDX": "Volatility NASDAQ - 100",
+    "^VOLQ": "Nasdaq-100 Volatility Index",
+    "^WMTSY": "NASDAQ OMX Alpha WMT vs. SPY Index",
+    "^WVSPY": "NASDAQ OMX Alpha WMT vs. SPY Index",
+    "^XAU": "PHLX Gold/Silver Sector",
+    "^XCM": "PHLX Chemicals Sector",
+    "^XEX": "PHLX Europe Sector",
+    "^XND": "Nasdaq-100 Micro Index",
+}
+
+
+def get_random_agent() -> str:
+    """Get a random user agent."""
+    # pylint: disable=import-outside-toplevel
+    from random_user_agent.user_agent import UserAgent
+
+    user_agent_rotator = UserAgent(limit=100)
+    user_agent = user_agent_rotator.get_random_user_agent()
+    return user_agent
+
+
+def get_companies_backend():
+    """Get the SQLiteBackend for the TMX companies."""
+    # pylint: disable=import-outside-toplevel
+    from aiohttp_client_cache import SQLiteBackend  # noqa
+    from openbb_core.app.utils import get_user_cache_directory  # noqa
+
+    # Only used for obtaining the directory of all valid company tickers.
+    tmx_companies_backend = SQLiteBackend(
+        f"{get_user_cache_directory()}/http/tmx_companies",
+        expire_after=timedelta(days=2),
+    )
+
+    return tmx_companies_backend
+
+
+def get_indices_backend():
+    """Get the SQLiteBackend for the TMX indices."""
+    # pylint: disable=import-outside-toplevel
+    from aiohttp_client_cache import SQLiteBackend  # noqa
+    from openbb_core.app.utils import get_user_cache_directory  # noqa
+
+    # Only used for obtaining the directory of all valid indices.
+    tmx_indices_backend = SQLiteBackend(
+        f"{get_user_cache_directory()}/http/tmx_indices", expire_after=timedelta(days=1)
+    )
+
+    return tmx_indices_backend
+
+
+async def response_callback(response, _: Any):
+    """Use callback for HTTP Client Response."""
+    content_type = response.headers.get("Content-Type", "")
+    if "application/json" in content_type:
+        return await response.json()
+    if "text" in content_type:
+        return await response.text()
+    return await response.read()
+
+
+async def get_data_from_url(
+    url: str,
+    use_cache: bool = True,
+    backend: Optional["SQLiteBackend"] = None,
+    **kwargs: Any,
+) -> Any:
+    """Make an asynchronous HTTP request to a static file."""
+    # pylint: disable=import-outside-toplevel
+    from aiohttp_client_cache.session import CachedSession
+    from openbb_core.provider.utils.helpers import amake_request
+
+    data: Any = None
+    if use_cache is True:
+        async with CachedSession(cache=backend) as cached_session:
+            try:
+                response = await cached_session.get(url, **kwargs)
+                data = await response_callback(response, None)
+            finally:
+                await cached_session.close()
+    else:
+        data = await amake_request(url, response_callback=response_callback, timeout=20)
+
+    return data
+
+
+async def get_data_from_gql(url: str, headers, data, **kwargs: Any) -> Any:
+    """Make an asynchronous GraphQL request."""
+    # pylint: disable=import-outside-toplevel
+    from openbb_core.provider.utils.helpers import amake_request
+
+    response = await amake_request(
+        url=url,
+        method="POST",
+        response_callback=response_callback,
+        headers=headers,
+        data=data,
+        timeout=30,
+    )
+
+    return response
+
+
+def replace_values_in_list_of_dicts(data):
+    """Replace "NA" and "-" with None in a list of dictionaries."""
+    for d in data:
+        for k, v in d.items():
+            if isinstance(v, dict):
+                replace_values_in_list_of_dicts([v])  # Recurse into nested dictionary
+            elif isinstance(v, list):
+                for i in range(len(v)):  # pylint: disable=C0200
+                    if isinstance(v[i], dict):
+                        replace_values_in_list_of_dicts(
+                            [v[i]]
+                        )  # Recurse into nested dictionary in list
+                    elif v[i] in ("NA", "-"):
+                        v[i] = None  # Replace "NA" and "-" with None
+            elif v in ("NA", "-"):
+                d[k] = None  # Replace "NA" and "-" with None
+    return data
+
+
+def check_weekday(date) -> str:
+    """Check if the input date is a weekday, and if not, returns the next weekday.
+
+    Parameters
+    ----------
+    date: str
+        The date to check in YYYY-MM-DD format.
+
+    Returns
+    -------
+    str
+        Date in YYYY-MM-DD format.  If the date is a weekend, returns the date of the next weekday.
+    """
+    # pylint: disable=import-outside-toplevel
+    from pandas import to_datetime
+    from pandas.tseries.holiday import next_workday
+
+    if to_datetime(date).weekday() > 4:
+        return next_workday(to_datetime(date)).strftime("%Y-%m-%d")
+    return date
+
+
+async def get_all_etfs(use_cache: bool = True) -> List[Dict]:
+    """Get a summary of the TMX ETF universe.
+
+    Returns
+    -------
+    Dict
+        Dictionary with all TMX-listed ETFs.
+    """
+    # pylint: disable=import-outside-toplevel
+    from aiohttp_client_cache import SQLiteBackend  # noqa
+    from openbb_core.app.utils import get_user_cache_directory  # noqa
+    from pandas import DataFrame  # noqa
+
+    # Only used for obtaining the all ETFs JSON file.
+    tmx_etfs_backend = SQLiteBackend(
+        f"{get_user_cache_directory()}/http/tmx_etfs", expire_after=timedelta(hours=4)
+    )
+
+    url = "https://dgr53wu9i7rmp.cloudfront.net/etfs/etfs.json"
+
+    response = await get_data_from_url(
+        url, use_cache=use_cache, backend=tmx_etfs_backend
+    )
+
+    if not response or response is None:
+        raise OpenBBError("There was a problem with the request. Could not get ETFs.")
+
+    response = replace_values_in_list_of_dicts(response)
+
+    etfs = DataFrame(response).rename(columns=COLUMNS_DICT)
+
+    etfs = etfs.drop(
+        columns=[
+            "beta_2y",
+            "beta_4y",
+            "beta_6y",
+            "beta_7y",
+            "beta_8y",
+            "beta_9y",
+            "beta_11y",
+            "beta_12y",
+            "beta_13y",
+            "beta_14y",
+            "beta_16y",
+            "beta_17y",
+            "beta_18y",
+            "beta_19y",
+        ]
+    )
+
+    for i in etfs.index:
+        etfs.loc[i, "fund_family"] = etfs.loc[i, "additional_data"].get("fundfamilyen", None)  # type: ignore
+        etfs.loc[i, "website"] = etfs.loc[i, "additional_data"].get("websitefactsheeten", None)  # type: ignore
+        etfs.loc[i, "mer"] = etfs.loc[i, "additional_data"].get("mer", None)  # type: ignore
+    etfs = etfs.fillna("N/A").replace("N/A", None)
+
+    return etfs.to_dict(orient="records")
+
+
+async def get_tmx_tickers(
+    exchange: Literal["tsx", "tsxv"] = "tsx", use_cache: bool = True
+) -> Dict:
+    """Get a dictionary of either TSX or TSX-V symbols and names."""
+    # pylint: disable=import-outside-toplevel
+    from pandas import DataFrame
+
+    tsx_json_url = "https://www.tsx.com/json/company-directory/search"
+    url = f"{tsx_json_url}/{exchange}/*"
+    response = await get_data_from_url(
+        url, use_cache=use_cache, backend=get_companies_backend()
+    )
+    data = (
+        DataFrame.from_records(response["results"])[["symbol", "name"]]
+        .set_index("symbol")
+        .sort_index()
+    )
+    results = data.to_dict()["name"]
+    return results
+
+
+async def get_all_tmx_companies(use_cache: bool = True) -> Dict:
+    """Merge TSX and TSX-V listings into a single dictionary."""
+    all_tmx = {}
+    tsx_tickers = await get_tmx_tickers(use_cache=use_cache)
+    tsxv_tickers = await get_tmx_tickers("tsxv", use_cache=use_cache)
+    all_tmx.update(tsxv_tickers)
+    all_tmx.update(tsx_tickers)
+    return all_tmx
+
+
+async def get_all_options_tickers(use_cache: bool = True) -> "DataFrame":
+    """Return a DataFrame with all valid ticker symbols."""
+    # pylint: disable=import-outside-toplevel
+    from io import StringIO  # noqa
+    from pandas import concat, read_html  # noqa
+    from openbb_core.provider.utils.helpers import to_snake_case  # noqa
+
+    url = "https://www.m-x.ca/en/trading/data/options-list"
+
+    r = await get_data_from_url(
+        url, use_cache=use_cache, backend=get_companies_backend()
+    )
+
+    if r is None or r == []:
+        raise OpenBBError("Error with the request")  # mypy: ignore
+
+    options_listings = read_html(StringIO(r))
+    listings = concat(options_listings)
+    listings = listings.set_index("Option Symbol").drop_duplicates().sort_index()
+    symbols = listings[:-1]
+    symbols = symbols.fillna(value="")
+    symbols["Underlying Symbol"] = (
+        symbols["Underlying Symbol"].str.replace(" u", ".UN").str.replace("––", "")
+    )
+    symbols = symbols.reset_index()
+    symbols.columns = [
+        to_snake_case(col).replace("name_of_", "") for col in symbols.columns
+    ]
+
+    return symbols.set_index("option_symbol")
+
+
+async def get_current_options(symbol: str, use_cache: bool = True) -> "DataFrame":
+    """Get the current quotes for the complete options chain."""
+    # pylint: disable=import-outside-toplevel
+    from io import StringIO  # noqa
+    from pandas import DataFrame, DatetimeIndex, concat, read_html, to_datetime  # noqa
+    from openbb_core.provider.utils.helpers import to_snake_case  # noqa
+
+    SYMBOLS = await get_all_options_tickers(use_cache=use_cache)
+    data = DataFrame()
+    symbol = symbol.upper()
+
+    # Remove exchange  identifiers from the symbol.
+    symbol = symbol.upper().replace("-", ".").replace(".TO", "").replace(".TSX", "")
+    # Underlying symbol may have a different ticker symbol than the ticker used to lookup options.
+    if len(SYMBOLS[SYMBOLS["underlying_symbol"].str.contains(symbol)]) == 1:
+        symbol = SYMBOLS[SYMBOLS["underlying_symbol"] == symbol].index.values[0]
+    # Check if the symbol has options trading.
+    if symbol not in SYMBOLS.index and not SYMBOLS.empty:
+        raise OpenBBError(
+            f"The symbol, {symbol}, is not a valid listing or does not trade options."
+        )
+
+    QUOTES_URL = f"https://www.m-x.ca/en/trading/data/quotes?symbol={symbol}"
+
+    cols = [
+        "expiration",
+        "strike",
+        "bid",
+        "ask",
+        "lastTradePrice",
+        "change",
+        "openInterest",
+        "volume",
+        "optionType",
+    ]
+
+    r = await get_data_from_url(QUOTES_URL, use_cache=False)
+    data = read_html(StringIO(r))[0]
+    data = data.iloc[:-1]
+
+    expirations = (
+        data["Unnamed: 0_level_0"]["Expiry date"].astype(str).rename("expiration")
+    )
+
+    expirations = expirations.str.strip("(Weekly)")
+
+    strikes = (
+        data["Unnamed: 7_level_0"]
+        .dropna()
+        .sort_values("Strike")  # type: ignore
+        .rename(columns={"Strike": "strike"})
+    )
+
+    calls = concat([expirations, strikes, data["Calls"]], axis=1)
+    calls["expiration"] = DatetimeIndex(calls["expiration"]).astype(str)
+    calls["optionType"] = "call"
+    calls.columns = cols
+    calls = calls.set_index(["expiration", "strike", "optionType"])
+
+    puts = concat([expirations, strikes, data["Puts"]], axis=1)
+    puts["expiration"] = DatetimeIndex(puts["expiration"]).astype(str)
+    puts["optionType"] = "put"
+    puts.columns = cols
+    puts = puts.set_index(["expiration", "strike", "optionType"])
+
+    chains = concat([calls, puts])
+    chains["openInterest"] = chains["openInterest"].astype("int64")
+    chains["volume"] = chains["volume"].astype("int64")
+    chains["change"] = chains["change"].astype(float)
+    chains["lastTradePrice"] = chains["lastTradePrice"].astype(float)
+    chains["bid"] = chains["bid"].astype(float)
+    chains["ask"] = chains["ask"].astype(float)
+    chains = chains.sort_index()
+    chains = chains.reset_index()
+    now = datetime.now()
+    temp = DatetimeIndex(chains.expiration)
+    temp_ = (temp - now).days + 1  # type: ignore
+    chains["dte"] = temp_
+
+    # Create the standardized contract symbol.
+    _strikes = chains["strike"]
+    strikes = []
+    for _strike in _strikes:
+        _strike = str(_strike).split(".")
+        front = "0" * (5 - len(_strike[0]))
+        back = "0" * (3 - len(_strike[1]))
+        strike = f"{front}{_strike[0]}{_strike[1]}{back}"
+        strikes.append(str(strike))
+
+    chains["strikes"] = strikes
+    chains["contract_symbol"] = (
+        symbol
+        + " " * (6 - len(symbol))
+        + to_datetime(chains["expiration"]).dt.strftime("%y%m%d")
+        + (chains["optionType"].replace("call", "C").replace("put", "P"))
+        + chains["strikes"]
+    )
+    chains.drop(columns=["strikes"], inplace=True)
+
+    chains.columns = [to_snake_case(c) for c in chains.columns.to_list()]
+
+    return chains
+
+
+async def download_eod_chains(
+    symbol: str, date: Optional[dateType] = None, use_cache: bool = False
+) -> "DataFrame":
+    """Download EOD chains data for a given symbol and date."""
+    # pylint: disable=import-outside-toplevel
+    from io import StringIO  # noqa
+    import exchange_calendars as xcals  # noqa
+    from pandas import DatetimeIndex, Timedelta, read_csv, to_datetime  # noqa
+    from openbb_core.provider.utils.helpers import to_snake_case  # noqa
+
+    symbol = symbol.upper()
+    SYMBOLS = await get_all_options_tickers(use_cache=False)
+    # Remove echange  identifiers from the symbol.
+    symbol = symbol.upper().replace("-", ".").replace(".TO", "").replace(".TSX", "")
+
+    # Underlying symbol may have a different ticker symbol than the ticker used to lookup options.
+    if len(SYMBOLS[SYMBOLS["underlying_symbol"].str.contains(symbol)]) == 1:
+        symbol = SYMBOLS[SYMBOLS["underlying_symbol"] == symbol].index.values[0]
+    # Check if the symbol has options trading.
+    if symbol not in SYMBOLS.index and not SYMBOLS.empty:
+        raise OpenBBError(
+            f"The symbol, {symbol}, is not a valid listing or does not trade options."
+        )
+
+    BASE_URL = "https://www.m-x.ca/en/trading/data/historical?symbol="
+
+    cal = xcals.get_calendar("XTSE")
+
+    if date is None:
+        EOD_URL = BASE_URL + f"{symbol}" "&dnld=1#quotes"
+    else:
+        date = check_weekday(date)  # type: ignore
+        if cal.is_session(date) is False:  # type: ignore
+            date = (to_datetime(date) + timedelta(days=1)).strftime("%Y-%m-%d")  # type: ignore
+        date = check_weekday(date)  # type: ignore
+        if cal.is_session(date=date) is False:  # type: ignore
+            date = (to_datetime(date) + timedelta(days=1)).strftime("%Y-%m-%d")  # type: ignore
+
+        EOD_URL = (
+            BASE_URL + f"{symbol}" "&from=" f"{date}" "&to=" f"{date}" "&dnld=1#quotes"
+        )
+
+    r = await get_data_from_url(EOD_URL, use_cache=use_cache)  # type: ignore
+
+    if r is None:
+        raise OpenBBError("Error with the request, no data was returned.")
+
+    data = read_csv(StringIO(r))
+    if data.empty:
+        raise OpenBBError(
+            f"No data found for, {symbol}, on, {date}."
+            "The symbol may not have been listed, or traded options, before that date."
+        )
+
+    data["contractSymbol"] = data["Symbol"]
+
+    data["optionType"] = data["Call/Put"].replace(0, "call").replace(1, "put")
+
+    data = data.drop(
+        columns=[
+            "Symbol",
+            "Class Symbol",
+            "Root Symbol",
+            "Underlying Symbol",
+            "Ins. Type",
+            "Call/Put",
+        ]
+    )
+
+    cols = [
+        "eod_date",
+        "strike",
+        "expiration",
+        "closeBid",
+        "closeAsk",
+        "closeBidSize",
+        "closeAskSize",
+        "lastTradePrice",
+        "volume",
+        "prevClose",
+        "change",
+        "open",
+        "high",
+        "low",
+        "totalValue",
+        "transactions",
+        "settlementPrice",
+        "openInterest",
+        "impliedVolatility",
+        "contractSymbol",
+        "optionType",
+    ]
+
+    data.columns = cols
+    data["underlying_symbol"] = symbol + ":CA"
+    data["expiration"] = to_datetime(data["expiration"], format="%Y-%m-%d")
+    data["eod_date"] = to_datetime(data["eod_date"], format="%Y-%m-%d")
+    data["impliedVolatility"] = 0.01 * data["impliedVolatility"]
+
+    date_ = data["eod_date"]
+    temp = DatetimeIndex(data.expiration)
+    temp_ = temp - date_  # type: ignore
+    data["dte"] = [Timedelta(_temp_).days for _temp_ in temp_]
+    data = data.set_index(["expiration", "strike", "optionType"]).sort_index()
+    data["eod_date"] = data["eod_date"].astype(str)
+    underlying_price = data.iloc[-1]["lastTradePrice"]
+    data["underlyingPrice"] = underlying_price
+    data = data.reset_index()
+    data = data[data["strike"] != 0]
+    data["expiration"] = to_datetime(data["expiration"]).dt.strftime("%Y-%m-%d")
+
+    data.columns = [to_snake_case(c) for c in data.columns.to_list()]
+
+    return data
+
+
+async def get_company_filings(
+    symbol: str,
+    start_date: Optional[str] = (datetime.now() - timedelta(days=30)).strftime(
+        "%Y-%m-%d"
+    ),
+    end_date: Optional[str] = datetime.now().date().strftime("%Y-%m-%d"),
+    limit: int = 50,
+) -> List[Dict]:
+    """Get company filings."""
+    # pylint: disable=import-outside-toplevel
+    import json
+
+    user_agent = get_random_agent()
+    results: List[Dict] = []
+    symbol = symbol.upper().replace("-", ".").replace(".TO", "").replace(".TSX", "")
+
+    payload = gql.get_company_filings_payload
+    payload["variables"]["symbol"] = symbol
+    payload["variables"]["fromDate"] = start_date
+    payload["variables"]["toDate"] = end_date
+    payload["variables"]["limit"] = limit
+    url = "https://app-money.tmx.com/graphql"
+    try:
+        r = await get_data_from_gql(
+            url=url,
+            data=json.dumps(payload),
+            headers={
+                "Accept": "*/*",
+                "Accept-Encoding": "gzip, deflate, br",
+                "Accept-Language": "en-CA,en-US;q=0.7,en;q=0.3",
+                "Connection": "keep-alive",
+                "Content-Type": "application/json",
+                "Host": "app-money.tmx.com",
+                "Origin": "https://money.tmx.com",
+                "Referer": "https://money.tmx.com/",
+                "locale": "en",
+                "Sec-Fetch-Dest": "empty",
+                "Sec-Fetch-Mode": "cors",
+                "Sec-Fetch-Site": "same-site",
+                "TE": "trailers",
+                "User-Agent": user_agent,
+            },
+        )
+    except Exception as _e:
+        raise OpenBBError(_e) from _e
+    if r["data"]["filings"] is None:
+        results = []
+    results = r.get("data").get("filings")
+
+    return results
+
+
+async def get_daily_price_history(
+    symbol: str,
+    start_date: Optional[Union[str, dateType]] = None,
+    end_date: Optional[Union[str, dateType]] = None,
+    adjustment: Literal[
+        "splits_only", "unadjusted", "splits_and_dividends"
+    ] = "splits_only",
+):
+    """Get historical price data."""
+    # pylint: disable=import-outside-toplevel
+    import json  # noqa
+    import asyncio  # noqa
+    from dateutil import rrule  # noqa
+
+    start_date = (
+        datetime.strptime(start_date, "%Y-%m-%d")
+        if isinstance(start_date, str)
+        else start_date
+    )
+    end_date = (
+        datetime.strptime(end_date, "%Y-%m-%d")
+        if isinstance(end_date, str)
+        else end_date
+    )
+    user_agent = get_random_agent()
+    results: List[Dict] = []
+    symbol = symbol.upper().replace("-", ".").replace(".TO", "").replace(".TSX", "")
+    start_date = (
+        (datetime.now() - timedelta(weeks=52)).date()
+        if start_date is None
+        else start_date
+    )
+    end_date = datetime.now() if end_date is None else end_date
+
+    # Generate a list of dates from start_date to end_date with a frequency of 4 weeks
+    dates = list(
+        rrule.rrule(rrule.WEEKLY, interval=4, dtstart=start_date, until=end_date)
+    )
+
+    # Add end_date to the list if it's not there already
+    if dates[-1] != end_date:
+        dates.append(end_date)  # type: ignore
+
+    # Create a list of 4-week chunks
+    chunks = [
+        (dates[i], dates[i + 1] - timedelta(days=1)) for i in range(len(dates) - 1)
+    ]
+
+    # Adjust the end date of the last chunk to be the final end date
+    chunks[-1] = (chunks[-1][0], end_date)  # type: ignore
+
+    async def create_task(start, end, results):
+        """Create a task from a start and end date chunk."""
+        payload = gql.get_company_price_history_payload.copy()
+        payload["variables"]["adjusted"] = (
+            False if adjustment == "unadjusted" else True  # noqa: SIM211
+        )
+        payload["variables"]["adjustmentType"] = (
+            "SO" if adjustment == "splits_only" else None
+        )
+        payload["variables"]["end"] = end.strftime("%Y-%m-%d")
+        payload["variables"]["start"] = start.strftime("%Y-%m-%d")
+        payload["variables"]["symbol"] = symbol
+        payload["variables"]["unadjusted"] = (
+            True if adjustment == "unadjusted" else False  # noqa: SIM210
+        )
+        if payload["variables"]["adjustmentType"] is None:
+            payload["variables"].pop("adjustmentType")
+        url = "https://app-money.tmx.com/graphql"
+
+        async def try_again():
+            """Try again if it fails."""
+            return await get_data_from_gql(
+                method="POST",
+                url=url,
+                data=json.dumps(payload),
+                headers={
+                    "authority": "app-money.tmx.com",
+                    "referer": f"https://money.tmx.com/en/quote/{symbol}",
+                    "locale": "en",
+                    "Content-Type": "application/json",
+                    "User-Agent": user_agent,
+                    "Accept": "*/*",
+                },
+                timeout=3,
+            )
+
+        try:
+            data = await get_data_from_gql(
+                method="POST",
+                url=url,
+                data=json.dumps(payload),
+                headers={
+                    "authority": "app-money.tmx.com",
+                    "referer": f"https://money.tmx.com/en/quote/{symbol}",
+                    "locale": "en",
+                    "Content-Type": "application/json",
+                    "User-Agent": user_agent,
+                    "Accept": "*/*",
+                },
+                timeout=3,
+            )
+        except Exception:
+            data = await try_again()
+
+        if isinstance(data, str):
+            data = await try_again()
+
+        if data.get("data") and data["data"].get("getCompanyPriceHistory"):
+            results.extend(data["data"].get("getCompanyPriceHistory"))
+
+        return results
+
+    tasks = [create_task(chunk[0], chunk[1], results) for chunk in chunks]
+
+    await asyncio.gather(*tasks)
+
+    results = [d for d in results if d["openPrice"] is not None]
+
+    return sorted(results, key=lambda x: x["datetime"], reverse=False)
+
+
+async def get_weekly_or_monthly_price_history(
+    symbol: str,
+    start_date: Optional[Union[str, dateType]] = None,
+    end_date: Optional[Union[str, dateType]] = None,
+    interval: Literal["month", "week"] = "month",
+):
+    """Get historical price data."""
+    # pylint: disable=import-outside-toplevel
+    import json
+
+    if start_date:
+        start_date = (
+            datetime.strptime(start_date, "%Y-%m-%d")
+            if isinstance(start_date, str)
+            else start_date
+        )
+    if end_date:
+        end_date = (
+            datetime.strptime(end_date, "%Y-%m-%d")
+            if isinstance(end_date, str)
+            else end_date
+        )
+    user_agent = get_random_agent()
+    results: List[Dict] = []
+    symbol = symbol.upper().replace("-", ".").replace(".TO", "").replace(".TSX", "")
+    start_date = (
+        (datetime.now() - timedelta(weeks=52 * 100)).date()
+        if start_date is None
+        else start_date
+    )
+    end_date = datetime.now() if end_date is None else end_date
+
+    payload = gql.get_timeseries_payload.copy()
+    if "interval" in payload["variables"]:
+        payload["variables"].pop("interval")
+    if "startDateTime" in payload["variables"]:
+        payload["variables"].pop("startDateTime")
+    if "endDateTime" in payload["variables"]:
+        payload["variables"].pop("endDateTime")
+    payload["variables"]["symbol"] = symbol
+    payload["variables"]["freq"] = interval
+    payload["variables"]["end"] = (
+        end_date.strftime("%Y-%m-%d") if isinstance(end_date, dateType) else end_date
+    )
+    payload["variables"]["start"] = (
+        start_date.strftime("%Y-%m-%d")
+        if isinstance(start_date, dateType)
+        else start_date
+    )
+    url = "https://app-money.tmx.com/graphql"
+    data = await get_data_from_gql(
+        method="POST",
+        url=url,
+        data=json.dumps(payload),
+        headers={
+            "authority": "app-money.tmx.com",
+            "referer": f"https://money.tmx.com/en/quote/{symbol}",
+            "locale": "en",
+            "Content-Type": "application/json",
+            "User-Agent": user_agent,
+            "Accept": "*/*",
+        },
+        timeout=3,
+    )
+
+    async def try_again():
+        """Try again if the request fails."""
+        return await get_data_from_gql(
+            method="POST",
+            url=url,
+            data=json.dumps(payload),
+            headers={
+                "authority": "app-money.tmx.com",
+                "referer": f"https://money.tmx.com/en/quote/{symbol}",
+                "locale": "en",
+                "Content-Type": "application/json",
+                "User-Agent": user_agent,
+                "Accept": "*/*",
+            },
+            timeout=3,
+        )
+
+    if isinstance(data, str):
+        data = await try_again()
+
+    if data.get("data") and data["data"].get("getTimeSeriesData"):
+        results = data["data"].get("getTimeSeriesData")
+        results = sorted(results, key=lambda x: x["dateTime"], reverse=False)
+    return results
+
+
+async def get_intraday_price_history(
+    symbol: str,
+    start_date: Optional[Union[str, dateType]] = None,
+    end_date: Optional[Union[str, dateType]] = None,
+    interval: Optional[int] = 1,
+):
+    """Get historical price data."""
+    # pylint: disable=import-outside-toplevel
+    import json  # noqa
+    import asyncio  # noqa
+    import pytz  # noqa
+    from dateutil import rrule  # noqa
+
+    if start_date:
+        start_date = (
+            datetime.strptime(start_date, "%Y-%m-%d")
+            if isinstance(start_date, str)
+            else start_date
+        )
+    if end_date:
+        end_date = (
+            datetime.strptime(end_date, "%Y-%m-%d")
+            if isinstance(end_date, str)
+            else end_date
+        )
+    user_agent = get_random_agent()
+    results: List[Dict] = []
+    symbol = symbol.upper().replace("-", ".").replace(".TO", "").replace(".TSX", "")
+    start_date = (
+        (datetime.now() - timedelta(weeks=4)).date()
+        if start_date is None
+        else start_date
+    )
+    end_date = datetime.now().date() if end_date is None else end_date
+    # This is the first date of available intraday data.
+    date_check = datetime(2022, 4, 12).date()
+    start_date = max(start_date, date_check)
+    if end_date < date_check:  # type: ignore
+        end_date = datetime.now().date()
+    # Generate a list of dates from start_date to end_date with a frequency of 3 weeks
+    dates = list(
+        rrule.rrule(rrule.WEEKLY, interval=4, dtstart=start_date, until=end_date)  # type: ignore
+    )
+
+    if dates[-1] != end_date:
+        dates.append(end_date)  # type: ignore
+
+    # Create a list of 4-week chunks
+    chunks = [
+        (dates[i], dates[i + 1] - timedelta(days=1)) for i in range(len(dates) - 1)
+    ]
+
+    # Adjust the end date of the last chunk to be the final end date
+    chunks[-1] = (chunks[-1][0], end_date)  # type: ignore
+
+    async def create_task(start, end, results):
+        """Create a task from a start and end date chunk."""
+        # Create a datetime object representing 9:30 AM on the date
+        start_obj = datetime.combine(start, time(9, 30))
+        end_obj = datetime.combine(end, time(16, 0))
+
+        # Convert the datetime object to EST
+        est = pytz.timezone("US/Eastern")
+        start_obj_est = est.localize(start_obj)
+        end_obj_est = est.localize(end_obj)
+
+        # Convert the datetime object to a timestamp
+        start_time = int(start_obj_est.timestamp())
+        end_time = int(end_obj_est.timestamp())
+
+        payload = gql.get_timeseries_payload.copy()
+        payload["variables"]["interval"] = None
+        if payload["variables"].get("start"):
+            payload["variables"].pop("start")
+        payload["variables"]["startDateTime"] = int(start_time)
+        if payload["variables"].get("end"):
+            payload["variables"].pop("end")
+        payload["variables"]["endDateTime"] = int(end_time)
+        payload["variables"]["interval"] = interval
+        payload["variables"]["symbol"] = symbol
+        if payload["variables"].get("freq"):
+            payload["variables"].pop("freq")
+        url = "https://app-money.tmx.com/graphql"
+        data = await get_data_from_gql(
+            method="POST",
+            url=url,
+            data=json.dumps(payload),
+            headers={
+                "authority": "app-money.tmx.com",
+                "referer": f"https://money.tmx.com/en/quote/{symbol}",
+                "locale": "en",
+                "Content-Type": "application/json",
+                "User-Agent": user_agent,
+                "Accept": "*/*",
+            },
+            timeout=3,
+        )
+
+        async def try_again():
+            """Try again if the request fails."""
+            return await get_data_from_gql(
+                method="POST",
+                url=url,
+                data=json.dumps(payload),
+                headers={
+                    "authority": "app-money.tmx.com",
+                    "referer": f"https://money.tmx.com/en/quote/{symbol}",
+                    "locale": "en",
+                    "Content-Type": "application/json",
+                    "User-Agent": user_agent,
+                    "Accept": "*/*",
+                },
+                timeout=3,
+            )
+
+        if isinstance(data, str):
+            data = await try_again()
+
+        if data.get("data") and data["data"].get("getTimeSeriesData"):
+            result = data["data"].get("getTimeSeriesData")
+            results.extend(result)
+
+        return results
+
+    tasks = [create_task(chunk[0], chunk[1], results) for chunk in chunks]
+
+    await asyncio.gather(*tasks)
+
+    if len(results) > 0 and "dateTime" in results[0]:
+        results = sorted(results, key=lambda x: x["dateTime"], reverse=False)
+
+    return results
+
+
+async def get_all_bonds(use_cache: bool = True) -> "DataFrame":
+    """Get all bonds reference data published by CIRO.
+
+    The complete list is approximately 70-100K securities.
+    """
+    # pylint: disable=import-outside-toplevel
+    from aiohttp_client_cache import SQLiteBackend  # noqa
+    from openbb_core.app.utils import get_user_cache_directory  # noqa
+    from pandas import DataFrame  # noqa
+
+    tmx_bonds_backend = SQLiteBackend(
+        f"{get_user_cache_directory()}/http/tmx_bonds", expire_after=timedelta(days=1)
+    )
+
+    url = "https://bondtradedata.iiroc.ca/debtip/designatedbonds/list"
+    response = await get_data_from_url(
+        url, use_cache=use_cache, timeout=30, backend=tmx_bonds_backend
+    )
+
+    # Convert the response to a DataFrame and set the types for proper filtering in-fetcher.
+    # This is done here because multiple functions might share this response object.
+    bonds_data = (
+        DataFrame.from_records(response)
+        .replace("N/A", None)
+        .sort_values(by=["lastTradedDate", "totalTrades"], ascending=False)
+    )
+
+    bonds_data["issuer"] = (
+        bonds_data["issuer"].fillna("-").replace("-", None).astype(str)
+    )
+
+    int_columns = ["totalTrades", "secKey"]
+    for column in int_columns:
+        bonds_data[column] = bonds_data[column].astype(int)
+
+    float_columns = [
+        "lastPrice",
+        "lowestPrice",
+        "highestPrice",
+        "lastYield",
+        "couponRate",
+    ]
+    for column in float_columns:
+        bonds_data[column] = bonds_data[column].astype(float)
+
+    return bonds_data