Upload 225 files

openbb_platform/extensions/README.md

@@ -0,0 +1,3 @@
+# Extensions
+
+In this folder you can find the extensions that were created or are supported by OpenBB.

openbb_platform/extensions/__init__.py

@@ -0,0 +1 @@
+"""OpenBB Platform Extensions."""

openbb_platform/extensions/commodity/README.md

@@ -0,0 +1,13 @@
+# Commodity Extension for OpenBB Platform
+
+This extension provides a set of commands for commodity-related data.
+
+## Installation
+
+To install the extension, run the following command in this folder:
+
+```bash
+pip install openbb-commodity
+```
+
+Documentation available [here](https://docs.openbb.co/platform/developer_guide/contributing).

openbb_platform/extensions/commodity/integration/test_commodity_api.py

@@ -0,0 +1,112 @@
+"""Test Commodity API endpoints."""
+
+import base64
+
+import pytest
+import requests
+from openbb_core.env import Env
+from openbb_core.provider.utils.helpers import get_querystring
+
+# pylint: disable=redefined-outer-name
+
+
+@pytest.fixture(scope="session")
+def headers():
+    """Get the headers for the API request."""
+    userpass = f"{Env().API_USERNAME}:{Env().API_PASSWORD}"
+    userpass_bytes = userpass.encode("ascii")
+    base64_bytes = base64.b64encode(userpass_bytes)
+
+    return {"Authorization": f"Basic {base64_bytes.decode('ascii')}"}
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        (
+            {
+                "commodity": "all",
+                "start_date": None,
+                "end_date": None,
+                "frequency": None,
+                "transform": None,
+                "aggregation_method": None,
+                "provider": "fred",
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_commodity_price_spot(params, headers):
+    """Test the commodity spot prices endpoint."""
+    params = {p: v for p, v in params.items() if v}
+
+    query_str = get_querystring(params, [])
+    url = f"http://0.0.0.0:8000/api/v1/commodity/price/spot?{query_str}"
+    result = requests.get(url, headers=headers, timeout=10)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        (
+            {
+                "category": "balance_sheet",
+                "table": "stocks",
+                "start_date": None,
+                "end_date": None,
+                "provider": "eia",
+                "use_cache": True,
+            }
+        ),
+        (
+            {
+                "category": "weekly_estimates",
+                "table": "crude_production",
+                "start_date": "2020-01-01",
+                "end_date": "2023-12-31",
+                "provider": "eia",
+                "use_cache": True,
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_commodity_petroleum_status_report(params, headers):
+    """Test the Petroleum Status Report endpoint."""
+    params = {p: v for p, v in params.items() if v}
+
+    query_str = get_querystring(params, [])
+    url = f"http://0.0.0.0:8000/api/v1/commodity/petroleum_status_report?{query_str}"
+    result = requests.get(url, headers=headers, timeout=10)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        (
+            {
+                "table": "01",
+                "symbol": None,
+                "start_date": "2024-09-01",
+                "end_date": "2024-10-01",
+                "provider": "eia",
+                "frequency": "month",
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_commodity_short_term_energy_outlook(params, headers):
+    """Test the Short Term Energy Outlook endpoint."""
+    params = {p: v for p, v in params.items() if v}
+
+    query_str = get_querystring(params, [])
+    url = f"http://0.0.0.0:8000/api/v1/commodity/short_term_energy_outlook?{query_str}"
+    result = requests.get(url, headers=headers, timeout=10)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200

openbb_platform/extensions/commodity/integration/test_commodity_python.py

@@ -0,0 +1,100 @@
+"""Test Commodity extension."""
+
+import pytest
+from openbb_core.app.model.obbject import OBBject
+
+# pylint: disable=redefined-outer-name
+
+
+@pytest.fixture(scope="session")
+def obb(pytestconfig):  # pylint: disable=inconsistent-return-statements
+    """Fixture to setup obb."""
+    if pytestconfig.getoption("markexpr") != "not integration":
+        import openbb  # pylint: disable=import-outside-toplevel
+
+        return openbb.obb
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        (
+            {
+                "commodity": "all",
+                "start_date": None,
+                "end_date": None,
+                "frequency": None,
+                "transform": None,
+                "aggregation_method": None,
+                "provider": "fred",
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_commodity_price_spot(params, obb):
+    """Test the commodity spot prices endpoint."""
+    params = {p: v for p, v in params.items() if v}
+
+    result = obb.commodity.price.spot(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        (
+            {
+                "category": "balance_sheet",
+                "table": "stocks",
+                "start_date": None,
+                "end_date": None,
+                "provider": "eia",
+                "use_cache": True,
+            }
+        ),
+        (
+            {
+                "category": "weekly_estimates",
+                "table": "crude_production",
+                "start_date": "2020-01-01",
+                "end_date": "2023-12-31",
+                "provider": "eia",
+                "use_cache": True,
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_commodity_petroleum_status_report(params, obb):
+    """Test Commodity Petroleum Status Report endpoint."""
+    result = obb.commodity.petroleum_status_report(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        (
+            {
+                "table": "01",
+                "symbol": None,
+                "start_date": "2024-09-01",
+                "end_date": "2024-10-01",
+                "provider": "eia",
+                "frequency": "month",
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_commodity_short_term_energy_outlook(params, obb):
+    """Test Commodity Short Term Energy Outlook endpoint."""
+    result = obb.commodity.short_term_energy_outlook(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0

openbb_platform/extensions/commodity/openbb_commodity/__init__.py

@@ -0,0 +1 @@
+"""OpenBB Commodity Extension."""

openbb_platform/extensions/commodity/openbb_commodity/commodity_router.py

@@ -0,0 +1,80 @@
+"""The Commodity router."""
+
+# pylint: disable=unused-argument,unused-import
+# flake8: noqa: F401
+
+# pylint: disable=unused-argument
+
+from openbb_core.app.model.command_context import CommandContext
+from openbb_core.app.model.example import APIEx
+from openbb_core.app.model.obbject import OBBject
+from openbb_core.app.provider_interface import (
+    ExtraParams,
+    ProviderChoices,
+    StandardParams,
+)
+from openbb_core.app.query import Query
+from openbb_core.app.router import Router
+
+from openbb_commodity.price.price_router import router as price_router
+
+router = Router(prefix="", description="Commodity market data.")
+
+
+router.include_router(price_router)
+
+
+@router.command(
+    model="PetroleumStatusReport",
+    examples=[
+        APIEx(
+            description="Get the EIA's Weekly Petroleum Status Report.",
+            parameters={"provider": "eia"},
+        ),
+        APIEx(
+            description="Select the category of data, and filter for a specific table within the report.",
+            parameters={
+                "category": "weekly_estimates",
+                "table": "imports",
+                "provider": "eia",
+            },
+        ),
+    ],
+)
+async def petroleum_status_report(
+    cc: CommandContext,
+    provider_choices: ProviderChoices,
+    standard_params: StandardParams,
+    extra_params: ExtraParams,
+) -> OBBject:
+    """EIA Weekly Petroleum Status Report."""
+    return await OBBject.from_query(Query(**locals()))
+
+
+@router.command(
+    model="ShortTermEnergyOutlook",
+    examples=[
+        APIEx(
+            description="Get the EIA's Short Term Energy Outlook.",
+            parameters={"provider": "eia"},
+        ),
+        APIEx(
+            description="Select the specific table of data from the STEO. Table 03d is World Crude Oil Production.",
+            parameters={
+                "table": "03d",
+                "provider": "eia",
+            },
+        ),
+    ],
+)
+async def short_term_energy_outlook(
+    cc: CommandContext,
+    provider_choices: ProviderChoices,
+    standard_params: StandardParams,
+    extra_params: ExtraParams,
+) -> OBBject:
+    """Monthly short term (18 month) projections using EIA's STEO model.
+
+    Source: www.eia.gov/steo/
+    """
+    return await OBBject.from_query(Query(**locals()))

openbb_platform/extensions/commodity/openbb_commodity/price/__init__.py

@@ -0,0 +1 @@
+"""Commodity Price."""

openbb_platform/extensions/commodity/openbb_commodity/price/price_router.py

@@ -0,0 +1,33 @@
+"""Price Router."""
+
+# pylint: disable=unused-argument
+
+from openbb_core.app.model.command_context import CommandContext
+from openbb_core.app.model.example import APIEx
+from openbb_core.app.model.obbject import OBBject
+from openbb_core.app.provider_interface import (
+    ExtraParams,
+    ProviderChoices,
+    StandardParams,
+)
+from openbb_core.app.query import Query
+from openbb_core.app.router import Router
+
+router = Router(prefix="/price")
+
+
+@router.command(
+    model="CommoditySpotPrices",
+    examples=[
+        APIEx(parameters={"provider": "fred"}),
+        APIEx(parameters={"provider": "fred", "commodity": "wti"}),
+    ],
+)
+async def spot(
+    cc: CommandContext,
+    provider_choices: ProviderChoices,
+    standard_params: StandardParams,
+    extra_params: ExtraParams,
+) -> OBBject:
+    """Commodity Spot Prices."""
+    return await OBBject.from_query(Query(**locals()))

openbb_platform/extensions/commodity/pyproject.toml

@@ -0,0 +1,19 @@
+[tool.poetry]
+name = "openbb-commodity"
+version = "1.3.1"
+description = "Commodity extension for OpenBB"
+authors = ["OpenBB Team <hello@openbb.co>"]
+license = "AGPL-3.0-only"
+readme = "README.md"
+packages = [{ include = "openbb_commodity" }]
+
+[tool.poetry.dependencies]
+python = ">=3.9.21,<3.13"
+openbb-core = "^1.4.6"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.poetry.plugins."openbb_core_extension"]
+commodity = "openbb_commodity.commodity_router:router"

openbb_platform/extensions/crypto/README.md

@@ -0,0 +1,13 @@
+# Crypto data extension for OpenBB Platform
+
+This extension provides a set of commands for crypto data retrieval.
+
+## Installation
+
+To install the extension, run the following command in this folder:
+
+```bash
+pip install openbb-crypto
+```
+
+Documentation available [here](https://docs.openbb.co/platform/developer_guide/contributing).

openbb_platform/extensions/crypto/integration/test_crypto_api.py

@@ -0,0 +1,126 @@
+"""Test crypto API endpoints."""
+
+import base64
+
+import pytest
+import requests
+from extensions.tests.conftest import parametrize
+from openbb_core.env import Env
+from openbb_core.provider.utils.helpers import get_querystring
+
+# pylint: disable=redefined-outer-name
+
+
+@pytest.fixture(scope="session")
+def headers():
+    """Get the headers for the API request."""
+    userpass = f"{Env().API_USERNAME}:{Env().API_PASSWORD}"
+    userpass_bytes = userpass.encode("ascii")
+    base64_bytes = base64.b64encode(userpass_bytes)
+
+    return {"Authorization": f"Basic {base64_bytes.decode('ascii')}"}
+
+
+@parametrize(
+    "params",
+    [
+        ({"query": "asd"}),
+        ({"query": "btc", "provider": "fmp"}),
+    ],
+)
+@pytest.mark.integration
+def test_crypto_search(params, headers):
+    """Test the crypto search endpoint."""
+    params = {p: v for p, v in params.items() if v}
+
+    query_str = get_querystring(params, [])
+    url = f"http://0.0.0.0:8000/api/v1/crypto/search?{query_str}"
+    result = requests.get(url, headers=headers, timeout=10)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@parametrize(
+    "params",
+    [
+        (
+            {
+                "interval": "1d",
+                "provider": "fmp",
+                "symbol": "BTCUSD",
+                "start_date": "2023-01-01",
+                "end_date": "2023-01-02",
+            }
+        ),
+        (
+            {
+                "interval": "1h",
+                "provider": "fmp",
+                "symbol": "BTCUSD,ETHUSD",
+                "start_date": None,
+                "end_date": None,
+            }
+        ),
+        (
+            {
+                "interval": "1m",
+                "sort": "desc",
+                "limit": 49999,
+                "provider": "polygon",
+                "symbol": "BTCUSD",
+                "start_date": "2023-01-01",
+                "end_date": "2023-01-02",
+            }
+        ),
+        (
+            {
+                "interval": "1d",
+                "sort": "desc",
+                "limit": 49999,
+                "provider": "polygon",
+                "symbol": "BTCUSD",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        ),
+        (
+            {
+                "interval": "1d",
+                "provider": "yfinance",
+                "symbol": "BTCUSD",
+                "start_date": "2023-01-01",
+                "end_date": "2023-01-04",
+            }
+        ),
+        (
+            {
+                "provider": "tiingo",
+                "interval": "1d",
+                "exchanges": None,
+                "symbol": "BTCUSD",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        ),
+        (
+            {
+                "provider": "tiingo",
+                "interval": "1h",
+                "exchanges": ["POLONIEX", "GDAX"],
+                "symbol": "BTCUSD",
+                "start_date": "2023-01-01",
+                "end_date": "2023-01-02",
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_crypto_price_historical(params, headers):
+    """Test the crypto historical price endpoint."""
+    params = {p: v for p, v in params.items() if v}
+
+    query_str = get_querystring(params, [])
+    url = f"http://0.0.0.0:8000/api/v1/crypto/price/historical?{query_str}"
+    result = requests.get(url, headers=headers, timeout=10)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200

openbb_platform/extensions/crypto/integration/test_crypto_python.py

@@ -0,0 +1,117 @@
+"""Test crypto extension."""
+
+import pytest
+from extensions.tests.conftest import parametrize
+from openbb_core.app.model.obbject import OBBject
+
+# pylint: disable=redefined-outer-name
+
+
+@pytest.fixture(scope="session")
+def obb(pytestconfig):  # pylint: disable=inconsistent-return-statements
+    """Fixture to setup obb."""
+    if pytestconfig.getoption("markexpr") != "not integration":
+        import openbb  # pylint: disable=import-outside-toplevel
+
+        return openbb.obb
+
+
+@parametrize(
+    "params",
+    [
+        ({"query": "asd"}),
+        ({"query": "btc", "provider": "fmp"}),
+    ],
+)
+@pytest.mark.integration
+def test_crypto_search(params, obb):
+    """Test the crypto search endpoint."""
+    params = {p: v for p, v in params.items() if v}
+
+    result = obb.crypto.search(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+
+
+@parametrize(
+    "params",
+    [
+        (
+            {
+                "interval": "1d",
+                "provider": "fmp",
+                "symbol": "BTCUSD",
+                "start_date": "2023-01-01",
+                "end_date": "2023-01-02",
+            }
+        ),
+        (
+            {
+                "interval": "1h",
+                "provider": "fmp",
+                "symbol": "BTCUSD,ETHUSD",
+                "start_date": None,
+                "end_date": None,
+            }
+        ),
+        (
+            {
+                "interval": "1m",
+                "sort": "desc",
+                "limit": 49999,
+                "provider": "polygon",
+                "symbol": "BTCUSD",
+                "start_date": "2023-01-01",
+                "end_date": "2023-01-02",
+            }
+        ),
+        (
+            {
+                "interval": "1d",
+                "sort": "desc",
+                "limit": 49999,
+                "provider": "polygon",
+                "symbol": "BTCUSD",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        ),
+        (
+            {
+                "interval": "1d",
+                "provider": "yfinance",
+                "symbol": "BTCUSD",
+                "start_date": "2023-01-01",
+                "end_date": "2023-01-04",
+            }
+        ),
+        (
+            {
+                "provider": "tiingo",
+                "interval": "1d",
+                "exchanges": None,
+                "symbol": "BTCUSD",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        ),
+        (
+            {
+                "provider": "tiingo",
+                "interval": "1h",
+                "exchanges": ["POLONIEX", "GDAX"],
+                "symbol": "BTCUSD",
+                "start_date": "2023-01-01",
+                "end_date": "2023-01-02",
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_crypto_price_historical(params, obb):
+    """Test crypto price historical."""
+    result = obb.crypto.price.historical(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0

openbb_platform/extensions/crypto/openbb_crypto/__init__.py

@@ -0,0 +1 @@
+"""OpenBB Crypto Extension."""

openbb_platform/extensions/crypto/openbb_crypto/crypto_router.py

@@ -0,0 +1,35 @@
+"""Crypto Router."""
+
+from openbb_core.app.model.command_context import CommandContext
+from openbb_core.app.model.example import APIEx
+from openbb_core.app.model.obbject import OBBject
+from openbb_core.app.provider_interface import (
+    ExtraParams,
+    ProviderChoices,
+    StandardParams,
+)
+from openbb_core.app.query import Query
+from openbb_core.app.router import Router
+
+from openbb_crypto.price.price_router import router as price_router
+
+router = Router(prefix="", description="Cryptocurrency market data.")
+router.include_router(price_router)
+
+
+# pylint: disable=unused-argument
+@router.command(
+    model="CryptoSearch",
+    examples=[
+        APIEx(parameters={"provider": "fmp"}),
+        APIEx(parameters={"query": "BTCUSD", "provider": "fmp"}),
+    ],
+)
+async def search(
+    cc: CommandContext,
+    provider_choices: ProviderChoices,
+    standard_params: StandardParams,
+    extra_params: ExtraParams,
+) -> OBBject:
+    """Search available cryptocurrency pairs within a provider."""
+    return await OBBject.from_query(Query(**locals()))

openbb_platform/extensions/crypto/openbb_crypto/crypto_views.py

@@ -0,0 +1,22 @@
+"""Views for the crypto Extension."""
+
+from typing import TYPE_CHECKING, Any, Dict, Tuple
+
+if TYPE_CHECKING:
+    from openbb_charting.core.openbb_figure import (
+        OpenBBFigure,
+    )
+
+
+class CryptoViews:
+    """Crypto Views."""
+
+    @staticmethod
+    def crypto_price_historical(  # noqa: PLR0912
+        **kwargs,
+    ) -> Tuple["OpenBBFigure", Dict[str, Any]]:
+        """Crypto Price Historical Chart."""
+        # pylint: disable=import-outside-toplevel
+        from openbb_charting.charts.price_historical import price_historical
+
+        return price_historical(**kwargs)

openbb_platform/extensions/crypto/openbb_crypto/price/__init__.py

@@ -0,0 +1 @@
+"""OpenBB Crypto Price Router."""

openbb_platform/extensions/crypto/openbb_crypto/price/price_router.py

@@ -0,0 +1,58 @@
+# pylint: disable=W0613:unused-argument
+"""Crypto Price Router."""
+
+from openbb_core.app.model.command_context import CommandContext
+from openbb_core.app.model.example import APIEx
+from openbb_core.app.model.obbject import OBBject
+from openbb_core.app.provider_interface import (
+    ExtraParams,
+    ProviderChoices,
+    StandardParams,
+)
+from openbb_core.app.query import Query
+from openbb_core.app.router import Router
+
+router = Router(prefix="/price")
+
+
+# pylint: disable=unused-argument,line-too-long
+@router.command(
+    model="CryptoHistorical",
+    examples=[
+        APIEx(parameters={"symbol": "BTCUSD", "provider": "fmp"}),
+        APIEx(
+            parameters={
+                "symbol": "BTCUSD",
+                "start_date": "2024-01-01",
+                "end_date": "2024-01-31",
+                "provider": "fmp",
+            },
+        ),
+        APIEx(
+            parameters={
+                "symbol": "BTCUSD,ETHUSD",
+                "start_date": "2024-01-01",
+                "end_date": "2024-01-31",
+                "provider": "polygon",
+            },
+        ),
+        APIEx(
+            description="Get monthly historical prices from Yahoo Finance for Ethereum.",
+            parameters={
+                "symbol": "ETH-USD",
+                "interval": "1m",
+                "start_date": "2024-01-01",
+                "end_date": "2024-12-31",
+                "provider": "yfinance",
+            },
+        ),
+    ],
+)
+async def historical(
+    cc: CommandContext,
+    provider_choices: ProviderChoices,
+    standard_params: StandardParams,
+    extra_params: ExtraParams,
+) -> OBBject:
+    """Get historical price data for cryptocurrency pair(s) within a provider."""
+    return await OBBject.from_query(Query(**locals()))

openbb_platform/extensions/crypto/pyproject.toml

@@ -0,0 +1,22 @@
+[tool.poetry]
+name = "openbb-crypto"
+version = "1.4.1"
+description = "Crypto extension for OpenBB"
+authors = ["OpenBB Team <hello@openbb.co>"]
+license = "AGPL-3.0-only"
+readme = "README.md"
+packages = [{ include = "openbb_crypto" }]
+
+[tool.poetry.dependencies]
+python = ">=3.9.21,<3.13"
+openbb-core = "^1.4.6"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.poetry.plugins."openbb_core_extension"]
+crypto = "openbb_crypto.crypto_router:router"
+
+[tool.poetry.plugins."openbb_charting_extension"]
+crypto = "openbb_crypto.crypto_views:CryptoViews"

openbb_platform/extensions/currency/README.md

@@ -0,0 +1,13 @@
+# OpenBB Currency Extension
+
+This extension provides currency exchange related data for the OpenBB Platform.
+
+## Installation
+
+To install the extension, run the following command in this folder:
+
+```bash
+pip install openbb-currency
+```
+
+Documentation available [here](https://docs.openbb.co/platform/developer_guide/contributing).

openbb_platform/extensions/currency/integration/test_currency_api.py

@@ -0,0 +1,198 @@
+"""Test currency API endpoints."""
+
+import base64
+
+import pytest
+import requests
+from extensions.tests.conftest import parametrize
+from openbb_core.env import Env
+from openbb_core.provider.utils.helpers import get_querystring
+
+# pylint: disable=redefined-outer-name
+
+
+@pytest.fixture(scope="session")
+def headers():
+    """Get the headers for the API request."""
+    userpass = f"{Env().API_USERNAME}:{Env().API_PASSWORD}"
+    userpass_bytes = userpass.encode("ascii")
+    base64_bytes = base64.b64encode(userpass_bytes)
+
+    return {"Authorization": f"Basic {base64_bytes.decode('ascii')}"}
+
+
+@parametrize(
+    "params",
+    [
+        (
+            {
+                "provider": "polygon",
+                "query": "eur",
+            }
+        ),
+        (
+            {
+                "provider": "fmp",
+                "query": "eur",
+            }
+        ),
+        (
+            {
+                "provider": "intrinio",
+                "query": "eur",
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_currency_search(params, headers):
+    """Test the currency search endpoint."""
+    params = {p: v for p, v in params.items() if v}
+
+    query_str = get_querystring(params, [])
+    url = f"http://0.0.0.0:8000/api/v1/currency/search?{query_str}"
+    result = requests.get(url, headers=headers, timeout=10)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@parametrize(
+    "params",
+    [
+        (
+            {
+                "symbol": "EURUSD",
+                "interval": "1d",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+                "provider": "fmp",
+            }
+        ),
+        (
+            {
+                "interval": "1h",
+                "provider": "fmp",
+                "symbol": "EURUSD,USDJPY",
+                "start_date": None,
+                "end_date": None,
+            }
+        ),
+        (
+            {
+                "interval": "1m",
+                "sort": "desc",
+                "limit": 49999,
+                "provider": "polygon",
+                "symbol": "EURUSD",
+                "start_date": "2023-01-01",
+                "end_date": "2023-01-10",
+            }
+        ),
+        (
+            {
+                "interval": "1d",
+                "sort": "desc",
+                "limit": 49999,
+                "provider": "polygon",
+                "symbol": "EURUSD",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        ),
+        (
+            {
+                "interval": "1d",
+                "provider": "yfinance",
+                "symbol": "EURUSD",
+                "start_date": "2023-01-01",
+                "end_date": "2023-01-10",
+            }
+        ),
+        (
+            {
+                "interval": "1m",
+                "provider": "yfinance",
+                "symbol": "EURUSD",
+                "start_date": None,
+                "end_date": None,
+            }
+        ),
+        (
+            {
+                "interval": "1h",
+                "provider": "tiingo",
+                "symbol": "EURUSD",
+                "start_date": "2023-05-21",
+                "end_date": "2023-06-06",
+            }
+        ),
+        (
+            {
+                "interval": "1d",
+                "provider": "tiingo",
+                "symbol": "EURUSD",
+                "start_date": "2023-05-21",
+                "end_date": "2023-06-06",
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_currency_price_historical(params, headers):
+    """Test the currency historical price endpoint."""
+    params = {p: v for p, v in params.items() if v}
+
+    query_str = get_querystring(params, [])
+    url = f"http://0.0.0.0:8000/api/v1/currency/price/historical?{query_str}"
+    result = requests.get(url, headers=headers, timeout=10)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@parametrize(
+    "params",
+    [({"provider": "ecb"})],
+)
+@pytest.mark.integration
+def test_currency_reference_rates(params, headers):
+    """Test the currency reference rates endpoint."""
+    params = {p: v for p, v in params.items() if v}
+
+    query_str = get_querystring(params, [])
+    url = f"http://0.0.0.0:8000/api/v1/currency/reference_rates?{query_str}"
+    result = requests.get(url, headers=headers, timeout=10)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@parametrize(
+    "params",
+    [
+        (
+            {
+                "provider": "fmp",
+                "base": "USD,XAU",
+                "counter_currencies": "EUR,JPY,GBP",
+                "quote_type": "indirect",
+            }
+        ),
+        (
+            {
+                "provider": "polygon",
+                "base": "USD,XAU",
+                "counter_currencies": "EUR,JPY,GBP",
+                "quote_type": "indirect",
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_currency_snapshots(params, headers):
+    """Test the currency snapshots endpoint."""
+    params = {p: v for p, v in params.items() if v}
+
+    query_str = get_querystring(params, [])
+    url = f"http://0.0.0.0:8000/api/v1/currency/snapshots?{query_str}"
+    result = requests.get(url, headers=headers, timeout=10)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200

openbb_platform/extensions/currency/integration/test_currency_python.py

@@ -0,0 +1,183 @@
+"""Test currency extension."""
+
+import pytest
+from extensions.tests.conftest import parametrize
+from openbb_core.app.model.obbject import OBBject
+
+# pylint: disable=redefined-outer-name
+# pylint: disable=inconsistent-return-statements
+
+
+@pytest.fixture(scope="session")
+def obb(pytestconfig):
+    """Fixture to setup obb."""
+
+    if pytestconfig.getoption("markexpr") != "not integration":
+        import openbb  # pylint: disable=import-outside-toplevel
+
+        return openbb.obb
+
+
+@parametrize(
+    "params",
+    [
+        (
+            {
+                "provider": "polygon",
+                "query": "eur",
+            }
+        ),
+        (
+            {
+                "provider": "fmp",
+                "query": "eur",
+            }
+        ),
+        (
+            {
+                "provider": "intrinio",
+                "query": "eur",
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_currency_search(params, obb):
+    """Test the currency search endpoint."""
+    result = obb.currency.search(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+
+
+@parametrize(
+    "params",
+    [
+        (
+            {
+                "symbol": "EURUSD",
+                "interval": "1d",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+                "provider": "fmp",
+            }
+        ),
+        (
+            {
+                "interval": "1h",
+                "provider": "fmp",
+                "symbol": "EURUSD,USDJPY",
+                "start_date": None,
+                "end_date": None,
+            }
+        ),
+        (
+            {
+                "interval": "1m",
+                "sort": "desc",
+                "limit": 49999,
+                "provider": "polygon",
+                "symbol": "EURUSD",
+                "start_date": "2023-01-01",
+                "end_date": "2023-01-10",
+            }
+        ),
+        (
+            {
+                "interval": "1d",
+                "sort": "desc",
+                "limit": 49999,
+                "provider": "polygon",
+                "symbol": "EURUSD",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        ),
+        (
+            {
+                "interval": "1d",
+                "provider": "yfinance",
+                "symbol": "EURUSD",
+                "start_date": "2023-01-01",
+                "end_date": "2023-01-10",
+            }
+        ),
+        (
+            {
+                "interval": "1m",
+                "provider": "yfinance",
+                "symbol": "EURUSD",
+                "start_date": None,
+                "end_date": None,
+            }
+        ),
+        (
+            {
+                "interval": "1h",
+                "provider": "tiingo",
+                "symbol": "EURUSD",
+                "start_date": "2023-05-21",
+                "end_date": "2023-06-06",
+            }
+        ),
+        (
+            {
+                "interval": "1d",
+                "provider": "tiingo",
+                "symbol": "EURUSD",
+                "start_date": "2023-05-21",
+                "end_date": "2023-06-06",
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_currency_price_historical(params, obb):
+    """Test the currency historical price endpoint."""
+    result = obb.currency.price.historical(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+
+
+@parametrize(
+    "params",
+    [({"provider": "ecb"})],
+)
+@pytest.mark.integration
+def test_currency_reference_rates(params, obb):
+    """Test the currency reference rates endpoint."""
+    result = obb.currency.reference_rates(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.model_dump()["results"].items()) > 0
+
+
+@parametrize(
+    "params",
+    [
+        (
+            {
+                "provider": "fmp",
+                "base": "USD,XAU",
+                "counter_currencies": "EUR,JPY,GBP",
+                "quote_type": "indirect",
+            }
+        ),
+        (
+            {
+                "provider": "polygon",
+                "base": "USD,XAU",
+                "counter_currencies": "EUR,JPY,GBP",
+                "quote_type": "indirect",
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_currency_snapshots(params, obb):
+    """Test the currency snapshots endpoint."""
+    result = obb.currency.snapshots(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0

openbb_platform/extensions/currency/openbb_currency/__init__.py

@@ -0,0 +1 @@
+"""The Currency router init."""

openbb_platform/extensions/currency/openbb_currency/currency_router.py

@@ -0,0 +1,99 @@
+"""The Currency router."""
+
+from openbb_core.app.model.command_context import CommandContext
+from openbb_core.app.model.example import APIEx
+from openbb_core.app.model.obbject import OBBject
+from openbb_core.app.provider_interface import (
+    ExtraParams,
+    ProviderChoices,
+    StandardParams,
+)
+from openbb_core.app.query import Query
+from openbb_core.app.router import Router
+
+from openbb_currency.price.price_router import router as price_router
+
+router = Router(prefix="", description="Foreign exchange (FX) market data.")
+router.include_router(price_router)
+
+
+# pylint: disable=unused-argument
+@router.command(
+    model="CurrencyPairs",
+    examples=[
+        APIEx(parameters={"provider": "fmp"}),
+        APIEx(
+            description="Search for 'EUR' currency pair using 'intrinio' as provider.",
+            parameters={"provider": "intrinio", "query": "EUR"},
+        ),
+        APIEx(
+            description="Search for terms  using 'polygon' as provider.",
+            parameters={"provider": "polygon", "query": "EUR"},
+        ),
+    ],
+)
+async def search(
+    cc: CommandContext,
+    provider_choices: ProviderChoices,
+    standard_params: StandardParams,
+    extra_params: ExtraParams,
+) -> OBBject:
+    """Currency Search.
+
+    Search available currency pairs.
+    Currency pairs are the national currencies from two countries coupled for trading on
+    the foreign exchange (FX) marketplace.
+    Both currencies will have exchange rates on which the trade will have its position basis.
+    All trading within the forex market, whether selling, buying, or trading, will take place through currency pairs.
+    (ref: Investopedia)
+    Major currency pairs include pairs such as EUR/USD, USD/JPY, GBP/USD, etc.
+    """
+    return await OBBject.from_query(Query(**locals()))
+
+
+@router.command(
+    model="CurrencyReferenceRates",
+    examples=[APIEx(parameters={"provider": "ecb"})],
+)
+async def reference_rates(
+    cc: CommandContext,
+    provider_choices: ProviderChoices,
+    standard_params: StandardParams,
+    extra_params: ExtraParams,
+) -> OBBject:
+    """Get current, official, currency reference rates.
+
+    Foreign exchange reference rates are the exchange rates set by a major financial institution or regulatory body,
+    serving as a benchmark for the value of currencies around the world.
+    These rates are used as a standard to facilitate international trade and financial transactions,
+    ensuring consistency and reliability in currency conversion.
+    They are typically updated on a daily basis and reflect the market conditions at a specific time.
+    Central banks and financial institutions often use these rates to guide their own exchange rates,
+    impacting global trade, loans, and investments.
+    """
+    return await OBBject.from_query(Query(**locals()))
+
+
+@router.command(
+    model="CurrencySnapshots",
+    examples=[
+        APIEx(parameters={"provider": "fmp"}),
+        APIEx(
+            description="Get exchange rates from USD and XAU to EUR, JPY, and GBP using 'fmp' as provider.",
+            parameters={
+                "provider": "fmp",
+                "base": "USD,XAU",
+                "counter_currencies": "EUR,JPY,GBP",
+                "quote_type": "indirect",
+            },
+        ),
+    ],
+)
+async def snapshots(
+    cc: CommandContext,
+    provider_choices: ProviderChoices,
+    standard_params: StandardParams,
+    extra_params: ExtraParams,
+) -> OBBject:
+    """Snapshots of currency exchange rates from an indirect or direct perspective of a base currency."""
+    return await OBBject.from_query(Query(**locals()))

openbb_platform/extensions/currency/openbb_currency/currency_views.py

@@ -0,0 +1,22 @@
+"""Views for the Currency Extension."""
+
+from typing import TYPE_CHECKING, Any, Dict, Tuple
+
+if TYPE_CHECKING:
+    from openbb_charting.core.openbb_figure import (
+        OpenBBFigure,
+    )
+
+
+class CurrencyViews:
+    """Currency Views."""
+
+    @staticmethod
+    def currency_price_historical(  # noqa: PLR0912
+        **kwargs,
+    ) -> Tuple["OpenBBFigure", Dict[str, Any]]:
+        """Currency Price Historical Chart."""
+        # pylint: disable=import-outside-toplevel
+        from openbb_charting.charts.price_historical import price_historical
+
+        return price_historical(**kwargs)

openbb_platform/extensions/currency/openbb_currency/price/__init__.py

@@ -0,0 +1 @@
+"""The Currency price router init."""

openbb_platform/extensions/currency/openbb_currency/price/price_router.py

@@ -0,0 +1,53 @@
+"""Price router for Currency."""
+
+# pylint: disable=unused-argument
+from openbb_core.app.model.command_context import CommandContext
+from openbb_core.app.model.example import APIEx
+from openbb_core.app.model.obbject import OBBject
+from openbb_core.app.provider_interface import (
+    ExtraParams,
+    ProviderChoices,
+    StandardParams,
+)
+from openbb_core.app.query import Query
+from openbb_core.app.router import Router
+
+router = Router(prefix="/price")
+
+
+# pylint: disable=unused-argument
+@router.command(
+    model="CurrencyHistorical",
+    examples=[
+        APIEx(parameters={"symbol": "EURUSD", "provider": "fmp"}),
+        APIEx(
+            description="Filter historical data with specific start and end date.",
+            parameters={
+                "symbol": "EURUSD",
+                "start_date": "2023-01-01",
+                "end_date": "2023-12-31",
+                "provider": "fmp",
+            },
+        ),
+        APIEx(
+            description="Get data with different granularity.",
+            parameters={"symbol": "EURUSD", "provider": "polygon", "interval": "15m"},
+        ),
+    ],
+)
+async def historical(
+    cc: CommandContext,
+    provider_choices: ProviderChoices,
+    standard_params: StandardParams,
+    extra_params: ExtraParams,
+) -> OBBject:
+    """
+    Currency Historical Price. Currency historical data.
+
+    Currency historical prices refer to the past exchange rates of one currency against
+    another over a specific period.
+    This data provides insight into the fluctuations and trends in the foreign exchange market,
+    helping analysts, traders, and economists understand currency performance,
+    evaluate economic health, and make predictions about future movements.
+    """
+    return await OBBject.from_query(Query(**locals()))

openbb_platform/extensions/currency/pyproject.toml

@@ -0,0 +1,22 @@
+[tool.poetry]
+name = "openbb-currency"
+version = "1.4.1"
+description = "Currency extension for OpenBB"
+authors = ["OpenBB Team <hello@openbb.co>"]
+license = "AGPL-3.0-only"
+readme = "README.md"
+packages = [{ include = "openbb_currency" }]
+
+[tool.poetry.dependencies]
+python = ">=3.9.21,<3.13"
+openbb-core = "^1.4.6"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.poetry.plugins."openbb_core_extension"]
+currency = "openbb_currency.currency_router:router"
+
+[tool.poetry.plugins."openbb_charting_extension"]
+currency = "openbb_currency.currency_views:CurrencyViews"

openbb_platform/extensions/derivatives/README.md

@@ -0,0 +1,13 @@
+# OpenBB Derivatives Extension
+
+This extension provides derivatives data for the OpenBB Platform.
+
+## Installation
+
+To install the extension, run the following command in this folder:
+
+```bash
+pip install openbb-derivatives
+```
+
+Documentation available [here](https://docs.openbb.co/sdk).

openbb_platform/extensions/derivatives/integration/test_derivatives_api.py

@@ -0,0 +1,224 @@
+"""API integration tests for the derivatives extension."""
+
+import base64
+
+import pytest
+import requests
+from extensions.tests.conftest import parametrize
+from openbb_core.env import Env
+from openbb_core.provider.utils.helpers import get_querystring
+
+# pylint: disable=too-many-lines,redefined-outer-name
+
+
+@pytest.fixture(scope="session")
+def headers():
+    """Get the headers for the API request."""
+    userpass = f"{Env().API_USERNAME}:{Env().API_PASSWORD}"
+    userpass_bytes = userpass.encode("ascii")
+    base64_bytes = base64.b64encode(userpass_bytes)
+
+    return {"Authorization": f"Basic {base64_bytes.decode('ascii')}"}
+
+
+@parametrize(
+    "params",
+    [
+        (
+            {
+                "provider": "intrinio",
+                "symbol": "AAPL",
+                "date": "2023-01-25",
+                "option_type": None,
+                "moneyness": "all",
+                "strike_gt": None,
+                "strike_lt": None,
+                "volume_gt": None,
+                "volume_lt": None,
+                "oi_gt": None,
+                "oi_lt": None,
+                "model": "black_scholes",
+                "show_extended_price": False,
+                "include_related_symbols": False,
+                "delay": "delayed",
+            }
+        ),
+        ({"provider": "cboe", "symbol": "AAPL", "use_cache": False}),
+        ({"provider": "tradier", "symbol": "AAPL"}),
+        ({"provider": "yfinance", "symbol": "AAPL"}),
+        ({"provider": "deribit", "symbol": "BTC"}),
+        (
+            {
+                "provider": "tmx",
+                "symbol": "SHOP",
+                "date": "2022-12-28",
+                "use_cache": False,
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_derivatives_options_chains(params, headers):
+    """Test the options chains endpoint."""
+    params = {p: v for p, v in params.items() if v}
+
+    query_str = get_querystring(params, [])
+    url = f"http://0.0.0.0:8000/api/v1/derivatives/options/chains?{query_str}"
+    result = requests.get(url, headers=headers, timeout=10)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@parametrize(
+    "params",
+    [
+        (
+            {
+                "symbol": "AAPL",
+                "provider": "intrinio",
+                "start_date": "2023-11-20",
+                "end_date": None,
+                "min_value": None,
+                "max_value": None,
+                "trade_type": None,
+                "sentiment": "neutral",
+                "limit": 1000,
+                "source": "delayed",
+            }
+        )
+    ],
+)
+@pytest.mark.integration
+def test_derivatives_options_unusual(params, headers):
+    """Test the unusual options endpoint."""
+    params = {p: v for p, v in params.items() if v}
+
+    query_str = get_querystring(params, [])
+    url = f"http://0.0.0.0:8000/api/v1/derivatives/options/unusual?{query_str}"
+    result = requests.get(url, headers=headers, timeout=10)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@parametrize(
+    "params",
+    [
+        (
+            {
+                "provider": "yfinance",
+                "interval": "1d",
+                "symbol": "CL,BZ",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+                "expiration": "2025-12",
+            }
+        ),
+        (
+            {
+                "provider": "deribit",
+                "interval": "1d",
+                "symbol": "BTC,ETH",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_derivatives_futures_historical(params, headers):
+    """Test the futures historical endpoint."""
+    params = {p: v for p, v in params.items() if v}
+
+    query_str = get_querystring(params, [])
+    url = f"http://0.0.0.0:8000/api/v1/derivatives/futures/historical?{query_str}"
+    result = requests.get(url, headers=headers, timeout=10)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@parametrize(
+    "params",
+    [
+        (
+            {
+                "provider": "yfinance",
+                "symbol": "ES",
+                "date": None,
+            }
+        ),
+        (
+            {
+                "provider": "cboe",
+                "symbol": "VX_EOD",
+                "date": "2024-06-25",
+            }
+        ),
+        ({"provider": "deribit", "date": None, "symbol": "BTC", "hours_ago": 12}),
+    ],
+)
+@pytest.mark.integration
+def test_derivatives_futures_curve(params, headers):
+    """Test the futures curve endpoint."""
+    params = {p: v for p, v in params.items() if v}
+
+    query_str = get_querystring(params, [])
+    url = f"http://0.0.0.0:8000/api/v1/derivatives/futures/curve?{query_str}"
+    result = requests.get(url, headers=headers, timeout=10)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@parametrize(
+    "params",
+    [
+        ({"provider": "intrinio", "date": None, "only_traded": True}),
+    ],
+)
+@pytest.mark.skip(
+    reason="This test is skipped because the download is excessively large."
+)
+def test_derivatives_options_snapshots(params, headers):
+    """Test the options snapshots endpoint."""
+    params = {p: v for p, v in params.items() if v}
+
+    query_str = get_querystring(params, [])
+    url = f"http://0.0.0.0:8000/api/v1/derivatives/options/snapshots?{query_str}"
+    result = requests.get(url, headers=headers, timeout=60)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@parametrize(
+    "params",
+    [
+        ({"provider": "deribit"}),
+    ],
+)
+@pytest.mark.integration
+def test_derivatives_futures_instruments(params, headers):
+    """Test the futures instruments endpoint."""
+    params = {p: v for p, v in params.items() if v}
+
+    query_str = get_querystring(params, [])
+    url = f"http://0.0.0.0:8000/api/v1/derivatives/futures/instruments?{query_str}"
+    result = requests.get(url, headers=headers, timeout=10)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@parametrize(
+    "params",
+    [
+        ({"provider": "deribit", "symbol": "ETH-PERPETUAL"}),
+    ],
+)
+@pytest.mark.integration
+def test_derivatives_futures_info(params, headers):
+    """Test the futures info endpoint."""
+    params = {p: v for p, v in params.items() if v}
+
+    query_str = get_querystring(params, [])
+    url = f"http://0.0.0.0:8000/api/v1/derivatives/futures/info?{query_str}"
+    result = requests.get(url, headers=headers, timeout=10)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200

openbb_platform/extensions/derivatives/integration/test_derivatives_python.py

@@ -0,0 +1,198 @@
+"""Python interface integration tests for the derivatives extension."""
+
+import pytest
+from extensions.tests.conftest import parametrize
+from openbb_core.app.model.obbject import OBBject
+
+# pylint: disable=too-many-lines,redefined-outer-name
+# pylint: disable=import-outside-toplevel,inconsistent-return-statements
+
+
+@pytest.fixture(scope="session")
+def obb(pytestconfig):
+    """Fixture to setup obb."""
+    if pytestconfig.getoption("markexpr") != "not integration":
+        import openbb
+
+        return openbb.obb
+
+
+@parametrize(
+    "params",
+    [
+        (
+            {
+                "provider": "intrinio",
+                "symbol": "AAPL",
+                "date": "2023-01-25",
+                "option_type": None,
+                "moneyness": "all",
+                "strike_gt": None,
+                "strike_lt": None,
+                "volume_gt": None,
+                "volume_lt": None,
+                "oi_gt": None,
+                "oi_lt": None,
+                "model": "black_scholes",
+                "show_extended_price": False,
+                "include_related_symbols": False,
+                "delay": "delayed",
+            }
+        ),
+        ({"provider": "cboe", "symbol": "AAPL", "use_cache": False}),
+        ({"provider": "tradier", "symbol": "AAPL"}),
+        ({"provider": "yfinance", "symbol": "AAPL"}),
+        ({"provider": "deribit", "symbol": "BTC"}),
+        (
+            {
+                "provider": "tmx",
+                "symbol": "SHOP",
+                "date": "2022-12-28",
+                "use_cache": False,
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_derivatives_options_chains(params, obb):
+    """Test the options chains endpoint."""
+    result = obb.derivatives.options.chains(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    result = result.results  # type: ignore
+    list_msg = "Unexpected data format, expected List"
+    oi_msg = "Unexpected keys in total_oi property, expected ['total', 'expiration', 'strike']"
+    assert isinstance(result.expirations, list), list_msg  # type: ignore
+    assert isinstance(result.strikes, list), list_msg  # type: ignore
+    assert isinstance(result.contract_symbol, list), list_msg  # type: ignore
+    assert hasattr(result, "total_oi"), "Missing total_oi property"  # type: ignore
+    assert isinstance(result.total_oi, dict), "Unexpected property format, expected dictionary."  # type: ignore
+    assert list(result.total_oi) == ["total", "expiration", "strike"], oi_msg  # type: ignore
+    assert hasattr(result, "dataframe"), "Missing dataframe attribute"  # type: ignore
+    assert result.has_iv, "Expected implied volatility data"  # type: ignore
+    assert len(getattr(result, "dataframe", [])) == len(result.contract_symbol)  # type: ignore
+
+
+@parametrize(
+    "params",
+    [
+        (
+            {
+                "symbol": "AAPL",
+                "provider": "intrinio",
+                "start_date": "2023-11-20",
+                "end_date": None,
+                "min_value": None,
+                "max_value": None,
+                "trade_type": None,
+                "sentiment": "neutral",
+                "limit": 1000,
+                "source": "delayed",
+            }
+        )
+    ],
+)
+@pytest.mark.integration
+def test_derivatives_options_unusual(params, obb):
+    """Test the unusual options endpoint."""
+    result = obb.derivatives.options.unusual(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+
+
+@parametrize(
+    "params",
+    [
+        (
+            {
+                "provider": "yfinance",
+                "interval": "1d",
+                "symbol": "CL,BZ",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+                "expiration": "2025-12",
+            }
+        ),
+        (
+            {
+                "provider": "deribit",
+                "interval": "1d",
+                "symbol": "BTC,ETH",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_derivatives_futures_historical(params, obb):
+    """Test the futures historical endpoint."""
+    result = obb.derivatives.futures.historical(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+
+
+@parametrize(
+    "params",
+    [
+        ({"provider": "yfinance", "symbol": "ES", "date": None}),
+        ({"provider": "cboe", "symbol": "VX", "date": "2024-06-25"}),
+        ({"provider": "deribit", "date": None, "symbol": "BTC", "hours_ago": 12}),
+    ],
+)
+@pytest.mark.integration
+def test_derivatives_futures_curve(params, obb):
+    """Test the futures curve endpoint."""
+    result = obb.derivatives.futures.curve(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+
+
+@parametrize(
+    "params",
+    [
+        ({"provider": "intrinio", "date": None, "only_traded": True}),
+    ],
+)
+@pytest.mark.skip(
+    reason="This test is skipped because the download is excessively large."
+)
+def test_derivatives_options_snapshots(params, obb):
+    """Test the options snapshots endpoint."""
+    result = obb.derivatives.options.snapshots(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+
+
+@parametrize(
+    "params",
+    [
+        ({"provider": "deribit"}),
+    ],
+)
+@pytest.mark.integration
+def test_derivatives_futures_instruments(params, obb):
+    """Test the futures instruments endpoint."""
+    result = obb.derivatives.futures.instruments(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+
+
+@parametrize(
+    "params",
+    [
+        ({"provider": "deribit", "symbol": "ETH-PERPETUAL"}),
+    ],
+)
+@pytest.mark.integration
+def test_derivatives_futures_info(params, obb):
+    """Test the futures info endpoint."""
+    result = obb.derivatives.futures.info(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0

openbb_platform/extensions/derivatives/openbb_derivatives/__init__.py

@@ -0,0 +1 @@
+"""Options."""

openbb_platform/extensions/derivatives/openbb_derivatives/derivatives_router.py

@@ -0,0 +1,10 @@
+"""Derivatives Router."""
+
+from openbb_core.app.router import Router
+
+from openbb_derivatives.futures.futures_router import router as futures_router
+from openbb_derivatives.options.options_router import router as options_router
+
+router = Router(prefix="", description="Derivatives market data.")
+router.include_router(options_router)
+router.include_router(futures_router)

openbb_platform/extensions/derivatives/openbb_derivatives/derivatives_views.py

@@ -0,0 +1,244 @@
+"""Views for the Derivatives Extension."""
+
+from typing import TYPE_CHECKING, Any, Dict, Tuple
+
+if TYPE_CHECKING:
+    from openbb_charting.core.openbb_figure import OpenBBFigure
+
+
+class DerivativesViews:
+    """Derivatives Views."""
+
+    @staticmethod
+    def derivatives_futures_historical(  # noqa: PLR0912
+        **kwargs,
+    ) -> Tuple["OpenBBFigure", Dict[str, Any]]:
+        """Get Derivatives Price Historical Chart."""
+        # pylint: disable=import-outside-toplevel
+        from openbb_charting.charts.price_historical import price_historical
+
+        kwargs.update({"candles": False, "same_axis": False})
+
+        return price_historical(**kwargs)
+
+    @staticmethod
+    def derivatives_futures_curve(  # noqa: PLR0912
+        **kwargs,
+    ) -> Tuple["OpenBBFigure", Dict[str, Any]]:
+        """Futures curve chart. All parameters are optional, and are kwargs.
+        Parameters can be directly accessed from the function end point by
+        entering as a nested dictionary to the 'chart_params' key.
+
+        From the API, `chart_params` must be passed as a JSON in the request body with `extra_params`.
+
+        If using the chart post-request, the parameters are passed directly
+        as `key=value` pairs in the `charting.to_chart` or `charting.show` methods.
+
+        Parameters
+        ----------
+        data : Optional[Union[List[Data], DataFrame]]
+            Data for the chart. Required fields are: 'expiration' and 'price'.
+            Multiple dates will be plotted on the same chart.
+            If not supplied, the original OBBject.results will be used.
+            If a DataFrame is supplied, flat data is expected, without a set index.
+        title: Optional[str]
+            Title for the chart. If not supplied, a default title will be used.
+        colors: Optional[List[str]]
+            List of colors to use for the chart. If not supplied, the default colorway will be used.
+            Colors should be in hex format, or named Plotly colors. Invalid colors will raise a Plotly error.
+        layout_kwargs: Optional[Dict[str, Any]]
+            Additional layout parameters for the chart, passed directly to `figure.update_layout` before output.
+            See Plotly documentation for available options.
+
+        Returns
+        -------
+        Tuple[OpenBBFigure, Dict[str, Any]]
+            Tuple with the OpenBBFigure object, and the JSON-serialized content.
+            If using the API, only the JSON content will be returned.
+
+        Examples
+        --------
+        ```python
+        from openbb import obb
+        data = obb.derivatives.futures.curve(symbol="vx", provider="cboe", date=["2020-03-31", "2024-06-28"], chart=True)
+        data.show()
+        ```
+
+        Redraw the chart, from the same data, with a custom colorway and title:
+
+        ```python
+        data.charting.to_chart(colors=["green", "red"], title="VIX Futures Curve - 2020 vs. 2024")
+        ```
+        """
+        # pylint: disable=import-outside-toplevel
+        from openbb_charting.core.chart_style import ChartStyle
+        from openbb_charting.core.openbb_figure import OpenBBFigure
+        from openbb_charting.styles.colors import LARGE_CYCLER
+        from openbb_core.app.model.abstract.error import OpenBBError
+        from openbb_core.provider.abstract.data import Data
+        from pandas import DataFrame, to_datetime
+
+        data = kwargs.get("data")
+        symbol = kwargs.get("standard_params", {}).get("symbol", "")
+        df: DataFrame = DataFrame()
+        if data:
+            if isinstance(data, DataFrame) and not data.empty:  # noqa: SIM108
+                df = data
+            elif isinstance(data, (list, Data)):
+                df = DataFrame([d.model_dump(exclude_none=True, exclude_unset=True) for d in data])  # type: ignore
+            else:
+                pass
+        else:
+            df = DataFrame(
+                [
+                    d.model_dump(exclude_none=True, exclude_unset=True)  # type: ignore
+                    for d in kwargs["obbject_item"]
+                ]
+                if isinstance(kwargs.get("obbject_item"), list)
+                else kwargs["obbject_item"].model_dump(exclude_none=True, exclude_unset=True)  # type: ignore
+            )
+
+        if df.empty:
+            raise OpenBBError("Error: No data to plot.")
+
+        if "expiration" not in df.columns:
+            raise OpenBBError("Expiration field not found in the data.")
+
+        if "price" not in df.columns:
+            raise ValueError("Price field not found in the data.")
+
+        provider = kwargs.get("provider", "")
+
+        if provider != "deribit":
+            df["expiration"] = df["expiration"].apply(to_datetime).dt.strftime("%b-%Y")
+
+        if (
+            provider == "cboe"
+            and "date" in df.columns
+            and len(df["date"].unique()) > 1
+            and "symbol" in df.columns
+        ):
+            df["expiration"] = df.symbol
+
+        # Use a complete list of expirations to categorize the x-axis across all dates.
+        expirations = df["expiration"].unique().tolist()
+
+        # Use the supplied colors, if any.
+        colors = kwargs.get("colors", [])
+        if not colors:
+            colors = LARGE_CYCLER
+        color_count = 0
+
+        figure = OpenBBFigure().create_subplots(shared_xaxes=True)
+        figure.update_layout(ChartStyle().plotly_template.get("layout", {}))
+        text_color = "white" if ChartStyle().plt_style == "dark" else "black"
+
+        def create_fig(figure, df, dates, color_count):
+            """Create a scatter for each date in the data."""
+            for date in dates:
+                color = colors[color_count % len(colors)]
+                plot_df = (
+                    df[df["date"].astype(str) == date].copy()
+                    if "date" in df.columns
+                    else df.copy()
+                )
+                plot_df = plot_df.drop(
+                    columns=["date"] if "date" in plot_df.columns else []
+                ).rename(columns={"expiration": "Expiration", "price": "Price"})
+                figure.add_scatter(
+                    x=plot_df["Expiration"],
+                    y=plot_df["Price"],
+                    mode="lines+markers",
+                    name=date,
+                    line=dict(width=3, color=color),
+                    marker=dict(size=10, color=color),
+                    hovertemplate=(
+                        "Expiration: %{x}<br>Price: $%{y}<extra></extra>"
+                        if len(dates) == 1
+                        else "%{fullData.name}<br>Expiration: %{x}<br>Price: $%{y}<extra></extra>"
+                    ),
+                )
+                color_count += 1
+            return figure, color_count
+
+        dates = (
+            df.date.astype(str).unique().tolist()
+            if "date" in df.columns
+            else ["Current"]
+        )
+
+        if provider == "deribit" and "hours_ago" in df.columns:
+            dates = [
+                str(d) + " Hours Ago" if d > 0 else "Current"
+                for d in df["hours_ago"].unique().tolist()
+            ]
+            df.loc[:, "date"] = df["hours_ago"].apply(
+                lambda x: str(x) + " Hours Ago" if x > 0 else "Current"
+            )
+        figure, color_count = create_fig(figure, df, dates, color_count)
+
+        # Set the title for the chart
+        title: str = ""
+        if provider == "cboe":
+            vx_eod_symbols = ["vx", "vix", "vx_eod", "^vix"]
+            title = (
+                "VIX EOD Futures Curve"
+                if symbol.lower() in vx_eod_symbols
+                else "VIX Mid-Morning TWAP Futures Curve"
+            )
+            if len(dates) == 1 and dates[0] != "Current":
+                title = f"{title} for {dates[0]}"
+        else:
+            title = f"{symbol.upper()} Futures Curve"
+
+        # Use the supplied title, if any.
+        title = kwargs.get("title", title)
+
+        # Update the layout of the figure.
+        figure.update_layout(
+            title=dict(text=title, x=0.5, font=dict(size=20)),
+            plot_bgcolor=(
+                "rgba(0,0,0,0)" if text_color == "white" else "rgba(255,255,255,0)"
+            ),
+            paper_bgcolor=(
+                "rgba(0,0,0,0)" if text_color == "white" else "rgba(255,255,255,0)"
+            ),
+            xaxis=dict(
+                title="",
+                ticklen=0,
+                showgrid=False,
+                type="category",
+                categoryorder="array",
+                categoryarray=expirations,
+            ),
+            yaxis=dict(
+                title="Price ($)",
+                ticklen=0,
+                showgrid=True,
+                gridcolor="rgba(128,128,128,0.3)",
+            ),
+            legend=dict(
+                orientation="v",
+                yanchor="top",
+                xanchor="right",
+                y=0.95,
+                x=0,
+                xref="paper",
+                font=dict(size=12),
+                bgcolor=(
+                    "rgba(0,0,0,0)" if text_color == "white" else "rgba(255,255,255,0)"
+                ),
+            ),
+            margin=dict(
+                b=10,
+                t=10,
+            ),
+        )
+
+        layout_kwargs = kwargs.get("layout_kwargs", {})
+        if layout_kwargs:
+            figure.update_layout(layout_kwargs)
+
+        content = figure.show(external=True).to_plotly_json()
+
+        return figure, content

openbb_platform/extensions/derivatives/openbb_derivatives/futures/__init__.py

@@ -0,0 +1 @@
+"""Futures."""

openbb_platform/extensions/derivatives/openbb_derivatives/futures/futures_router.py

@@ -0,0 +1,97 @@
+"""Futures Router."""
+
+from openbb_core.app.model.command_context import CommandContext
+from openbb_core.app.model.example import APIEx
+from openbb_core.app.model.obbject import OBBject
+from openbb_core.app.provider_interface import (
+    ExtraParams,
+    ProviderChoices,
+    StandardParams,
+)
+from openbb_core.app.query import Query
+from openbb_core.app.router import Router
+
+router = Router(prefix="/futures")
+
+
+# pylint: disable=unused-argument
+@router.command(
+    model="FuturesHistorical",
+    examples=[
+        APIEx(parameters={"symbol": "ES", "provider": "yfinance"}),
+        APIEx(
+            description="Enter multiple symbols.",
+            parameters={"symbol": "ES,NQ", "provider": "yfinance"},
+        ),
+        APIEx(
+            description='Enter expiration dates as "YYYY-MM".',
+            parameters={
+                "symbol": "ES",
+                "provider": "yfinance",
+                "expiration": "2025-12",
+            },
+        ),
+    ],
+)
+async def historical(
+    cc: CommandContext,
+    provider_choices: ProviderChoices,
+    standard_params: StandardParams,
+    extra_params: ExtraParams,
+) -> OBBject:
+    """Historical futures prices."""
+    return await OBBject.from_query(Query(**locals()))
+
+
+@router.command(
+    model="FuturesCurve",
+    examples=[
+        APIEx(parameters={"symbol": "VX", "provider": "cboe", "date": "2024-06-25"}),
+        APIEx(
+            parameters={"symbol": "NG", "provider": "yfinance"},
+        ),
+    ],
+)
+async def curve(
+    cc: CommandContext,
+    provider_choices: ProviderChoices,
+    standard_params: StandardParams,
+    extra_params: ExtraParams,
+) -> OBBject:
+    """Futures Term Structure, current or historical."""
+    return await OBBject.from_query(Query(**locals()))
+
+
+@router.command(
+    model="FuturesInstruments",
+    examples=[
+        APIEx(parameters={"provider": "deribit"}),
+    ],
+)
+async def instruments(
+    cc: CommandContext,
+    provider_choices: ProviderChoices,
+    standard_params: StandardParams,
+    extra_params: ExtraParams,
+) -> OBBject:
+    """Get reference data for available futures instruments by provider."""
+    return await OBBject.from_query(Query(**locals()))
+
+
+@router.command(
+    model="FuturesInfo",
+    examples=[
+        APIEx(parameters={"provider": "deribit", "symbol": "BTC"}),
+        APIEx(parameters={"provider": "deribit", "symbol": "SOLUSDC"}),
+        APIEx(parameters={"provider": "deribit", "symbol": "SOL_USDC-PERPETUAL"}),
+        APIEx(parameters={"provider": "deribit", "symbol": "BTC,ETH"}),
+    ],
+)
+async def info(
+    cc: CommandContext,
+    provider_choices: ProviderChoices,
+    standard_params: StandardParams,
+    extra_params: ExtraParams,
+) -> OBBject:
+    """Get current trading statistics by futures contract symbol."""
+    return await OBBject.from_query(Query(**locals()))

openbb_platform/extensions/derivatives/openbb_derivatives/options/__init__.py

@@ -0,0 +1 @@
+"""Options."""

openbb_platform/extensions/derivatives/openbb_derivatives/options/options_router.py

@@ -0,0 +1,74 @@
+"""Options Router."""
+
+from openbb_core.app.model.command_context import CommandContext
+from openbb_core.app.model.example import APIEx
+from openbb_core.app.model.obbject import OBBject
+from openbb_core.app.provider_interface import (
+    ExtraParams,
+    ProviderChoices,
+    StandardParams,
+)
+from openbb_core.app.query import Query
+from openbb_core.app.router import Router
+
+router = Router(prefix="/options")
+
+# pylint: disable=unused-argument
+
+
+@router.command(
+    model="OptionsChains",
+    examples=[
+        APIEx(parameters={"symbol": "AAPL", "provider": "intrinio"}),
+        APIEx(
+            description='Use the "date" parameter to get the end-of-day-data for a specific date, where supported.',
+            parameters={"symbol": "AAPL", "date": "2023-01-25", "provider": "intrinio"},
+        ),
+    ],
+)
+async def chains(
+    cc: CommandContext,
+    provider_choices: ProviderChoices,
+    standard_params: StandardParams,
+    extra_params: ExtraParams,
+) -> OBBject:
+    """Get the complete options chain for a ticker."""
+    return await OBBject.from_query(Query(**locals()))
+
+
+@router.command(
+    model="OptionsUnusual",
+    examples=[
+        APIEx(parameters={"symbol": "TSLA", "provider": "intrinio"}),
+        APIEx(
+            description="Use the 'symbol' parameter to get the most recent activity for a specific symbol.",
+            parameters={"symbol": "TSLA", "provider": "intrinio"},
+        ),
+    ],
+)
+async def unusual(
+    cc: CommandContext,
+    provider_choices: ProviderChoices,
+    standard_params: StandardParams,
+    extra_params: ExtraParams,
+) -> OBBject:
+    """Get the complete options chain for a ticker."""
+    return await OBBject.from_query(Query(**locals()))
+
+
+@router.command(
+    model="OptionsSnapshots",
+    examples=[
+        APIEx(
+            parameters={"provider": "intrinio"},
+        ),
+    ],
+)
+async def snapshots(
+    cc: CommandContext,
+    provider_choices: ProviderChoices,
+    standard_params: StandardParams,
+    extra_params: ExtraParams,
+) -> OBBject:
+    """Get a snapshot of the options market universe."""
+    return await OBBject.from_query(Query(**locals()))

openbb_platform/extensions/derivatives/pyproject.toml

@@ -0,0 +1,22 @@
+[tool.poetry]
+name = "openbb-derivatives"
+version = "1.4.1"
+description = "Derivatives extension for OpenBB"
+authors = ["OpenBB Team <hello@openbb.co>"]
+license = "AGPL-3.0-only"
+readme = "README.md"
+packages = [{ include = "openbb_derivatives" }]
+
+[tool.poetry.dependencies]
+python = ">=3.9.21,<3.13"
+openbb-core = "^1.4.6"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.poetry.plugins."openbb_core_extension"]
+derivatives = "openbb_derivatives.derivatives_router:router"
+
+[tool.poetry.plugins."openbb_charting_extension"]
+derivatives = "openbb_derivatives.derivatives_views:DerivativesViews"

openbb_platform/extensions/devtools/README.md

@@ -0,0 +1,22 @@
+# The OpenBB DevTools Extension
+
+This extension aggregates the dependencies that facilitate a nice development experience
+for OpenBB. It does not contain any code itself, but rather pulls in the following dependencies:
+
+- Linters (ruff, pylint, mypy)
+- Code formatters (black)
+- Code quality tools (bandit)
+- Pre-commit hooks (pre-commit)
+- CI/CD configuration (tox, pytest, pytest-cov)
+- Jupyter kernel (ipykernel)
+- ... add your productivity booster here ...
+
+## Installation
+
+The extension is included into the dev_install.py script.
+
+Standalone installation:
+
+```bash
+pip install openbb-devtools
+```